Opérateurs Python : arithmétiques, comparaison, logiques, appartenance et identité

Les opérateurs sont juste des symboles pour des actions

Un opérateur est un symbole (ou un court mot-clé) qui dit à Python de faire quelque chose avec une ou deux valeurs - les additionner, les comparer, vérifier si l'une contient l'autre. Tu en connais déjà quelques-uns grâce aux maths de base ; Python en a quelques-uns en plus pour la logique, l'appartenance et l'identité.

On va passer les principales catégories une à une.

Opérateurs arithmétiques

Les opérateurs mathématiques standard, plus deux spécialités Python :

print(10 + 3)   # 13
print(10 - 3)   # 7
print(10 * 3)   # 30
print(10 / 3)   # 3.3333333... - / renvoie toujours un float
print(10 // 3)  # 3 - division entière, supprime le reste
print(10 % 3)   # 1 - modulo, le reste
print(10 ** 3)  # 1000 - exposant

Deux éléments de cette liste sont faciles à oublier :

• / renvoie un float même quand les deux côtés sont des entiers. 10 / 2 te donne 5.0. Pour une division entière, utilise //.
• % est le modulo. n % 2 == 0 est la façon la plus propre de tester si n est pair.

Python suit la priorité mathématique standard : ** lie plus fort que * et /, qui lient plus fort que + et -. Les parenthèses priment sur tout :

print(2 + 3 * 4)      # 14, pas 20
print((2 + 3) * 4)    # 20

Utilise les parenthèses généreusement quand il y a le moindre doute. Elles ne coûtent rien et rendent l'intention évidente.

Opérateurs de comparaison

Six comparaisons, chacune renvoyant un booléen :

print(5 == 5)    # True - égal ?
print(5 != 6)    # True - différent ?
print(5 < 6)     # True
print(5 <= 5)    # True
print(6 > 5)     # True
print(6 >= 6)    # True

Python te permet d'enchaîner les comparaisons, ce qui est inhabituel et utile :

age = 25

if 18 <= age < 65:
    print("Working age")

Ça se lit « age est au moins 18 et inférieur à 65 ». Sous le capot, c'est équivalent à 18 <= age and age < 65, mais ça se lit plus comme les maths.

Opérateurs logiques

Écrits comme des mots anglais, pas comme des symboles :

logged_in = True
is_admin = False

print(logged_in and is_admin)   # False - les deux doivent être vrais
print(logged_in or is_admin)    # True - au moins un doit être vrai
print(not logged_in)            # False - inverse le booléen

Deux détails à connaître :

Évaluation court-circuit. and s'arrête à la première valeur falsy ; or s'arrête à la première valeur truthy. Le côté droit n'est même pas évalué si le côté gauche a déjà décidé la réponse. Ça te permet de te protéger des erreurs en toute sécurité :

name = None

# name.upper() planterait si name vaut None,
# mais le court-circuit nous sauve.
if name is not None and name.upper() == "ADMIN":
    print("Admin access")
else:
    print("Not admin")

and/or renvoient la valeur, pas toujours True/False. Ils renvoient celui des opérandes qui a décidé le résultat :

print(0 or "default")    # "default"
print("" or "default")   # "default"
print("value" or "fallback")  # "value"

print(1 and "end")       # "end"
print(0 and "never")     # 0

Tu verras name = user_input or "anonymous" dans du vrai code - c'est un motif de valeur par défaut bâti sur ce comportement.

Pour les règles complètes de ces trois opérateurs, y compris les valeurs qui comptent comme falsy, l'ordre de priorité entre not, and et or et la raison pour laquelle and n'est pas la même chose que &, consulte and, or et not en Python.

Opérateurs d'affectation

= affecte. Les formes composées combinent une opération avec une affectation :

n = 10

n += 5    # comme n = n + 5
n -= 2    # n = n - 2
n *= 3    # n = n * 3
n //= 2   # n = n // 2
n %= 4    # n = n % 4
n **= 2   # n = n ** 2

print(n)

Les formes composées marchent aussi pour les chaînes (s += "more") et les listes (lst += [4, 5]). Elles ne sont pas plus rapides que la forme complète ; elles sont juste plus courtes.

Appartenance : in et not in

Teste si une valeur apparaît dans un conteneur :

colors = ["red", "green", "blue"]

print("red" in colors)         # True
print("yellow" not in colors)  # True

text = "hello world"
print("world" in text)         # True
print("z" not in text)         # True

contacts = {"alice": 1, "bob": 2}
print("alice" in contacts)     # True (vérifie les clés)

in fonctionne sur tout itérable - listes, tuples, ensembles, chaînes, dictionnaires et plus. Pour de grosses recherches, in sur une liste est en O(n) ; in sur un set ou dict est en O(1). Ça compte dès que tu vérifies l'appartenance beaucoup de fois.

Identité : is et is not

is vérifie si deux variables pointent vers le même objet en mémoire, pas juste vers des valeurs égales :

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True - même contenu
print(a is b)   # False - objets différents
print(a is c)   # True - les deux désignent la même liste

Presque toujours, tu veux ==. Le seul endroit où is brille vraiment, c'est pour vérifier contre None, True et False :

value = None

if value is None:
    print("no value")

La convention de la communauté est ferme : is None, pas == None. Pareil pour is True (même si tu en as rarement besoin).

Opérateurs bit à bit (passe à la première lecture)

Python a aussi des opérateurs bit à bit - &, |, ^, ~, <<, >> - pour manipuler les bits individuels d'un entier. Ils sont utiles en cryptographie, en réseau bas niveau et dans certains algorithmes. Tu peux les ignorer sans risque à la première lecture.

L'opérateur walrus (:=)

Python 3.8 a ajouté :=, qui affecte et renvoie une valeur dans une seule expression. Utile dans des conditions où tu veux à la fois capturer et tester un résultat :

numbers = [1, 2, 3, 4, 5]

if (count := len(numbers)) > 3:
    print(f"Got {count} items - more than expected")

Sans le walrus, tu appellerais len(numbers) deux fois ou tu ajouterais une ligne supplémentaire. Ce n'est pas essentiel ; utilise-le quand ça réduit la répétition.

Antisèche de priorité des opérateurs

Du plus serré au plus lâche pour les opérateurs que tu utiliseras vraiment :

1. ** - exposant
2. *, /, //, % - multiplication et division
3. +, - - addition et soustraction
4. <, <=, >, >=, ==, != - comparaisons
5. not
6. and
7. or

Dans le doute, mets des parenthèses. La clarté bat l'astuce.