Introduction aux opérateurs Python

Les opérateurs sont les symboles et les mots-clés qui indiquent à Python quelle action effectuer sur une ou plusieurs valeurs. Toute expression Python significative — de x + 1 à if age >= 18 — repose sur au moins un opérateur. Python regroupe ses opérateurs en sept catégories : arithmétiques, comparaison, affectation, logiques, identité, appartenance et bit à bit. Ce chapitre explique chaque catégorie, indique quand l'utiliser et met en évidence les pièges courants.

Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des calculs mathématiques. Python en fournit sept :

Deux opérateurs méritent une attention particulière :

• / retourne toujours un float en Python 3, même lors de la division de deux entiers (4 / 2 retourne 2.0, et non 2).
• // (division entière) arrondit le résultat vers moins l'infini, et non vers zéro. Ainsi, -7 // 2 vaut -4, et non -3.

Utilisation courante : vérifier pair ou impair

L'opérateur modulo (%) est la méthode standard pour tester la divisibilité :

number = 42
if number % 2 == 0:
    print("even")
else:
    print("odd")
# Output: even

Opérateurs de comparaison

Les opérateurs de comparaison comparent deux valeurs et retournent toujours True ou False. Ils sont utilisés dans les conditions, les boucles while et partout où un résultat booléen est nécessaire.

Chaînage de comparaisons

Python vous permet de chaîner plusieurs comparaisons en une seule expression, ce qui se lit plus naturellement que dans la plupart des autres langages :

x = 7
print(1 < x < 10)   # True  — equivalent to (1 < x) and (x < 10)
print(0 < x < 5)    # False

Piège : == vs =

= est l'opérateur d'affectation ; == teste l'égalité. Utiliser = à l'intérieur d'une condition est une SyntaxError en Python (contrairement à certains autres langages où cela effectue silencieusement une affectation).

Opérateurs d'affectation

Les opérateurs d'affectation stockent des valeurs dans des variables. Les formes composées (+=, -=, …) combinent une opération arithmétique ou bit à bit avec une affectation, rendant le code plus concis.

L'opérateur morse := (Python 3.8+)

L'opérateur morse affecte une valeur à l'intérieur d'une expression. Il est utile quand on veut à la fois évaluer et stocker un résultat sans écrire l'expression deux fois :

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Without walrus: compute length twice
if len(numbers) > 5:
    print(f"Long list: {len(numbers)} items")

# With walrus: assign once, use in condition and body
if (n := len(numbers)) > 5:
    print(f"Long list: {n} items")
# Output: Long list: 10 items

Opérateurs logiques

Les opérateurs logiques combinent ou inversent des expressions booléennes. Python utilise des mots-clés en anglais plutôt que des symboles (&&, ||, !).

Évaluation en court-circuit

Python évalue and et or paresseusement (de gauche à droite) et s'arrête dès que le résultat est déterminé :

• False and <anything> — le côté droit n'est jamais évalué.
• True or <anything> — le côté droit n'est jamais évalué.

Cela a de l'importance quand le membre droit a un effet de bord ou pourrait lever une erreur :

user_input = ""
name = user_input or "Anonymous"
print(name)   # Anonymous  (empty string is falsy, so "Anonymous" is returned)

Valeurs truthy et falsy

Les opérateurs logiques fonctionnent avec n'importe quelle valeur, pas seulement True/False. Python traite 0, "", None, [], {} et () comme falsy ; tout le reste est truthy.

Consultez le chapitre Python Data Types pour une liste complète des valeurs falsy par type.

Opérateurs d'identité

Les opérateurs d'identité testent si deux variables pointent vers le même objet en mémoire, et non pas simplement si elles contiennent des valeurs égales.

Quand utiliser is plutôt que ==

Utilisez is uniquement lorsque vous souhaitez intentionnellement vérifier l'identité d'un objet — le plus souvent lors de la comparaison à des singletons :

value = None
if value is None:       # correct idiom
    print("No value provided")

# Never do: if value == None — works but is considered bad style

Python met en cache les petits entiers (généralement de -5 à 256) et interne les string, donc a is b peut retourner True pour deux petits entiers créés séparément. Ne vous fiez jamais à ce comportement pour les entiers ou les string — utilisez == pour l'égalité de valeur.

Opérateurs d'appartenance

Les opérateurs d'appartenance testent si une valeur existe dans une séquence (liste, tuple, string, set ou dictionnaire).

Note sur les performances

Pour les listes et les tuples, in vérifie chaque élément séquentiellement (O(n)). Pour les sets et les clés de dictionnaire, in utilise une table de hachage et s'exécute en temps constant (O(1)). Préférez un set lorsque vous avez besoin de nombreux tests d'appartenance sur une grande collection.

Opérateurs bit à bit

Les opérateurs bit à bit travaillent sur la représentation binaire des entiers, en manipulant les bits individuels.

Pourquoi les opérateurs bit à bit sont importants

Dans la plupart du code Python quotidien, vous n'utiliserez pas directement les opérateurs bit à bit, mais ils apparaissent fréquemment dans :

• Les drapeaux et permissions — combinaison de masques de bits pour représenter plusieurs options dans un seul entier.
• La cryptographie et le hachage — XOR est un bloc de construction de base.
• Les calculs efficaces — n << 1 est plus rapide que n * 2 dans les boucles critiques pour les performances.
• Le travail avec les protocoles binaires — analyse des paquets réseau ou des en-têtes de fichiers.

Précédence des opérateurs

Lorsqu'une expression mélange plusieurs opérateurs, Python les évalue dans un ordre fixe (la précédence la plus haute en premier) :

# Multiplication before addition (standard math rules apply)
print(2 + 3 * 4)      # 14, not 20

# Use parentheses to override
print((2 + 3) * 4)    # 20

# ** is right-associative: 2 ** 3 ** 2 = 2 ** (3**2) = 2**9
print(2 ** 3 ** 2)    # 512, not 64

# Comparisons before logical operators
print(2 + 3 > 4 and 10 % 3 == 1)  # True and True → True

En cas de doute, utilisez des parenthèses. Elles rendent la précédence explicite et améliorent la lisibilité.

Résumé

Pour les sujets connexes, voir Python Variables, Python If...Else et Python Data Types.

Pratique