Les opérateurs en Python

Opérateurs en Python

Un opérateur est un symbole spécial qui effectue une opération sur une ou plusieurs valeurs appelées opérandes. Python propose six catégories d'opérateurs :

Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des calculs mathématiques sur des opérandes numériques (int ou float).

Exemple n°1 — Opérateurs arithmétiques

a = 10
b = 4

print(f"a + b  = {a + b}")    # addition
print(f"a - b  = {a - b}")    # soustraction
print(f"a * b  = {a * b}")    # multiplication
print(f"a / b  = {a / b}")    # division réelle
print(f"a % b  = {a % b}")    # modulo
print(f"a // b = {a // b}")   # division entière
print(f"a ** 2 = {a ** 2}")   # puissance

a + b  = 14
a - b  = 6
a * b  = 40
a / b  = 2.5
a % b  = 2
a // b = 2
a ** 2 = 100

n = 17
if n % 2 == 0:
    print(f"{n} est pair")
else:
    print(f"{n} est impair")   # 17 est impair

Opérateurs relationnels et logiques

Opérateurs relationnels

Les opérateurs relationnels comparent deux valeurs et retournent un booléen : True ou False.

Exemple n°2 — Opérateurs relationnels

a, b = 10, 4

print(f"a > b  : {a > b}")    # True
print(f"a >= b : {a >= b}")   # True
print(f"a < b  : {a < b}")    # False
print(f"a <= b : {a <= b}")   # False
print(f"a == b : {a == b}")   # False
print(f"a != b : {a != b}")   # True

a > b  : True
a >= b : True
a < b  : False
a <= b : False
a == b : False
a != b : True

note = 15
print(0 <= note <= 20)   # True  ✅ style Python
print(0 <= note and note <= 20)   # équivalent mais moins lisible

Opérateurs logiques

Les opérateurs logiques combinent plusieurs conditions et retournent un booléen.

Exemple n°3 — Opérateurs logiques

a, b, c, d = 10, 4, 10, 20

# ET logique : les deux conditions doivent être vraies
print(f"a > b and c == d : {a > b and c == d}")   # False (c != d)

# OU logique : au moins une condition vraie suffit
print(f"a > b or  c == d : {a > b or  c == d}")   # True  (a > b est vrai)

# NON logique : inverse la condition
print(f"not (a == b)     : {not (a == b)}")        # True  (a != b)
print(f"not (a == c)     : {not (a == c)}")        # False (a == c est vrai)

a > b and c == d : False
a > b or  c == d : True
not (a == b)     : True
not (a == c)     : False

a = 10
if !a:          # ❌ SyntaxError en Python !
    print("zéro")

if not a:       # ✅ correct
    print("zéro")

Opérateurs d'affectation

Les opérateurs d'affectation combinent une opération arithmétique ou binaire avec l'affectation. Ils permettent d'écrire du code plus concis.

Exemple n°4 — Opérateurs d'affectation composés

x = 10
print(f"initial  : x = {x}")

x += 5;  print(f"x += 5   : x = {x}")   # 15
x -= 3;  print(f"x -= 3   : x = {x}")   # 12
x *= 2;  print(f"x *= 2   : x = {x}")   # 24
x //= 5; print(f"x //= 5  : x = {x}")   # 4
x **= 3; print(f"x **= 3  : x = {x}")   # 64

initial  : x = 10
x += 5   : x = 15
x -= 3   : x = 12
x *= 2   : x = 24
x //= 5  : x = 4
x **= 3  : x = 64

Opérateurs binaires (bit à bit)

Les opérateurs binaires travaillent directement sur la représentation binaire des entiers, bit par bit. Soit x = 10 (0000 1010) et y = 4 (0000 0100).

Exemple n°5 — Opérateurs binaires

x, y = 10, 4   # 0000 1010  et  0000 0100

print(f"x & y  = {x & y}")    # ET  → 0
print(f"x | y  = {x | y}")    # OU  → 14
print(f"x ^ y  = {x ^ y}")    # XOR → 14
print(f"~x     = {~x}")        # NON → -11
print(f"x >> 2 = {x >> 2}")   # décalage droit  → 2
print(f"x << 2 = {x << 2}")   # décalage gauche → 40

x & y  = 0
x | y  = 14
x ^ y  = 14
~x     = -11
x >> 2 = 2
x << 2 = 40

print(10 << 1)   # 20  = 10 × 2¹
print(10 << 2)   # 40  = 10 × 2²
print(10 >> 1)   # 5   = 10 // 2¹
print(10 >> 2)   # 2   = 10 // 2²

Opérateurs spéciaux

Opérateurs d'identité — is / is not

Exemple n°6 — is vs ==

a = [1, 2, 3]
b = [1, 2, 3]   # même contenu, objet différent
c = a           # c pointe vers le même objet que a

print(f"a == b  : {a == b}")    # True  — même valeur
print(f"a is b  : {a is b}")    # False — objets différents !
print(f"a is c  : {a is c}")    # True  — même objet en mémoire
print(f"a is not b : {a is not b}")  # True

a == b  : True
a is b  : False
a is c  : True
a is not b : True

x = None
if x is None:       # ✅ usage correct de is
    print("x est None")

if x == None:       # ⚠️ fonctionne mais déconseillé (PEP 8)

Opérateurs d'appartenance — in / not in

Exemple n°7 — Opérateurs d'appartenance

villes  = ['Meknès', 'Rabat', 'Casablanca']
message = "Bonjour Mostafa"
notes   = {'maths': 18, 'info': 20}

# Liste
print('Rabat' in villes)          # True
print('Fès'   not in villes)      # True

# Chaîne
print('Mostafa' in message)       # True
print('Bonjour' not in message)   # False

# Dictionnaire — teste les clés uniquement
print('info'  in notes)           # True
print(20      in notes)           # False (20 est une valeur, pas une clé)

True
True
True
False
True
False