Comparaisons en

À propos de Comparaisons

Un opérateur de comparaison en Python (aussi appelé opérateur relationnel), examine les valeurs de deux opérandes et renvoie un booléen True ou False selon que la condition de comparaison est remplie ou non.

Le tableau ci-dessous présente les opérateurs de comparaison les plus courants en Python :

Ils ont tous la même priorité (plus élevée que celle des opérations booléennes, mais plus faible que celle des opérations arithmétiques ou bit à bit).

Comparaison entre différents types de données

Des objets de types différents (sauf les types numériques) ne sont jamais égaux par défaut lors d'une comparaison. De même, des instances non identiques d'une class ne seront pas considérées comme égales, sauf si la class définit des méthodes spéciales de comparaison enrichie qui personnalisent le comportement de comparaison par défaut des object. Pour plus (beaucoup plus) de détails, consulte Comparaisons de valeurs dans la documentation Python.

Les types numériques font (en grande partie) exception à cette règle de correspondance des types. Un integer peut être considéré comme égal à un float (ou un octal égal à un hexadecimal), tant que les types peuvent être convertis implicitement pour la comparaison.

Pour les autres types numériques (complexes, décimaux, fractions), les opérateurs de comparaison sont définis là où ils « ont du sens » (là où la conversion implicite ne change pas le résultat), mais lèvent une TypeError si les objets sous-jacents ne peuvent pas être convertis avec précision pour la comparaison. Pour plus d'informations sur les règles que Python applique à la conversion numérique, consulte conversions arithmétiques dans la documentation Python.

>>> import fractions

# A string cannot be converted to an int.
>>> 17 == '17'
False

# An int can be converted to float for comparison.
>>> 17 == 17.0
True

# The fraction 6/3 can be converted to the int 2
# The int 2 can be converted to 0b10 in binary.
>>> 6/3 == 0b10
True

# An int can be converted to a complex 
# number with a 0 imaginary part.
>>> 17 == complex(17)
True

# The fraction 2/5 can be converted to the float 0.4
>>> 0.4 == 2/5
True

>>> complex(2/5, 1/2) == complex(0.4, 0.5)
True

Toute comparaison ordonnée d'un nombre avec un NaN (not a number, autrement dit « pas un nombre ») vaut False. Un effet secondaire déroutant de la définition de NaN en Python est que NaN n'est jamais égal à NaN. Si tu es curieux de savoir pourquoi NaN a été défini ainsi en Python, ce post Stack Overflow sur NaN consacré à l'établissement de la norme internationale est une lecture intéressante.

>>> x = float('NaN')

>>> 3 < x
False

>>> x < 3
False

# NaN never compares equal to NaN
>>> x == x
False

Comparer des strings

Les strings (str) sont comparées lexicographiquement, en utilisant leurs points de code Unicode individuels (le résultat de passer chaque point de code du str à la fonction intégrée ord(), qui renvoie un int). Si tous les points de code des deux strings correspondent et sont dans le même ordre, les deux strings sont considérées comme égales. Cette comparaison s'effectue par paires, la première avec la première, la deuxième avec la deuxième, etc. En Python 3.x, str et bytes ne peuvent pas être convertis ou comparés directement.

>>> 'Python' > 'Rust'
False

>>> 'Python' > 'JavaScript'
True

# Examples with Mandarin.
# hello < goodbye
>>> '你好' < '再见'
True

# ord() of first characters
>>> ord('你'), ord('再')
(20320, 20877)

# ord() of second characters
>>> ord('好'), ord('见')
(22909, 35265)

# And with Korean words.
# Pretty < beautiful.
>>> '예쁜' < '아름다운'
False

>>> ord('예'), ord('아')
(50696, 50500)

Comparer des types de conteneurs

Les types de conteneurs (lists, tuples, sets, dicts, etc.) se comparent eux aussi de manière lexicographique : ils sont égaux si les deux conteneurs contiennent les mêmes données et les mêmes types de données (dans le cas des lists et des tuples, ils doivent également avoir le même ordre), et inégaux sinon.

>>> [1, 2] == [1, 2]
True

# But if the data is not in the same order, they are not equal.
>>> [2, 1] == [1, 2]
False

# The same holds true for tuples
>>> (3,4,5) == (5,4,3)
False

# Length is also compared
>>> [1, 2] < [1, 2, 3]
True

# Comparing dicts
>>> {'name': 'John', 'age': 19} == {'name': 'John', 'age': 18}
False

>>> {'name': 'John', 'age': 19} == {'name': 'John', 'age': 19}
True

Chaînage de comparaisons

Les opérateurs de comparaison peuvent être chaînés de manière arbitraire. Note que l'évaluation d'une expression se fait de left à right. Par exemple, x < y <= z est équivalent à x < y and y <= z, sauf que y n'est évalué qu'une seule fois. Dans les deux cas, z n'est pas évalué du tout lorsque x < y s'avère valoir False. C'est ce qu'on appelle souvent l'évaluation en short-circuit evaluation : elle s'arrête dès que la valeur de vérité de l'expression a déjà été déterminée.

Short circuiting est pris en charge par divers opérateurs booléens, par des fonctions, ainsi que par le chaînage de comparaisons en Python. Contrairement à de nombreux autres langages de programmation, notamment C, C++, C# et Java, les expressions chaînées comme a < b < c en Python ont une interprétation mathématique et une priorité conventionnelles.

>>> x = 2
>>> y = 5
>>> z = 10

>>> x < y < z
True

>>> x < y > z
False

>>> x > y < z
False

Comparaisons d'identité

Les opérateurs is et is not testent l'identité d'un objet, par opposition à sa valeur. L'identité d'un objet ne change jamais après sa création et peut être obtenue à l'aide de la fonction id().

<apple> is <orange> est évalué à True si et seulement si id(<apple>) == id(<orange>). <apple> is not <orange> donne l'inverse.

En raison de leur statut de singleton, None et NotImplemented doivent toujours être comparés aux éléments à l'aide de is et is not. Consulte la documentation de référence Python sur les comparaisons de valeurs et PEP8 pour plus de détails sur cette convention.

# A list of favorite numbers.
>>> my_fav_numbers = [1, 2, 3]

>>> your_fav_numbers = my_fav_numbers

>>> my_fav_numbers is your_fav_numbers
True

# The returned id will differ by system and Python version.
>>> id(my_fav_numbers)
4517478208

# your_fav_numbers is only an alias pointing to the original my_fav_numbers object.
# Assigning a new name does not create a new object.
>>> id(your_fav_numbers)
4517478208


>>> my_fav_numbers is not your_fav_numbers
False

>>> my_fav_numbers is not None
True

>>> my_fav_numbers is NotImplemented
False

Comparaisons d'appartenance

Les opérateurs in et not in testent l'appartenance. <fish> in <soup> est évalué à True si <fish> est un membre de <soup> (si <fish> est un sous-ensemble de <soup> ou est contenu dans comparison), et à False sinon. <fish> not in <soup> renvoie la négation, c'est-à-dire l'inverse de <fish> in <soup>.

Pour les types string et bytes, <name> in <fullname> vaut True si et seulement si <name> est une sous-chaîne de <fullname>.

# A set of lucky numbers.
>>> lucky_numbers = {11, 22, 33}
>>> 22 in lucky_numbers
True

>>> 44 in lucky_numbers
False

# A dictionary of employee information.
>>> employee = {'name': 'John Doe', 'id': 67826, 'age': 33, 'title': 'ceo'}

# Checking for the membership of certain keys.
>>> 'age' in employee
True

>>> 33 in employee
False

>>> 'lastname' not in employee
True

# Checking for substring membership
>>> name = 'Super Batman'
>>> 'Bat' in name
True

>>> 'Batwoman' in name
False

Le comportement de comparaison des objets peut être personnalisé en implémentant des rich comparison methods. Pour plus d'informations, consulte Python Tutorial: classes, Python Classes and Magic Methods (Dan Bader) et Special method names.