Les opérateurs en Python

Les groupes d'opérateurs en Python

Python organise ses opérateurs en sept familles : arithmétiques, d'affectation, de comparaison, logiques, d'identité, d'appartenance et bitwise. Chacune couvre un type d'opération précis. Les sections ci-dessous passent en revue chacune d'elles avec des exemples prêts à tester.

Opérateurs arithmétiques

Ce sont les opérateurs mathématiques classiques, auxquels Python ajoute deux opérateurs bien pratiques : le modulo (%) pour récupérer le reste d'une division, et la division entière (//) pour obtenir la partie entière du résultat.

Un détail à retenir : en Python 3, la division simple (/) retourne toujours un float, même si les deux opérandes sont des entiers. Pour obtenir un entier, il faut utiliser //.

x = 17
y = 5

print(x + y)   # 22
print(x - y)   # 12
print(x * y)   # 85
print(x / y)   # 3.4  (retourne toujours un float en Python 3)
print(x % y)   # 2    (reste de 17 ÷ 5)
print(x ** y)  # 1419857  (17 à la puissance 5)
print(x // y)  # 3    (partie entière de 17 ÷ 5)

Opérateurs d'affectation

L'opérateur = assigne une valeur à une variable. Les formes abrégées comme += ou *= combinent une opération et une affectation en une seule instruction — pratique pour modifier une variable sur place sans avoir à la réécrire deux fois.

Opérateurs de comparaison

Ces opérateurs comparent deux valeurs et retournent True ou False. On les retrouve surtout dans les conditions if pour orienter l'exécution du programme. Pour les exemples ci-dessous, a = 10 et b = 20 :

a = 10
b = 20

print(a == b)  # False : 10 n'est pas égal à 20
print(a != b)  # True  : 10 est différent de 20
print(a > b)   # False : 10 n'est pas supérieur à 20
print(a < b)   # True  : 10 est inférieur à 20
print(a >= b)  # False
print(a <= b)  # True

Opérateurs logiques

and, or et not servent à combiner ou inverser des conditions booléennes. En pratique, on les utilise beaucoup dans les blocs if pour tester plusieurs conditions à la fois. Avec a = 10 et b = 20 :

a = 10
b = 20

print(a < 20 and b > 10)       # True : les deux conditions sont vraies
print(a < 20 or b > 30)        # True : la première condition suffit
print(not(a < 20 and b > 10))  # False : on inverse True, donc False

Opérateurs d'identité

is et is not ne comparent pas les valeurs — ils vérifient si deux variables pointent vers le même objet en mémoire. C'est une différence importante avec ==, qui lui compare uniquement le contenu. Deux listes avec les mêmes éléments peuvent être égales (==) sans être le même objet (is).

x = ["pomme", "banane"]
y = ["pomme", "banane"]
z = x

print(x is z)      # True  : z pointe vers le même objet que x
print(x is y)      # False : même contenu, mais deux objets distincts en mémoire
print(x == y)      # True  : == compare le contenu, pas l'adresse mémoire
print(x is not y)  # True

Opérateurs d'appartenance

in et not in vérifient si une valeur est présente dans une séquence — liste, tuple ou chaîne de caractères. Très utilisés pour tester rapidement l'existence d'un élément sans avoir à écrire une boucle.

fruits = ["pomme", "banane", "cerise"]

print("pomme" in fruits)      # True  : "pomme" est dans la liste
print("mangue" in fruits)     # False : "mangue" n'y est pas
print("mangue" not in fruits) # True

# Fonctionne aussi sur les chaînes de caractères
print("on" in "Bonjour")      # True : "on" est une sous-chaîne de "Bonjour"

Opérateurs bitwise (manipulation des bits)

Ces opérateurs travaillent directement sur la représentation binaire des entiers, bit par bit. Moins courants dans le code Python quotidien, ils deviennent utiles dans des contextes précis : manipulation de flags, cryptographie légère, traitement bas niveau, ou optimisation de performances. Pour les exemples, a = 60 (soit 0011 1100 en binaire) et b = 13 (soit 0000 1101) :

Le résultat de ~a vaut -61 car Python utilise la notation en complément à deux pour les entiers négatifs : inverser tous les bits de 60 donne -(60+1).

a = 60   # 0011 1100 en binaire
b = 13   # 0000 1101 en binaire

print(a & b)   # 12  → 0000 1100 : seuls les bits à 1 dans les deux sont conservés
print(a | b)   # 61  → 0011 1101
print(a ^ b)   # 49  → 0011 0001 : bits différents seulement
print(~a)      # -61 (complément à deux : -(a+1))
print(a << 2)  # 240 → 1111 0000 : décalage de 2 bits vers la gauche = ×4
print(a >> 2)  # 15  → 0000 1111 : décalage de 2 bits vers la droite = ÷4

Par carabde | Mis à jour le 15 mai 2026