Come confrontare le tuple in Python

Quando si lavora con Python, spesso potrebbe essere necessario confrontare le tuple. Le tuple sono sequenze immutabili, il che significa che una volta create, non possono essere modificate. Questa caratteristica le rende particolarmente utili per memorizzare collezioni fisse di elementi. Confrontare le tuple può aiutarti a determinarne l’uguaglianza, l’ordine e persino il contenuto.

In questo articolo, esploreremo come Python confronta le tuple, dai semplici controlli di uguaglianza all’ordinamento lessicografico, e come si comportano i confronti quando le tuple differiscono per tipo, lunghezza o annidamento.

Come Python confronta le tuple

Python confronta le tuple in modo lessicografico, allo stesso modo in cui le parole sono ordinate in un dizionario. Confronta i primi elementi di ciascuna tupla; se differiscono, quella prima differenza decide il confronto, e gli elementi rimanenti non vengono mai esaminati. Se i primi elementi sono uguali, passa alla coppia successiva, e così via, finché non trova una differenza o esaurisce gli elementi. Se una tupla è un prefisso dell’altra — tutti i suoi elementi corrispondono all’inizio della tupla più lunga — la tupla più corta è considerata minore di quella più lunga.

L’operatore di uguaglianza (==) controlla se entrambe le tuple hanno gli stessi elementi nello stesso ordine, e l’operatore di disuguaglianza (!=) è il suo esatto opposto:

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)
tuple3 = (1, 2, 4)

print(tuple1 == tuple2)
print(tuple1 == tuple3)
print(tuple1 != tuple3)

Output:

True
False
True

Gli operatori di ordine (<, <=, >, >=) applicano la stessa scansione elemento per elemento, utilizzando l’ordine proprio di ciascuna coppia per decidere:

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
tuple3 = (1, 2)

print(tuple1 < tuple2)
print(tuple1 > tuple3)

Output:

True
True

Qui tuple1 è minore di tuple2 perché i primi due elementi sono uguali e 3 < 4. E tuple1 è maggiore di tuple3 perché tuple3 è un prefisso di tuple1, quindi la tupla più lunga si ordina dopo quella più corta.

Gestire tipi diversi, lunghezze e tuple annidate

Uguaglianza e ordine non trattano i tipi misti allo stesso modo, e confonderli è una fonte comune di aspettative errate.

L’uguaglianza non solleva mai un errore a causa dei tipi. Due elementi di tipi diversi sono semplicemente disuguali — con la consueta eccezione numerica per cui valori come 1 e 1.0 sono considerati uguali —, quindi un confronto tra tuple con == restituisce False, e != restituisce True, senza che nessuno controlli prima i tipi:

tuple1 = (1, "a", 3)
tuple2 = (1, 2, 3)

print(tuple1 == tuple2)
print(tuple1 != tuple2)

Output:

False
True

L’ordine è più severo. Nel momento in cui un confronto di ordine raggiunge una coppia di elementi che non possono essere ordinati l’uno rispetto all’altro, come una stringa contro un intero, solleva un TypeError invece di restituire un risultato:

tuple1 = (1, "a", 3)
tuple2 = (1, 2, 3)

print(tuple1 < tuple2)

Output:

TypeError: '<' not supported between instances of 'str' and 'int'

I primi elementi sono uguali, quindi il confronto passa a "a" contro 2 — e stringhe e interi non hanno alcun ordine tra loro, da qui l’errore. Nota che questo accade solo se il confronto raggiunge effettivamente la coppia incompatibile: (0, "a") < (1, 2) restituisce False senza errore, perché i primi elementi lo decidono già.

Lunghezze diverse interagiscono con un popolare controllo di uguaglianza elemento per elemento in un modo facile da perdere. Combinare all() con zip() confronta le coppie che zip() produce, e zip() si ferma alla tupla più corta — così gli elementi finali senza corrispondente vengono silenziosamente ignorati:

tuple1 = (1, 2, 3)
tuple2 = (1, 2)

print(all(a == b for a, b in zip(tuple1, tuple2)))
print(len(tuple1) == len(tuple2) and all(a == b for a, b in zip(tuple1, tuple2)))

Output:

True
False

La prima riga riporta True anche se le tuple non sono uguali, perché il 3 finale non viene mai confrontato. Se usi questo schema — è comodo per tuple grandi o per una logica personalizzata per elemento — abbinalo sempre a un controllo della lunghezza, come nella seconda riga.

Le tuple annidate non richiedono alcun trattamento speciale: un elemento tupla viene confrontato con le stesse regole di qualsiasi altro elemento, in modo ricorsivo. (1, 2) all’interno di una tupla si ordina prima di (3, 5) all’interno di un’altra, perché i loro primi elementi differenti lo decidono:

tuple1 = ((1, 2), (3, 4))
tuple2 = ((1, 2), (3, 5))

print(tuple1 < tuple2)
print(tuple1 == tuple2)

Output:

True
False

In breve: usa == e != quando hai solo bisogno di sapere se due tuple sono uguali — funzionano con qualsiasi contenuto. Usa gli operatori di ordine quando hai bisogno dell’ordine relativo, e assicurati che gli elementi che il confronto raggiungerà effettivamente possano essere ordinati l’uno rispetto all’altro.