Opérateurs de comparaison

L’ordinateur, mis en demeure de trancher

Une évaluation 2 + 3 produit un nombre. Mais la plus grande partie de ce qu’un programme a besoin de savoir n’est pas un nombre, c’est une décision. La note valide-t-elle ? Le nom d’utilisateur est-il pris ? La température est-elle dans la plage ? Les opérateurs de comparaison sont la branche de la famille arithmétique qui produit une réponse dans l’ensemble $\{\mathrm{True}, \mathrm{False}\}$ au lieu de $\mathbb{R}$.

Les six opérateurs de comparaison

Chacun compare deux valeurs et produit un bool :

5 == 5      # True   — égal
5 != 3      # True   — différent
5 < 10      # True   — inférieur à
5 <= 5      # True   — inférieur ou égal
5 > 10      # False  — supérieur à
5 >= 5      # True   — supérieur ou égal

En mathématiques vous écririez $\leq$, $\geq$, $\neq$ ; Python opte pour les <=, >=, != compatibles avec un clavier. Le sens est inchangé. Le double égal == exige une pause délibérée : c’est la question « sont-ils égaux ? », tandis qu’un seul = est un ordre d’affectation. Le signe doublé est ce qui les empêche de jamais entrer en collision.

Enchaînez les comparaisons comme un mathématicien

Supposons que $x$ appartienne à l’intervalle $[0, 10)$. Sur papier vous écrivez la condition en trois parties d’un seul souffle, $0 \leq x < 10$. Python vous laisse l’écrire exactement ainsi :

x = 5
0 <= x < 10    # True — les deux conditions tiennent
0 <= x < 3     # False — la seconde échoue

C’est une expression unique, évaluée par le même appariement que vous liriez : $0 \leq x$ puis $x < 10$, la valeur du milieu n’étant calculée qu’une fois. La comparaison enchaînée vaut $0 \leq x$ and $x < 10$, mais la forme enchaînée se lit comme les mathématiques dont elle sort.

== interroge le contenu ; is interroge l’identité

Deux questions se ressemblent et répondent différemment :

a = [1, 2, 3]
b = [1, 2, 3]
a == b    # True  — même contenu
a is b    # False — objets distincts en mémoire

c = a
a is c    # True  — le même objet

== compare les valeurs portées ; is compare les adresses mémoire. Plusieurs boîtes peuvent par hasard contenir la même liste ; il n’y a qu’un seul objet. Les deux coïncident pour les petites choses (comme les petits entiers que Python met en cache) et divergent pour tout le reste, donc la règle est stable : utilisez == pour le contenu, et réservez is au singleton unique qui n’a pas de contenu à comparer, None :

if x is None:    # correct
if x == None:    # fonctionne, mais vous posez la mauvaise question

Comparer entre types

Amener des valeurs d’ensembles différents dans une comparaison, $\mathbb{Z}$ contre $\mathbb{S}$, suit une politique fixe :

5 == 5.0      # True  — l'égalité numérique ignore le type
"5" == 5      # False — une chaîne et un int ne sont jamais égaux
"5" < 6       # TypeError: '<' not supported between str and int

Deux règles en découlent. Pour l’égalité, les valeurs numériques se comparent par la valeur, pas par le type, tandis que des valeurs de familles étrangères ne sont simplement jamais égales. Pour l’ordre, Python refuse de deviner : il n’existe pas d’ordre total qui ait un sens entre une chaîne et un entier, donc il lève TypeError plutôt que d’en inventer un.

Un exemple travaillé : la tolérance du reçu

Le piège du bruit de floats a une réponse constructive. Comparez avec tolérance comme le ferait un physicien, ou passez à des unités entières exactes :

expected = 0.3
price = 0.1 + 0.2                    # 0.30000000000000004
price == expected                    # False — bruit du float
abs(price - expected) < 1e-9         # True — dans la tolérance

Le motif est une paire de questions et une décision : sont-ils exactement égaux ? False. Et dans une proximité raisonnable ? True. La seconde est celle que le monde réel entend souvent.

Pièges courants

• = contre ==. if score = 60: est une erreur de syntaxe, Python ne vous laisse pas affecter dans une condition par accident. Le signe doublé est un garde-fou, pas une formalité.
• Égalité en virgule flottante. 0.1 + 0.2 == 0.3 est False. La représentation binaire de $0.1$ est infinie, donc la somme tombe sur $0.30000000000000004$. Comparez dans une tolérance à la place : abs((0.1 + 0.2) - 0.3) < 1e-10.
• == avec None. x == None marche par hasard ; x is None est la question que vous posez vraiment.
• L’égalité de floats demande une tolérance ; l’argent demande des unités entières. 0.1 + 0.2 == 0.3 échoue (False), alors comparez dans abs(a - b) < 1e-9 ou comptez en centimes, 120 == 12 * 10 est exact.