Les opérateurs sont les outils de calcul de Python. Ce chapitre couvre les trois grandes familles : arithmétiques (pour les nombres), de comparaison (pour tester), logiques (pour combiner des conditions). On termine par les opérateurs d’affectation combinée, très courants au TOSA.
Python dispose des opérateurs mathématiques classiques, plus quelques ajouts utiles :
| Opérateur | Nom | Exemple | Résultat |
|---|---|---|---|
+ |
Addition | 3 + 2 |
5 |
- |
Soustraction | 5 - 2 |
3 |
* |
Multiplication | 3 * 4 |
12 |
/ |
Division réelle | 7 / 2 |
3.5 |
// |
Division entière | 7 // 2 |
3 |
% |
Modulo (reste) | 7 % 2 |
1 |
** |
Puissance | 2 ** 10 |
1024 |
Démonstrations :
print("Addition :", 3 + 2)
print("Soustraction :", 10 - 3)
print("Multiplication :", 4 * 5)
print("Division :", 7 / 2)
print("Division entière:", 7 // 2)
print("Modulo :", 7 % 2)
print("Puissance :", 2 ** 10)Addition : 5
Soustraction : 7
Multiplication : 20
Division : 3.5
Division entière: 3
Modulo : 1
Puissance : 1024/ vs //
/ fait une division réelle et renvoie toujours un float — même si le résultat est entier !// fait une division entière (tronque vers le bas).print(10 / 2) # 5.0 (float, PAS 5)
print(10 // 2) # 5 (int)
print(10 / 3) # 3.3333...
print(10 // 3) # 35.0
5
3.3333333333333335
3Une question TOSA classique : « que renvoie 10 / 2 ? » → 5.0 (piège !).
//La division entière // tronque vers le bas (vers moins l’infini), pas vers zéro :
print(7 // 2) # 3
print(-7 // 2) # -4, PAS -3 !3
-4%Le modulo renvoie le reste de la division entière. Très utile pour :
n % 2 == 0 → n est pair.i % 7 → donne toujours un nombre entre 0 et 6.n % 5 == 0 → n est multiple de 5.for i in range(1, 11):
parite = "pair" if i % 2 == 0 else "impair"
print(f"{i} est {parite}")1 est impair
2 est pair
3 est impair
4 est pair
5 est impair
6 est pair
7 est impair
8 est pair
9 est impair
10 est pairLes règles sont celles des mathématiques :
()***, /, //, %+, -En cas de doute, mettez des parenthèses.
# Sans parenthèses
print(2 + 3 * 4) # 14, pas 20
# Avec parenthèses
print((2 + 3) * 4) # 2014
20Quand on veut modifier la valeur d’une variable par rapport à sa valeur actuelle, on peut utiliser des raccourcis :
| Opérateur | Équivalent | Exemple |
|---|---|---|
+= |
x = x + v |
x += 5 |
-= |
x = x - v |
x -= 3 |
*= |
x = x * v |
x *= 2 |
/= |
x = x / v |
x /= 4 |
//= |
x = x // v |
x //= 3 |
%= |
x = x % v |
x %= 10 |
**= |
x = x ** v |
x **= 2 |
Exemple d’utilisation :
compteur = 0
compteur += 1 # compteur vaut maintenant 1
compteur += 1 # compteur vaut maintenant 2
compteur += 5 # compteur vaut maintenant 7
print(compteur)7prix = 100
prix *= 1.20 # applique une majoration de 20%
print(prix)120.0x += 1 à x = x + 1 ?
x ».C’est la norme en Python. Le TOSA teste souvent cette notation.
Ces opérateurs renvoient toujours un booléen (True ou False).
| Opérateur | Signification | Exemple | Résultat |
|---|---|---|---|
== |
Égal à | 3 == 3 |
True |
!= |
Différent de | 3 != 4 |
True |
< |
Strictement inférieur | 3 < 5 |
True |
> |
Strictement supérieur | 5 > 3 |
True |
<= |
Inférieur ou égal | 3 <= 3 |
True |
>= |
Supérieur ou égal | 3 >= 4 |
False |
age = 18
print("Majeur ?", age >= 18)
print("Mineur ?", age < 18)
print("Pile 18 ?", age == 18)Majeur ? True
Mineur ? False
Pile 18 ? True= vs == : ne pas confondre !
= est l’affectation (donne une valeur à une variable).== est la comparaison (teste si deux valeurs sont égales).if age = 18: # ❌ SyntaxError
print("Oui")Cell In[9], line 1 if age = 18: # ❌ SyntaxError ^ SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?
age = 18
if age == 18: # ✅ Correct
print("Oui")OuiPython permet d’écrire des comparaisons à la façon mathématique :
age = 25
# Python autorise 18 <= age < 65 (plus lisible)
if 18 <= age < 65:
print("Adulte actif")Adulte actifC’est équivalent à age >= 18 and age < 65 mais bien plus lisible. Cette syntaxe est spécifique à Python — elle n’existe pas dans la plupart des autres langages.
Ces opérateurs combinent des booléens :
| Opérateur | Sens | Exemple |
|---|---|---|
and |
ET logique | True and False → False |
or |
OU logique | True or False → True |
not |
NON logique (inverse) | not True → False |
Table de vérité :
print("and :")
print(" T and T =", True and True)
print(" T and F =", True and False)
print(" F and F =", False and False)
print("or :")
print(" T or T =", True or True)
print(" T or F =", True or False)
print(" F or F =", False or False)
print("not :")
print(" not T =", not True)
print(" not F =", not False)and :
T and T = True
T and F = False
F and F = False
or :
T or T = True
T or F = True
F or F = False
not :
not T = False
not F = TrueUsage typique :
age = 25
permis = True
peut_conduire = age >= 18 and permis
print("Peut conduire :", peut_conduire)Peut conduire : TrueImportant pour le TOSA : Python évalue les opérateurs and et or en court-circuit :
A and B : si A est False, B n’est même pas évalué (c’est déjà False).A or B : si A est True, B n’est même pas évalué (c’est déjà True).Exemple pratique : éviter une division par zéro.
x = 0
# Si x == 0, la deuxième partie N'EST PAS évaluée, donc pas de ZeroDivisionError
if x != 0 and 10 / x > 2:
print("OK")
else:
print("x vaut zéro ou le quotient est petit")x vaut zéro ou le quotient est petitinin teste si un élément appartient à une collection (liste, tuple, chaîne, ensemble, dictionnaire).
print("a" in "abc") # True
print(3 in [1, 2, 3]) # True
print("nom" in {"nom": "Alice"}) # True (regarde les clés du dict)
print(5 in (1, 2, 3)) # FalseTrue
True
True
FalseSon contraire : not in.
print("z" not in "abc") # TrueTrueOn reviendra longuement sur in dans les chapitres sur les structures de données.
Que renvoie 10 / 2 ?
55.05.5b) 5.0 — l’opérateur / renvoie toujours un float, même si le résultat est « entier ». Pour obtenir un entier, utilisez //.
print(10 / 2, type(10 / 2))
print(10 // 2, type(10 // 2))5.0 <class 'float'>
5 <class 'int'>Que vaut 17 % 5 ?
323.412b) 2 — le modulo renvoie le reste de la division. 17 = 5 × 3 + 2, donc 17 % 5 == 2.
print(17 % 5)2Que vaut x après ce code ?
x = 10
x **= 2102010012c) 100 — x **= 2 équivaut à x = x ** 2, soit x = 10 ** 2 = 100.
x = 10
x **= 2
print(x)100Que renvoie True and False or True ?
TrueFalsea) True — and est prioritaire sur or. L’expression s’évalue comme (True and False) or True, soit False or True, soit True.
print(True and False or True)
print((True and False) or True) # équivalent avec parenthèsesTrue
TrueQue renvoie 3 < 5 < 10 ?
TrueFalseSyntaxErrorTypeErrora) True — Python autorise les comparaisons chaînées, équivalentes à (3 < 5) and (5 < 10).
print(3 < 5 < 10)
print(3 < 5 and 5 < 10)True
TrueQue renvoie -7 // 2 ?
-3-4-3.53b) -4 — la division entière tronque vers le bas (vers moins l’infini), pas vers zéro. Piège classique !
print(-7 // 2)
print(7 // 2)-4
3Que s’affiche-t-il ?
x = 5
print(x > 0 and x < 10)TrueFalse5True Truea) True — 5 > 0 est vrai ET 5 < 10 est vrai, donc l’expression combinée est True.
x = 5
print(x > 0 and x < 10)TrueUn produit coûte 150 € HT. Calculez et affichez :
prix_ht = 150
taux_tva = 0.20
tva = ...
prix_ttc = ...
print("TVA :", tva, "€")
print("Prix TTC :", prix_ttc, "€")prix_ht = 150
taux_tva = 0.20
tva = prix_ht * taux_tva
prix_ttc = prix_ht + tva
print("TVA :", tva, "€")
print("Prix TTC :", prix_ttc, "€")TVA : 30.0 €
Prix TTC : 180.0 €prix = 150
prix *= 1.20 # ajoute 20% directement
print("Prix TTC :", prix, "€")Prix TTC : 180.0 €Écrivez un programme qui demande un nombre entier à l’utilisateur et affiche s’il est pair ou impair.
Indice : un nombre est pair si son reste par 2 vaut 0.
nombre_txt = input("Entrez un nombre entier : ")
nombre = int(nombre_txt)
# Votre code : afficher "pair" ou "impair"nombre = 42 # au lieu de input() pour la démo
if nombre % 2 == 0:
print(nombre, "est pair")
else:
print(nombre, "est impair")42 est pairVersion avec un autre nombre :
nombre = 17
if nombre % 2 == 0:
print(nombre, "est pair")
else:
print(nombre, "est impair")17 est impairAvec une expression ternaire (vu au chapitre suivant) :
nombre = 42
parite = "pair" if nombre % 2 == 0 else "impair"
print(nombre, "est", parite)42 est pairUne durée est donnée en secondes. Écrivez un programme qui la décompose en heures, minutes, secondes.
Par exemple, pour 3725 secondes, on veut afficher : 1 h 2 min 5 s.
Indice : utilisez // et %.
duree = 3725 # secondes
heures = ...
minutes = ...
secondes = ...
print(heures, "h", minutes, "min", secondes, "s")duree = 3725
heures = duree // 3600 # nombre d'heures complètes
reste = duree % 3600 # secondes restantes après les heures
minutes = reste // 60 # nombre de minutes complètes
secondes = reste % 60 # secondes finales
print(heures, "h", minutes, "min", secondes, "s")1 h 2 min 5 sdef decomposer(duree):
heures = duree // 3600
reste = duree % 3600
minutes = reste // 60
secondes = reste % 60
return heures, minutes, secondes
for d in [60, 3600, 3725, 86400]:
h, m, s = decomposer(d)
print(f"{d} s = {h} h {m} min {s} s")60 s = 0 h 1 min 0 s
3600 s = 1 h 0 min 0 s
3725 s = 1 h 2 min 5 s
86400 s = 24 h 0 min 0 sLes fonctions seront vues en détail en Partie 2.
/ renvoie toujours un float, // renvoie un entier (troncature vers le bas).% (modulo) donne le reste d’une division : très utile pour la parité et les cycles.x += v est l’équivalent concis de x = x + v. À utiliser systématiquement.= (affectation) et == (comparaison).18 <= age < 65.and et or évaluent en court-circuit — pratique pour éviter des erreurs.in teste l’appartenance à une collection : pratique et très testé au TOSA.← Chapitre précédent : Variables et types • Chapitre suivant : Les chaînes →