Python Language
Comparaisons

Syntaxe

• ! = - n'est pas égal à

• == - Est égal à

• > - supérieur à

• < - moins que

• >= - supérieur ou égal à

• <= - inférieur ou égal à

• is - teste si les objets sont exactement le même objet

• is not = test si les objets ne sont pas exactement le même objet

Paramètres

Supérieur ou inférieur à

x > y
x < y

Ces opérateurs comparent deux types de valeurs, ils sont inférieurs et supérieurs aux opérateurs. Pour les nombres, il suffit de comparer les valeurs numériques pour voir laquelle est la plus grande:

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

Pour les chaînes, ils comparent lexicographiquement, ce qui est similaire à l'ordre alphabétique mais pas tout à fait pareil.

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

Dans ces comparaisons, les lettres minuscules sont considérées comme «supérieures à» les majuscules, ce qui explique pourquoi "gamma" < "OMEGA" est faux. S'ils étaient tous en majuscules, ils renverraient le résultat de l'ordre alphabétique attendu:

"GAMMA" < "OMEGA"
# True

Chaque type définit son calcul avec les opérateurs < et > différemment, vous devez donc étudier ce que les opérateurs veulent dire avec un type donné avant de l'utiliser.

Pas égal à

x != y  

Cela renvoie True si x et y ne sont pas égaux et renvoie sinon False .

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

Égal à

x == y 

Cette expression évalue si x et y sont la même valeur et renvoie le résultat sous forme de valeur booléenne. Généralement, le type et la valeur doivent correspondre, donc l'int 12 n'est pas la même que la chaîne '12' .

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

Notez que chaque type doit définir une fonction qui sera utilisée pour évaluer si deux valeurs sont identiques. Pour les types intégrés, ces fonctions se comportent comme prévu et évaluent simplement les choses en fonction de la même valeur. Cependant, les types personnalisés peuvent définir le test d'égalité comme ils le souhaitent, notamment en renvoyant toujours True ou en retournant toujours False .

Comparaisons en chaîne

Vous pouvez comparer plusieurs éléments avec plusieurs opérateurs de comparaison avec une comparaison en chaîne. Par exemple

x > y > z

est juste une forme abrégée de:

x > y and y > z

Ceci évaluera à True seulement si les deux comparaisons sont True .

La forme générale est

a OP b OP c OP d ...

Où OP représente l'une des multiples opérations de comparaison que vous pouvez utiliser, et les lettres représentent des expressions valides arbitraires.

Notez que 0 != 1 != 0 0 != 0 vaut True , même si 0 != 0 est False . Contrairement à la notation mathématique commune dans laquelle x != y != z signifie que x , y et z ont des valeurs différentes. Le chaînage des opérations == a un sens naturel dans la plupart des cas, puisque l'égalité est généralement transitive.

Style

Il n'y a pas de limite théorique sur le nombre d'éléments et d'opérations de comparaison que vous utilisez tant que vous avez la syntaxe appropriée:

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

Ce qui précède renvoie True si chaque comparaison renvoie True . Cependant, utiliser un chaînage compliqué n'est pas un bon style. Un bon chaînage sera "directionnel", pas plus compliqué que

1 > x > -4 > y != 8

Effets secondaires

Dès qu'une comparaison renvoie False , l'expression est immédiatement évaluée à False , en ignorant toutes les comparaisons restantes.

Notez que l'expression exp dans a > exp > b sera évaluée une seule fois, alors que dans le cas de

a > exp and exp > b

exp sera calculée deux fois si a > exp est vraie.

Comparaison par `is` vs` == `

Un écueil courant confond les opérateurs de comparaison de l' égalité is et == .

a == b compare la valeur de a et b .

a is b comparera les identités de a et b .

Pour illustrer:

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 [!!]

Fondamentalement, is peut être considéré comme un raccourci pour id(a) == id(b) .

Au-delà de cela, il existe des particularités de l'environnement d'exécution qui compliquent davantage les choses. Les chaînes courtes et les petits entiers renvoient True par rapport à is , car la machine Python tente d'utiliser moins de mémoire pour des objets identiques.

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

Mais les chaînes plus longues et les entiers plus grands seront stockés séparément.

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

Vous devez utiliser is de tester pour None :

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

Une utilisation de is de tester un "sentinelle" (c'est-à-dire un objet unique).

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

Comparer des objets

Pour comparer l'égalité des classes personnalisées, vous pouvez remplacer == et != définissant les méthodes __eq__ et __ne__ . Vous pouvez également remplacer __lt__ ( < ), __le__ ( <= ), __gt__ ( > ) et __ge__ ( > ). Notez que vous devez uniquement remplacer deux méthodes de comparaison, et Python peut gérer le reste ( == est le même que not < et not > , etc.)

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

Notez que cette simple comparaison suppose que l' other (l'objet comparé à) est le même type d'objet. La comparaison avec un autre type provoquera une erreur:

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'

Vérifier isinstance() ou similaire aidera à empêcher cela (si désiré).

Common Gotcha: Python n'impose pas la saisie

Dans beaucoup d'autres langues, si vous exécutez ce qui suit (exemple Java)

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

... vous aurez une erreur. Vous ne pouvez pas simplement comparer des chaînes à des entiers comme celui-là. En Python, il s’agit d’une déclaration parfaitement légale - elle se résume à False .

Un gotcha commun est le suivant

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

Cette comparaison sera évaluée à False sans erreur, à chaque fois, masquant potentiellement un bogue ou interrompant une condition.