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

URL: https://skillaria.top/fr/guides/python/operateurs-python

Les opérateurs Python transforment des valeurs : + ajoute, // fait une division entière, and combine les conditions. L'article présente 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, math.ceil, math.floor et abs. Tous les exemples peuvent être testés dans l'interpréteur.

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.

| Groupe | Opérateurs | Exemple |
| --- | --- | --- |

| Arithmétiques | `+ - * / // % **` | `7 // 2` → 3 |

| Comparaison | `== != < > <= >=` | `3 < 5` → True |

| Logiques | `and or not` | `not True` → False |

| Identité | `is`, `is not` | `x is None` |

| Appartenance | `in`, `not in` | `"café" in "café noir"` → True |

| Affectation | `= += -= *= /= //= %= **=` | `total += 250` |

| Walrus | `:=` | `if (n := len(s)) > 10:` |

| Binaires | `& | ^ ~ << >>` | `5 & 3` → 1 |

## 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 > 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.

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

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.

| Fonction | Ce qu'elle fait | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | au plus proche, la moitié vers le pair | 2 | -2 | 3 |

| `math.floor(x)` | vers le bas, vers moins l'infini | 2 | -3 | 2 |

| `math.ceil(x)` | vers le haut, vers plus l'infini | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | supprimer la partie décimale, vers zéro | 2 | -2 | 2 |

### 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

| Erreur | Ce qui se passe | Solution |
| --- | --- | --- |

| `if x = 5:` | SyntaxError : c'est une affectation | `if x == 5:` |

| `2 ^ 3` pour une puissance | OU exclusif binaire, résultat 1 | `2 ** 3` |

| attendre un entier de `8 / 2` | on obtient `4.0` | `8 // 2` |

| `x == 1 or 2` | toujours vrai : `or 2` | `x in (1, 2)` |

| attendre 3 de `round(2.5)` | l'arrondi bancaire donne 2 | `Decimal` avec `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

## 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.

## FAQ

**Comment arrondir un nombre à deux décimales en Python ?**

Utilisez round(x, 2) ; si vous voulez seulement un affichage soigné, une f-chaîne f"{x:.2f}" suffit et ne modifie pas la valeur.

**Pourquoi round(0.5) renvoie-t-il 0 en Python ?**

Parce que round arrondit la moitié vers le pair le plus proche, et 0 est pair ; de même, round(1.5) et round(2.5) donnent 2.

**Comment obtenir la partie entière d'une division en Python ?**

Avec l'opérateur // : 17 // 5 donne 3. Pour les nombres négatifs, il arrondit vers le bas : -17 // 5 donne -4 ; pour supprimer la partie décimale vers zéro, utilisez int(-17 / 5).

**Python possède-t-il un opérateur ternaire ?**

Oui, c'est l'expression conditionnelle : valeur_si_vrai if condition else valeur_si_faux, par exemple "pair" if n % 2 == 0 else "impair".

**Quelle différence entre & et and en Python ?**

and est un opérateur logique à évaluation paresseuse, tandis que & est le ET binaire sur les nombres et l'intersection pour les ensembles ; dans les conditions if, utilisez and.


---
Source: Skillaria.Top (https://skillaria.top)