Come confrontare le liste in Python

Per confrontare due liste Python, stabilisci prima se contano l’ordine e il numero di duplicati. Usa == per l’uguaglianza ordinata, Counter per ignorare l’ordine mantenendo le frequenze, set() per valori unici e una comprensione per mantenere l’ordine di una lista.

Gli esempi usano la libreria standard e sono stati verificati con Python 3.14.7. I metodi rispondono a domande diverse: scegli prima la semantica, poi valuta le prestazioni.

L’uguaglianza restituisce un booleano, mentre set e contatori costruiscono nuovi risultati. Cambiare rappresentazione può quindi cambiare la risposta, non solo la velocità.

Confrontare liste ordinate esatte con ==

L’uguaglianza delle liste confronta gli elementi corrispondenti da sinistra a destra. Servono stessa lunghezza, stessi valori in ogni posizione e stesso ordine; è ideale per sequenze di passi o eventi.

"""Verify that list equality considers both values and order."""

first = [1, 2, 3]
same = [1, 2, 3]
reordered = [3, 2, 1]

print(first == same)
print(first == reordered)

True
False

Il secondo confronto è False anche se le liste hanno gli stessi valori unici. L’uguaglianza diretta funziona anche con elementi non hashable, come liste annidate.

Ogni confronto segue le regole di uguaglianza dei valori, incluso __eq__ per oggetti personalizzati. Non indica dove differiscono strutture annidate: restituisce solo il risultato finale.

Confrontare liste non ordinate mantenendo i duplicati con Counter

Usa collections.Counter quando l’ordine non conta ma conta la frequenza di ogni valore. Un contatore associa ogni elemento hashable al relativo numero di occorrenze.

"""Compare unordered lists with and without duplicate multiplicity."""

from collections import Counter

left = [1, 2, 2, 3]
reordered = [3, 2, 1, 2]
fewer_duplicates = [3, 2, 1]

print(Counter(left) == Counter(reordered))
print(Counter(left) == Counter(fewer_duplicates))
print(set(left) == set(fewer_duplicates))

True
False
True

Counter rileva il secondo 2 mancante; un set elimina i duplicati e considera perciò le liste uguali. Non sostituire questa verifica con l’uguaglianza di set se le ripetizioni sono significative.

sorted(left) == sorted(right) conserva i duplicati, ma richiede valori ordinabili e crea liste ordinate. Counter esprime di solito più chiaramente l’uguaglianza delle frequenze; sorted() resta utile quando servono anche le sequenze ordinate.

Confrontare valori unici, intersezioni e differenze con set()

Converti in set quando contano solo valori distinti. & restituisce l’intersezione, - una differenza direzionale e ^ la differenza simmetrica.

L’esempio ordina i risultati dei set soltanto per mostrarli in modo deterministico: un set non ha un ordine proprio.

I set sono utili per molti test di appartenenza, ma perdono posizione e molteplicità. Non fare affidamento sull’ordine stampato da un set.

"""Verify unique-value, order-preserving, and multiplicity-aware differences."""

from collections import Counter

left = [1, 2, 2, 3, 4]
right = [2, 3, 3, 5]
left_set = set(left)
right_set = set(right)

print(sorted(left_set & right_set))
print(sorted(left_set - right_set))
print(sorted(right_set - left_set))

right_members = set(right)
print([item for item in left if item in right_members])

left_counts = Counter(left)
right_counts = Counter(right)
print(sorted((left_counts & right_counts).elements()))
print(sorted((left_counts - right_counts).elements()))
print(sorted((right_counts - left_counts).elements()))

[2, 3]
[1, 4]
[5]
[2, 2, 3]
[2, 3]
[1, 2, 4]
[3, 5]

Le prime tre righe mostrano l’intersezione di valori unici e le differenze direzionali. left_set ^ right_set produrrebbe 1, 4 e 5 in un ordine non specificato.

Mantenere l’ordine del risultato con una list comprehension

Un set non conserva l’ordine della prima lista. Crea una volta il set di appartenenza e scorri la lista del cui ordine vuoi conservare il risultato.

La quarta riga, [2, 2, 3], conserva ordine e ripetizioni di left. Per valori non hashable si può usare l’appartenenza basata sull’uguaglianza, con scansioni ripetute più costose.

Mantenere le molteplicità in intersezioni e differenze con Counter

I set rispondono a domande sui valori unici; Counter mantiene le quantità in intersezioni e differenze.

• left_counts & right_counts conserva il conteggio positivo minimo per ogni valore condiviso.
• left_counts - right_counts sottrae i conteggi e conserva solo i resti positivi.
• La sottrazione inversa restituisce gli elementi rimasti a destra.
• .elements() espande nuovamente i conteggi in singoli valori.

Nell’esempio l’intersezione multinsieme è [2, 3], non [2, 2, 3]: il minimo per 2 è uno. I resti sono [1, 2, 4] a sinistra e [3, 5] a destra.

Questo metodo è utile per inventari, voti o etichette ripetute, dove la quantità conta. Un semplice set eliminerebbe silenziosamente tale informazione.

L’aritmetica di Counter rimuove i conteggi zero e negativi da questi risultati. Esamina direttamente i contatori se l’applicazione deve mantenere tali saldi.

Gestire valori non hashabili e scegliere il metodo corretto

set() e Counter richiedono elementi hashable. Le liste annidate sono mutabili e quindi generano TypeError, mentre l’uguaglianza diretta continua a funzionare.

"""Show the unhashable-item boundary of set and Counter comparisons."""

from collections import Counter

left = [[1], [2]]
right = [[1], [2]]

print(left == right)
for name, operation in (("set", set), ("Counter", Counter)):
    try:
        operation(left)
    except TypeError as error:
        print(f"{name}: {error}")

True
set: cannot use 'list' as a set element (unhashable type: 'list')
Counter: unhashable type: 'list'

Il testo esatto dell’errore di set può cambiare tra versioni di Python; il tipo di eccezione e la causa, un elemento non hashable, sono il comportamento stabile.

Se il modello dei dati lo consente, converti le liste interne in tuple prima di usare set o Counter; altrimenti mantieni un confronto basato sull’uguaglianza adatto al risultato richiesto.