5.9 Confronti

A differenza del C, tutte le operazioni di confronto in Python hanno la stessa priorità, che è più bassa rispetto ad ogni operazione aritmetica, di scorrimento o bit per bit. Inoltre, sempre a differenza del C, espressioni come a < b < c vengono interpretate con la convenzione matematica:

`comparison`	::=	`or_expr ( comp_operator or_expr )*`
`comp_operator`	::=	`"<" \| ">" \| "==" \| ">=" \| "<=" \| "<>" \| "!="`
		`\| "is" ["not"] \| ["not"] "in"`

Confronti booleani producono i valori: True o False.

I confronti possono essere concatenati arbitrariamente, per esempio, x < y <= z è equivalente a x < y and y <= z, eccetto per il fatto che y viene valutata una sola volta (ma in entrambi i casi z non viene valutata se x < y è falsa).

Formalmente, se a, b, c, ..., y, z sono espressioni e opa, opb, ..., opy sono operatori di confronto, allora a opa b opb c ...y opy z è equivalente a a opa b and b opb c and ...y opy z, eccetto per il fatto che ogni espressione viene valutata almeno una volta.

Da notare che a opa b opb c non implica ogni tipo di comparazione tra a e c, cioè, per esempio, x < y > z è perfettamente legale (anche se non è elegante).

Le forme <> e != sono equivalenti; per consistenza col C, != è da preferire; viene anche accettato != menzionato sotto <>. La sintassi <> sta diventando obsoleta.

Gli operatori <, >, ==, >=, <= e != confrontano i valori di due oggetti. Gli oggetti non devono essere necessariamente dello stesso tipo. Se entrambi sono numeri, vengono convertiti in un tipo comune. Altrimenti, confronti tra oggetti di tipo differente sono sempre differenti, e vengono ordinati in modo consistente ma arbitrario.

(Questa definizione inusuale di confronto è stata usata per semplificare la definizione di operazioni come l'ordinamento, l'in ed il not in negli operatori. In futuro, le regole di confronto per oggetti di tipo differente verranno probabilmente modificate.)

I confronti di oggetti dello stesso tipo dipendono dal tipo:

I numeri vengono confrontati aritmeticamente.
Le stringhe vengono confrontate lessicograficamente usando le equivalenze numeriche (il risultato della funzione built-in ord()) dei loro caratteri. In questo modo, stringhe unicode e 8-bit sono completamente interoperabili.
Le tuple e le liste vengono confrontate lessicograficamente usando il confronto degli elementi corrispondenti. Questo significa che per essere uguali, ogni elemento deve essere uguale e le due sequenze devono essere dello stesso tipo e avere la stessa lunghezza.
Se non sono uguali, le sequenze vengono ordinate in base ai loro primi elementi differenti. Per esempio, cmp([1,2,x], [1,2,y]) restituisce lo stesso risultato di cmp(x,y). Se l'elemento corrispondente non esiste, viene prima ordinata la sequenza più corta (per esempio, [1,2] < [1,2,3]).
Mappe (dizionari) risultano uguali se e solo se la loro lista ordinata (chiave, valore) risulta uguale.^5.3 Altri risultati oltre l'uguaglianza vengono risolti in modo consistente, ma non vengono altrimenti definiti.^5.4
Molti altri tipi risultano disuguali a meno che non siano lo stesso oggetto; la scelta di considerare un oggetto più piccolo o più grande di un altro è arbitraria ma consistente all'interno dell'esecuzione di un programma.

Gli operatori in e not in provano l'appartenenza ad un insieme. x in s valuta se è vero che x è membro dell'insieme s e falso altrimenti. x not in s restituisce la negazione di x in s. Il test sull'appartenenza ad un insieme è stato tradizionalmente legato alle sequenze; un oggetto è membro di un insieme se l'insieme è una sequenza e contiene un elemento uguale a tale oggetto. Comunque è possibile per un oggetto supportare il test di appartenenza ad un insieme senza essere una sequenza. In particolare, i dizionari supportano tale test come un modo comodo di scrivere chiavi in un dizionario; altri tipi di mappe possono seguire i seguenti comportamenti.

Per tipi lista e tupla, x in y risulta vero se e solo se esiste un indice i così che x == y[i] sia vero.

Per tipi Unicode e stringa, x in y risulta vero se e solo se x è una sottostringa di y. Un test equivalente è y.find(x) != -1. Da notare che x e y non devono necessariamente essere dello stesso tipo; di conseguenza, u'ab' in 'abc' restituirà True. Stringhe vuote vengono sempre considerate sottostringhe di qualsiasi altra stringa, così "" in "abc" restituirà True. Modificato nella versione 2.3: Precedentemente, era richiesto che x fosse una stringa di lunghezza 1.

Per classi definite dall'utente che definiscono il metodo __contains__(), x in y è vero se e solo se y.__contains__(x) risulta vero.

Per classi definite dall'utente che non definiscono __contains__() ma definiscono __getitem__(), x in y è vero se e solo se c'è un indice i intero non negativo in modo tale che x == y[i], e tutti gli indici interi inferiori non sollevino l'eccezione IndexError. (Se viene sollevata qualsiasi altra eccezione, è come se in avesse sollevato tale eccezione).

L'operatore not in viene definito per avere il valore vero inverso di in.

Gli operatori is e is not controllano l'identità di un oggetto: x is y è vero se e solo se x e y sono lo stesso oggetto. x is not y produce una valore vero inverso.

Footnotes

... uguale.^5.3: L'implementazione lo calcola efficientemente, senza costruire liste o ordinamenti.
... definiti.^5.4: Le prime versioni di Python utilizzavano il confronto lessicofrafico delle liste ordinate (chiave, valore), ma questo era molto costoso per la maggiorparte dei casi di confronto di uguaglianza. Una versione ancora più vecchia di Python, confrontava i dizionari solo tramite le identità, ma questo causava sorprese perché le persone si aspettavano di essere in grado di verificare se un dizionario è vuoto, confrontandolo con {}.

Vedete Circa questo documento... per informazioni su modifiche e suggerimenti.