2.3. Opérations mathématiques

Python fonctionne comme une calculatrice dès le départ. Cette page couvre les opérateurs que vous utiliserez le plus souvent : l’arithmétique sur les nombres, les comparaisons qui produisent des booléens, les opérateurs logiques qui combinent des conditions, et les opérateurs bit à bit pour le travail au niveau matériel.

2.3.1. Arithmétique

Les opérateurs arithmétiques standard sur les valeurs int et float :

  • + – addition

  • - – soustraction (ou négation, en préfixe : -x)

  • * – multiplication

  • / – division. Retourne toujours un float, même lorsque les deux opérandes sont des entiers.

  • // – division entière (floor). Retourne le quotient entier arrondi vers moins l’infini.

  • % – modulo (reste).

  • ** – exponentiation (2 ** 10 vaut 1024).

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> -7 // 2
-4
>>> 7 % 2
1
>>> 2 ** 16
65536

L’arithmétique entre types mixtes promeut automatiquement les entiers en flottants :

>>> 3 + 0.5
3.5

L’affectation augmentée combine l’opérateur avec = pour une mise à jour compacte sur place :

counter = 0
counter += 1                # equivalent to counter = counter + 1
counter *= 2                # works for *= /= //= %= **= too

La priorité des opérateurs suit l’ordre conventionnel : ** d’abord, puis le - unaire, puis *, /, // et %, puis + et -. Utilisez des parenthèses en cas de doute – elles ne coûtent rien à l’exécution.

2.3.2. Comparaison

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

  • == et != – égal / différent.

  • <, <=, >, >= – ordre.

>>> 3 == 3
True
>>> 3 == 3.0
True
>>> 3 < 5 <= 5
True

Le dernier exemple est une comparaison chaînée et équivaut exactement à 3 < 5 and 5 <= 5.

Avertissement

= affecte ; == compare. L’expression if x = 5: constitue une erreur de syntaxe précisément parce que Python refuse de confondre silencieusement les deux.

2.3.3. Logique booléenne

Trois opérateurs combinent les booléens :

  • and – True uniquement lorsque les deux côtés sont vrais.

  • or – True lorsque l’un ou l’autre côté est vrai.

  • not – inverse un booléen unique.

and et or font de la court-circuit : ils cessent d’évaluer dès que le résultat est connu. False and slow_check() n’appelle jamais slow_check.

and et or retournent aussi l’un de leurs opérandes plutôt qu’un littéral True ou False, ce qui permet d’écrire des valeurs par défaut de manière compacte :

name = user_name or "anonymous"   # "" / 0 / None are falsy

2.3.4. Opérateurs bit à bit

Pour le travail matériel – empaqueter des champs de registre, masquer des bits, analyser des en-têtes de protocole – vous aurez recours aux opérateurs bit à bit. Ils agissent sur la représentation binaire d’un int :

  • & – ET bit à bit

  • | – OU bit à bit

  • ^ – OU exclusif (XOR) bit à bit

  • ~ – NON bit à bit (complément à un)

  • << – décalage à gauche

  • >> – décalage à droite

Les formes littérales hexadécimale et binaire sont pratiques pour lire et écrire ces valeurs :

>>> 0b1100 & 0b1010
8                              # 0b1000
>>> 0b1100 | 0b1010
14                             # 0b1110
>>> 0xFF ^ 0x0F
240                            # 0xF0
>>> 1 << 8
256
>>> (0xABCD >> 8) & 0xFF
171                            # extract the high byte

Il existe une forme augmentée pour chacun : |=, &=, ^=, <<=, >>=.

Note

and / or opèrent sur des booléens (ou sur la valeur de vérité) ; & / | opèrent sur des bits. Ne les confondez pas. 0b1100 and 0b1010 s’évalue à 0b1010 car les deux opérandes sont vrais – ce qui n’est généralement pas ce que vous voulez en manipulant des bits.

2.3.5. Fonctions intégrées utiles pour les nombres

Une poignée de fonctions intégrées couvrent les opérations numériques courantes que les seuls opérateurs ne fournissent pas :

  • round() – l’entier le plus proche, ou la décimale ndigits la plus proche lorsqu’un second argument est fourni. Retourne un int pour round(x), un float pour round(x, n). Les égalités (0.5, 1.5, …) sont arrondies au nombre pair le plus proche, et non systématiquement vers le haut.

  • divmod() – retourne (quotient, remainder) en un seul appel. Pratique pour répartir une quantité en unités (secondes en minutes-et-secondes, octets en pages-et-décalages).

  • pow() – identique à ** dans sa forme à deux arguments. La forme à trois arguments pow(base, exp, mod) calcule (base ** exp) % mod sans jamais matérialiser l’énorme valeur intermédiaire, ce qui est le seul moyen pratique de faire de l’exponentiation modulaire pour de grands exposants.

>>> round(3.7)
4
>>> round(3.14159, 2)
3.14
>>> round(0.5)               # ties go to even, not always up
0
>>> round(1.5)
2

>>> divmod(125, 60)          # 125 seconds = 2 min, 5 sec
(2, 5)
>>> minutes, seconds = divmod(125, 60)

>>> pow(3, 4)                # same as 3 ** 4
81
>>> pow(3, 100, 7)           # (3 ** 100) mod 7, efficient
4

Les conversions d’entier en chaîne selon une base (bin, oct, hex) sont traitées dans Méthodes de chaînes et formatage.

2.3.6. Le module math

Les fonctions mathématiques courantes se trouvent dans le module math. Importez-le une fois et appelez ses fonctions via un nom pointé :

import math

print(math.sqrt(2))              # 1.4142135
print(math.sin(math.pi / 2))     # 1.0
print(math.floor(3.7))           # 3
print(math.log(100, 10))         # 2.0

Le module math de MicroPython couvre les fonctions habituelles (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Pour les nombres aléatoires, voir le module random ; pour la manipulation de bits en virgule fixe, les opérateurs ci-dessus suffisent généralement.

2.3.7. Nombres complexes

Pour le travail numérique nécessitant des composantes imaginaires, Python dispose d’un type complex avec des littéraux à suffixe j (1 + 2j). Le module cmath reflète math pour les entrées complexes. Les deux sont présents dans la plupart des builds MicroPython mais rarement nécessaires pour le travail avec la caméra ; nous les mentionnons surtout pour qu’ils ne vous surprennent pas si vous portez du code qui les utilise.