Opérateurs Python : arithmétiques, de comparaison, logiques, / et //, arrondi round, ceil et floor

Les opérateurs Python sont des signes qui transforment des valeurs en nouvelles valeurs : + additionne, // effectue une division entière, and combine des conditions. Voici la liste complète des opérateurs avec des exemples, la différence entre / et //, la logique de and, or et not, ainsi que les fonctions d'arrondi : round en Python, math.ceil, math.floor et abs. Tous les exemples peuvent être testés dans l'interpréteur interactif.

Liste des opérateurs Python

Les opérateurs se répartissent par fonction. Inutile de tout mémoriser : dans le code réel, on rencontre surtout l'arithmétique, les comparaisons et les liaisons logiques.

Opérateurs arithmétiques

L'addition, la soustraction et la multiplication fonctionnent comme à l'école. Si l'expression contient au moins un float, le résultat est aussi un float : 2 + 1.0 donne 3.0. Les entiers ne débordent pas en Python — 2 ** 100 se calcule exactement, quel que soit le nombre de chiffres.

>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951

Puissance en Python : l'opérateur **

L'élévation à la puissance s'écrit avec deux astérisques, et non avec ^ : en Python, le signe ^ désigne le OU exclusif binaire, donc 2 ^ 3 donne 1 et non 8. Un exposant fractionnaire donne une racine : 9 ** 0.5 vaut 3.0. Il existe aussi la fonction pow(x, y), équivalente, avec un troisième argument pour le reste : pow(2, 10, 1000) renvoie 24.

Attention à la priorité : ** est évalué avant le moins unaire, donc -2 ** 2 vaut -4. Pour élever un nombre négatif au carré, mettez des parenthèses : (-2) ** 2.

Division en Python : /, // et %

Python propose deux divisions, et c'est la principale source de surprises pour les débutants. La division classique / renvoie toujours un float, même si la division tombe juste. La division entière // supprime la partie décimale, et % donne le reste.

>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1

Division entière // et reste % : en pratique

Le couple // et % répond à la question « combien d'unités entières, et combien reste-t-il ». Dans le cours, un suivi des dépenses stocke l'argent en centimes pour ne pas perdre de précision, puis répartit la somme en euros et centimes :

centimes = 125050         # on stocke l'argent en centimes
euros = centimes // 100   # 1250 : euros entiers
cents = centimes % 100    # 50 : le reste
print(euros, cents)       # 1250 50

print(40 // 7, "semaines et", 40 % 7, "jours")   # 5 semaines et 5 jours

La fonction intégrée divmod renvoie les deux résultats d'un coup : divmod(125050, 100) donne le tuple (1250, 50). Le reste sert aussi à tester la parité : n % 2 == 0 est vrai pour les nombres pairs.

Nombres négatifs : // arrondit vers le bas

L'opérateur // ne fait pas que supprimer la partie décimale : il arrondit vers le bas, en direction de moins l'infini. Pour les nombres positifs, il n'y a pas de différence ; pour les négatifs, il y en a une. Le signe du reste % en Python suit celui du diviseur, si bien que l'égalité a == (a // b) * b + a % b est toujours vraie.

>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # supprimer la partie décimale, sans arrondir vers le bas
-3

Division par zéro : quelle erreur

Diviser par zéro avec l'un des trois opérateurs lève l'exception ZeroDivisionError, que l'on parle d'entiers ou de décimaux. On peut l'intercepter avec try/except, ou vérifier le diviseur à l'avance.

>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0

Opérateurs de comparaison

Les comparaisons renvoient True ou False. L'égalité s'écrit avec deux signes == ; le signe = seul est une affectation. Les chaînes se comparent caractère par caractère, selon leurs codes Unicode : "B" < "a" est vrai, car les majuscules précèdent les minuscules.

>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 <= 10     # chaîne : 1 < 5 and 5 <= 10
True
>>> 0.1 + 0.2 == 0.3
False

Les chaînes de comparaisons comme 0 <= x < 100 sont une particularité pratique de Python : inutile d'écrire and. La dernière ligne rappelle l'imprécision des décimaux : 0.1 + 0.2 donne 0.30000000000000004. Comparez les flottants avec math.isclose(a, b), et stockez l'argent en centimes ou avec Decimal.

Opérateurs logiques and, or, not

En Python, les opérateurs logiques s'écrivent en toutes lettres, et non avec les symboles && et || d'autres langages. and est vrai quand les deux parties le sont, or quand au moins une l'est, et not inverse la valeur.

Priorité : d'abord not, puis and, puis or. L'expression True or False and False vaut True, car and est évalué en premier. Dans les conditions complexes, mettez des parenthèses : c'est plus lisible pour vous et pour vos collègues.

Ce que renvoient réellement and et or

and et or ne renvoient pas forcément True ou False, mais l'un de leurs opérandes. or donne la première valeur vraie (ou la dernière, si aucune ne l'est), and donne la première valeur fausse (ou la dernière). Sont considérés comme faux : 0, 0.0, la chaîne vide, les collections vides, None et False.

>>> name = ""
>>> name or "Invité"
'Invité'
>>> 5 and 0
0
>>> not ""
True

L'évaluation est paresseuse : si le résultat est connu à partir de la partie gauche, la partie droite n'est pas calculée. Ainsi, count and total / count ne provoque pas de division par zéro quand count == 0. Contrairement aux deux autres, l'opérateur not renvoie toujours un bool.

Opérateurs is et in

== compare les valeurs, tandis que is vérifie que deux noms désignent le même objet. Deux paniers vides différents sont égaux, mais ce ne sont pas le même objet. L'unique cas où is sert en permanence est la vérification de None : if x is None.

>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True

N'utilisez pas is pour comparer des nombres ou des chaînes : cela peut « marcher » grâce à la mise en cache interne des objets, mais le résultat dépend de l'implémentation, et Python affiche un SyntaxWarning pour des constructions comme x is 5.

L'opérateur in teste l'appartenance : une sous-chaîne dans une chaîne, un élément dans une liste, une clé dans un dictionnaire. not in est sa négation.

>>> "café" in "café avec soi"
True
>>> "repas" in {"repas": 450, "taxi": 300}
True
>>> 5 not in [1, 2, 3]
True

Opérateurs d'affectation et opérateur walrus :=

Les opérateurs composés +=, -=, *=, //= et les autres sont des raccourcis : total += 250 signifie total = total + 250. Python n'a pas d'opérateurs ++ et -- : x++ provoque une erreur de syntaxe.

L'opérateur :=, surnommé « walrus » (morse) par analogie avec la forme des yeux et des défenses de l'animal, affecte une valeur à l'intérieur d'une expression. Il est utile quand une valeur doit être à la fois testée et réutilisée :

items = ["café", "taxi", "déjeuner", "cinéma"]
if (n := len(items)) > 3:
    print(f"Trop de dépenses : {n}")

while (line := input("Montant : ")) != "":
    print(int(line) * 2)

Sans walrus, il faudrait appeler len deux fois ou placer l'affectation sur une ligne à part. Ne l'utilisez pas à outrance : si la ligne devient illisible, une affectation ordinaire est préférable.

Arrondi en Python : round, ceil, floor

Pour arrondir en Python, on dispose de la fonction intégrée round et des fonctions du module math. Elles ne servent pas au même usage, et les confondre est une erreur fréquente.

La fonction round en Python et l'arrondi bancaire

La fonction round(x, n) arrondit à n décimales ; sans second argument, elle renvoie un int. Le piège principal : round arrondit « à la banquière », c'est-à-dire la moitié vers le pair. Ainsi, round(2.5) donne 2, et round(3.5) donne 4. Les erreurs d'arrondi ne s'accumulent pas dans un seul sens lors de gros calculs.

>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # à la centaine
1200
>>> round(2.675, 2)     # pas 2.68 : en binaire, c'est 2.67499...
2.67

Si vous voulez l'arrondi scolaire « la moitié vers le haut », par exemple sur une facture, utilisez Decimal avec le mode ROUND_HALF_UP. Passez le nombre sous forme de chaîne pour ne pas hériter de l'imprécision de float :

>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')

Une autre règle du cours : arrondissez uniquement à l'affichage. Pour un affichage soigné, pas besoin de round — une f-chaîne suffit : f"{amount:.2f}" montre deux décimales, et la valeur reste exacte.

math.ceil et math.floor : arrondi vers le haut et vers le bas

math.ceil sert quand il ne doit pas en manquer : combien de bus commander, combien de pages pour afficher une liste. math.floor sert quand on ne compte que les unités complètes. Les deux renvoient un int.

import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 bus
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 : ceil sans math, grâce à //

Le module math propose aussi math.sqrt (racine carrée), math.isclose (comparaison des décimaux), math.pi et math.gcd. Python 3.15 ajoute le sous-module math.integer (PEP 791) pour le calcul sur les entiers : on y trouve comb, factorial, gcd, isqrt, lcm, perm, et les anciennes fonctions comme math.gcd continuent de fonctionner.

Fonction abs : valeur absolue

abs(x) renvoie la valeur absolue, c'est-à-dire la distance à zéro sans signe. Aucun import n'est nécessaire, la fonction est intégrée. Elle fonctionne avec les entiers, les décimaux et même les complexes : pour 3+4j, elle renvoie la longueur du vecteur, soit 5.0.

>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # écart par rapport au budget
320

Usage typique : l'écart sans tenir compte du sens, ou la comparaison avec une tolérance : abs(a - b) < 0.001. Pour les décimaux, math.isclose est plus fiable, car il tient compte de l'ordre de grandeur des nombres.

Priorité des opérateurs

Quand une expression contient plusieurs opérateurs, Python les évalue selon leur priorité, de la plus haute à la plus basse :

1. **
2. unaires -x, +x, ~x
3. * / // %
4. + -
5. décalages et opérations binaires
6. comparaisons, in, is
7. not
8. and
9. or
10. :=

Ainsi, 2 + 3 * 4 vaut 14, et (2 + 3) * 4 vaut 20. En cas de doute, mettez des parenthèses : elles ne coûtent rien, alors qu'une erreur de priorité prend du temps à retrouver.

Erreurs fréquentes avec les opérateurs

Conclusion

Retenez l'essentiel : / renvoie toujours un float, // arrondit vers le bas, % donne le reste avec le signe du diviseur, et la puissance s'écrit **. Les opérateurs logiques and, or, not s'écrivent en toutes lettres et s'évaluent paresseusement ; is sert à tester None. L'arrondi round en Python se fait à la banquière, pour l'arrondi vers le haut ou le bas il existe math.ceil et math.floor, et la valeur absolue s'obtient avec abs. Le cours applique ces opérateurs en pratique, dans le suivi des dépenses où l'argent est stocké en centimes.