03 - Opérateurs

Fil conducteur : l’année bissextile

Au fil de ce cours, nous allons découvrir les différentes familles d’opérateurs en Python. Pour donner du sens à chaque notion, nous construirons progressivement un programme qui vérifie si une année est bissextile. Rappelons la règle : une année est bissextile si elle est divisible par 4, sauf si elle est divisible par 100, sauf si elle est divisible par 400. Par exemple, 2024 est bissextile, 1900 ne l’est pas, et 2000 l’est.

Pour résoudre ce problème, nous aurons besoin du modulo (divisibilité), des comparaisons (tester si le reste vaut zéro), des opérateurs logiques (combiner les conditions) et de la priorité des opérations (écrire l’expression correctement). Allons-y.

Opérateurs arithmétiques

Python dispose de sept opérateurs pour effectuer des calculs sur les nombres :

Division décimale et division entière

La division décimale / renvoie toujours un flottant, même si le résultat est un nombre entier :

print(7 / 2)     # 3.5
print(10 / 2)    # 5.0  (flottant, pas entier !)
print(type(10 / 2))  # <class 'float'>

La division entière // renvoie le quotient de la division euclidienne, et le modulo % renvoie le reste :

print(17 // 5)   # 3  (quotient)
print(17 % 5)    # 2  (reste)

On retrouve bien la relation fondamentale : 17 = 5 × 3 + 2, c’est-à-dire dividende = diviseur × quotient + reste.

dividende = 17
diviseur = 5
quotient = dividende // diviseur
reste = dividende % diviseur
print(f"{dividende} = {diviseur} × {quotient} + {reste}")

17 = 5 × 3 + 2

Attention avec les flottants : si l’un des opérandes est un flottant, // et % renvoient un flottant :

print(17.0 // 5)   # 3.0  (flottant)
print(17.0 % 5)    # 2.0  (flottant)

Applications du modulo

Le modulo est très utile en programmation. Voici quelques exemples courants :

# Tester si un nombre est pair
n = 42
print(n % 2 == 0)  # True (42 est pair)

# Extraire le dernier chiffre d'un nombre
n = 2025
print(n % 10)  # 5

# Convertir des secondes en minutes et secondes
duree = 195  # secondes
minutes = duree // 60
secondes = duree % 60
print(f"{duree} s = {minutes} min {secondes} s")

True
5
195 s = 3 min 15 s

Retour au fil conducteur. Nous savons maintenant tester la divisibilité : annee % 4 == 0 sera True si annee est divisible par 4. Mais nous avons encore besoin des opérateurs de comparaison et logiques pour finaliser notre programme.

Priorité des opérations

Python respecte les règles de priorité habituelles des mathématiques :

1. Les parenthèses () ;
2. la puissance ** ;
3. le signe unaire - (opposé) ;
4. la multiplication *, la division /, // et % ;
5. l’addition + et la soustraction -.

print(2 + 3 * 4)       # 14  (pas 20)
print((2 + 3) * 4)     # 20
print(2 ** 3 ** 2)      # 512  (= 2^9, car ** est associatif à droite)

En cas de doute, ajoutez des parenthèses pour rendre l’expression plus lisible.

Opérateurs de comparaison

Les opérateurs de comparaison renvoient un booléen (True ou False) :

Important : ne pas confondre = (affectation) et == (comparaison).

note = 15       # affectation : on donne la valeur 15 à note
note == 15      # comparaison : on teste si note vaut 15 → True

Chaînage des comparaisons

Python permet de chaîner les comparaisons, comme en mathématiques :

x = 5
print(2 < x <= 9)    # True (équivalent à 2 < x and x <= 9)
print(0 <= x < 3)    # False

Opérateurs logiques

Les opérateurs and, or et not permettent de combiner des conditions :

L’opérateur and renvoie True uniquement si les deux conditions sont vraies. L’opérateur or renvoie True si au moins une des conditions est vraie. L’opérateur not inverse une condition.

age = 17
a_permis = True

print(age >= 18 and a_permis)   # False (17 < 18)
print(age >= 18 or a_permis)    # True  (a_permis est True)
print(not age >= 18)             # True  (17 n'est pas ≥ 18)

Évaluation en court-circuit

Python évalue les opérateurs logiques de gauche à droite et s’arrête dès que le résultat est connu :

• avec and : si la première condition est False, Python ne regarde pas la deuxième (le résultat sera forcément False) ;
• avec or : si la première condition est True, Python ne regarde pas la deuxième (le résultat sera forcément True).

# Ceci ne provoque pas d'erreur, car Python n'évalue pas 1/0
x = 0
print(x == 0 or 1/x > 2)   # True (court-circuit après x == 0)

Retour au fil conducteur : le programme complet

Nous avons maintenant tous les outils pour écrire notre programme. Une année est bissextile si elle est divisible par 4, sauf si elle est divisible par 100, sauf si elle est divisible par 400 :

annee = 2024
bissextile = (annee % 4 == 0) and (annee % 100 != 0 or annee % 400 == 0)
print(f"{annee} est bissextile : {bissextile}")

2024 est bissextile : True

Vérifions avec les cas particuliers :

for a in [2024, 1900, 2000, 2025]:
    b = (a % 4 == 0) and (a % 100 != 0 or a % 400 == 0)
    print(f"{a} → {b}")

2024 → True
1900 → False
2000 → True
2025 → False

Ce programme combine le modulo (%), les comparaisons (==, !=), les opérateurs logiques (and, or) et les parenthèses pour la priorité. C’est un bon exemple de la puissance des opérateurs combinés.

Opérateurs d’affectation augmentée

Pour modifier la valeur d’une variable en la combinant avec une opération, on utilise les opérateurs d’affectation augmentée :

score = 0
score += 10    # équivalent à score = score + 10
print(score)   # 10

score *= 2     # équivalent à score = score * 2
print(score)   # 20

score -= 5     # équivalent à score = score - 5
print(score)   # 15

Les opérateurs disponibles sont +=, -=, *=, /=, //=, %= et **=.

Opérateur d’appartenance in

L’opérateur in teste si un élément est présent dans une séquence :

voyelles = ['a', 'e', 'i', 'o', 'u', 'y']
print('a' in voyelles)     # True
print('b' in voyelles)     # False
print('b' not in voyelles) # True

mot = "Python"
print('y' in mot)          # True

Résumé