Python Language
confronti

Sintassi

• ! = - Non è uguale a

• == - È uguale a

• > - maggiore di

• < - meno di

• >= - maggiore o uguale a

• <= - inferiore o uguale a

• is - verifica se gli oggetti sono esattamente lo stesso oggetto

• is not = test se gli oggetti non sono esattamente lo stesso oggetto

Parametri

Maggiore o minore di

x > y
x < y

Questi operatori confrontano due tipi di valori, sono inferiori e maggiori degli operatori. Per i numeri questo semplicemente confronta i valori numerici per vedere quale è più grande:

12 > 4
# True
12 < 4
# False
1 < 4
# True

Per gli archi si confronteranno lessicograficamente, che è simile all'ordine alfabetico ma non esattamente lo stesso.

"alpha" < "beta"
# True
"gamma" > "beta"
# True
"gamma" < "OMEGA"
# False

In questi confronti, le lettere minuscole sono considerate "maggiori di" maiuscole, motivo per cui "gamma" < "OMEGA" è falso. Se fossero tutti maiuscoli, restituirebbe il risultato ordinato in ordine alfabetico:

"GAMMA" < "OMEGA"
# True

Ogni tipo definisce il suo calcolo con < e > operatori in modo diverso, quindi è necessario indagare su cosa gli operatori intendono con un determinato tipo prima di utilizzarlo.

Non uguale a

x != y  

Ciò restituisce True se x e y non sono uguali e altrimenti restituisce False .

12 != 1
# True
12 != '12'
# True
'12' != '12'
# False

Uguale a

x == y 

Questa espressione valuta se x ed y sono lo stesso valore e restituisce il risultato come valore booleano. Generalmente sia il tipo che il valore devono corrispondere, quindi l'int 12 non è uguale alla stringa '12' .

12 == 12
# True
12 == 1
# False
'12' == '12'
# True
'spam' == 'spam'
# True
'spam' == 'spam '
# False
'12' == 12
# False

Nota che ogni tipo deve definire una funzione che verrà utilizzata per valutare se due valori sono gli stessi. Per i tipi built-in, queste funzioni si comportano come ci si aspetterebbe e valutano solo le cose in base all'essere lo stesso valore. Tuttavia, i tipi personalizzati potrebbero definire test di uguaglianza come qualsiasi cosa vorrebbero, incluso il ritorno sempre True o il ritorno di False .

Confronti a catena

È possibile confrontare più articoli con più operatori di confronto con il confronto a catena. Per esempio

x > y > z

è solo una breve forma di:

x > y and y > z

Verrà valutato su True solo se entrambi i confronti sono True .

La forma generale è

a OP b OP c OP d ...

Dove OP rappresenta una delle operazioni di confronto multiple che è possibile utilizzare e le lettere rappresentano espressioni valide arbitrarie.

Si noti che 0 != 1 != 0 restituisce True , anche se 0 != 0 è False . A differenza della comune notazione matematica in cui x != y != z significa che x , y e z hanno valori diversi. Il concatenamento == operazioni ha il significato naturale nella maggior parte dei casi, poiché l'uguaglianza è generalmente transitiva.

Stile

Non esiste un limite teorico su quanti articoli e operazioni di confronto si utilizzano a patto di avere una sintassi corretta:

1 > -1 < 2 > 0.5 < 100 != 24

Quanto sopra restituisce True se ogni confronto restituisce True . Tuttavia, l'utilizzo del concatenamento concatenato non è un buon stile. Un buon collegamento sarà "direzionale", non più complicato di

1 > x > -4 > y != 8

Effetti collaterali

Non appena un confronto restituisce False , l'espressione viene valutata immediatamente su False , ignorando tutti i confronti rimanenti.

Si noti che l'espressione exp in a > exp > b sarà valutata solo una volta, mentre nel caso di

a > exp and exp > b

exp sarà calcolato due volte se a > exp è vero.

Confronto con `is` vs` == `

Un errore comune è confondere gli operatori di confronto di uguaglianza is e == .

a == b confronta il valore di a e b .

a is b confronterà le identità di a e b .

Illustrare:

a = 'Python is fun!'
b = 'Python is fun!'
a == b # returns True
a is b # returns False

a = [1, 2, 3, 4, 5]
b = a      # b references a
a == b     # True
a is b     # True
b = a[:]   # b now references a copy of a
a == b     # True
a is b     # False [!!]

Fondamentalmente, is può essere pensato come abbreviazione di id(a) == id(b) .

Oltre a ciò, ci sono stranezze dell'ambiente di runtime che complicano ulteriormente le cose. Le stringhe corte e gli interi piccoli restituiscono True se confrontati con is , a causa del tentativo della macchina Python di utilizzare meno memoria per oggetti identici.

a = 'short'
b = 'short'
c = 5
d = 5
a is b # True
c is d # True

Ma stringhe più lunghe e interi più grandi verranno memorizzati separatamente.

a = 'not so short'
b = 'not so short'
c = 1000
d = 1000
a is b # False
c is d # False

È necessario utilizzare is per verificare per None :

if myvar is not None:
    # not None
    pass
if myvar is None:
    # None
    pass

L'uso di is è di testare un "sentinel" (cioè un oggetto unico).

sentinel = object()
def myfunc(var=sentinel):
    if var is sentinel:
        # value wasn’t provided
        pass
    else:
        # value was provided
        pass

Confronto di oggetti

Per confrontare l'uguaglianza delle classi personalizzate, è possibile sovrascrivere == e != Definendo i metodi __eq__ e __ne__ . Puoi anche eseguire l'override di __lt__ ( < ), __le__ ( <= ), __gt__ ( > ) e __ge__ ( > ). Nota che devi solo sostituire due metodi di confronto e Python può gestire il resto ( == è lo stesso di not < e not > , ecc.)

class Foo(object):
    def __init__(self, item):
        self.my_item = item
    def __eq__(self, other):
        return self.my_item == other.my_item
    
a = Foo(5)
b = Foo(5)
a == b     # True
a != b     # False
a is b     # False

Si noti che questo semplice confronto presuppone che l' other (l'oggetto confrontato con) sia lo stesso tipo di oggetto. Il confronto con un altro tipo genera un errore:

class Bar(object):
    def __init__(self, item):
        self.other_item = item
    def __eq__(self, other):
        return self.other_item == other.other_item
    def __ne__(self, other):
        return self.other_item != other.other_item
    
c = Bar(5)
a == c    # throws AttributeError: 'Foo' object has no attribute 'other_item'

Controllare isinstance() o simili aiuterà a prevenire questo (se lo si desidera).

Common Gotcha: Python non impone la digitazione

In molti altri linguaggi, se si esegue quanto segue (esempio Java)

if("asgdsrf" == 0) {
    //do stuff
}

... avrai un errore Non puoi semplicemente confrontare le stringhe con numeri come questo. In Python, questa è una dichiarazione perfettamente legale: si risolverà su False .

Un tipico trucchetto è il seguente

myVariable = "1"
if 1 == myVariable:
    #do stuff

Questo confronto valuterà False senza errori, ogni volta, potenzialmente nascondendo un bug o rompere un condizionale.