Aide-mémoire - Les mathématiques en Python

Les opérateurs arithmétiques

Les sept signes de calcul de base. Attention aux deux barres // et au pourcentage % : ce ne sont pas une division ni un pourcentage ordinaires.

Opérateur	Nom	Exemple → résultat
+	addition	7 + 2 → 9
-	soustraction	7 - 2 → 5
*	multiplication	7 * 2 → 14
/	division (toujours à virgule)	7 / 2 → 3.5
//	division entière (quotient)	7 // 2 → 3
%	modulo (le reste)	7 % 2 → 1
**	puissance (exposant)	7 ** 2 → 49

À quoi sert % ? Tester si un nombre est pair (n % 2 == 0), faire un cycle, ou trouver le reste d'une division. 17 % 5 → 2 car 17 = 3×5 + 2.

L'ordre des opérations (priorités)

Python calcule dans un ordre précis, comme en mathématiques. Les parenthèses passent toujours en premier ; en cas de doute, mets des parenthèses.

Du plus fort au plus faible

() > ** > * / // % > + -

2 + 3 * 4 # 14 (le × d'abord) (2 + 3) * 4 # 20 (parenthèses d'abord) 2 ** 3 * 2 # 16 (la puissance d'abord)

La puissance ** est plus forte que * et /. À priorité égale, Python lit de gauche à droite.

Le piège du moins

-2 ** 2

-2 ** 2 # -4 (= -(2**2)) (-2) ** 2 # 4

La puissance s'applique avant le signe moins. Pour mettre un nombre négatif au carré, encadre-le de parenthèses.

Les fonctions de calcul toujours disponibles

Celles-ci marchent sans rien importer. Les plus utiles pour les calculs de tous les jours.

Valeur absolue et arrondi

abs() · round()

abs(-7) # 7 round(3.14159, 2) # 3.14 round(8.7) # 9

round(x, n) arrondit à n décimales ; sans n, à l'entier le plus proche.

Puissance et reste en un coup

pow() · divmod()

pow(2, 10) # 1024 (= 2 ** 10) divmod(17, 5) # (3, 2) : quotient et reste

divmod(a, b) donne d'un coup a // b et a % b. Pratique pour convertir des secondes en minutes + secondes.

Sur une liste de nombres

sum() · min() · max()

notes = [85, 92, 78] sum(notes) # 255 min(notes) # 78 max(notes) # 92

La moyenne ? sum(notes) / len(notes). min et max acceptent aussi plusieurs arguments : max(3, 9, 5).

Le module `math` : tout le reste

Pour les racines, la trigonométrie, les logarithmes et les constantes. On l'importe une fois tout en haut du fichier, puis on écrit math.fonction().

import math # une seule fois, en haut du fichier

Racines et arrondis

sqrt · floor · ceil · trunc

math.sqrt(16) # 4.0 (racine carrée) math.floor(3.9) # 3 (vers le bas) math.ceil(3.1) # 4 (vers le haut) math.trunc(3.9) # 3 (coupe la virgule)

floor descend, ceil monte, trunc coupe net (vers zéro). round, lui, va au plus proche.

Les constantes

math.pi · math.e · math.inf

math.pi # 3.14159… math.e # 2.71828… math.inf # l'infini

Ce sont des valeurs, pas des fonctions : pas de parenthèses. aire = math.pi * rayon ** 2.

Puissances et logarithmes

pow · log · log10 · exp

math.pow(2, 3) # 8.0 math.log(math.e) # 1.0 (log naturel) math.log10(1000) # 3.0 math.log(8, 2) # 3.0 (base 2)

math.pow renvoie toujours un float ; pour rester en entier, garde l'opérateur **.

Trigonométrie

sin · cos · tan · radians

math.radians(90) # 90° en radians math.sin(math.radians(90)) # 1.0 math.degrees(math.pi) # 180.0

Les fonctions trigo travaillent en radians, pas en degrés. Convertis d'abord avec math.radians().

Entiers spéciaux

factorial · gcd

math.factorial(5) # 120 (= 5!) math.gcd(12, 18) # 6 (plus grand # commun diviseur)

Aussi disponible : math.isqrt() (racine entière) et math.hypot(a, b) (hypoténuse).

Convertir entre `int` et `float`

Un entier (int) n'a pas de virgule ; un flottant (float) en a une. On passe de l'un à l'autre avec les fonctions qui portent le nom du type.

On écrit	Effet	Exemple → résultat
int(x)	en entier (coupe la virgule, vers zéro)	int(3.9) → 3
int(x)	même sur un négatif : vers zéro	int(-3.9) → -3
float(x)	en nombre à virgule	float(5) → 5.0
int("42")	un texte d'entier devient un entier	int("42") → 42
float("3.5")	un texte à virgule devient un float	float("3.5") → 3.5

int() ne fait PAS d'arrondi : il coupe la virgule (int(3.9) → 3, pas 4). Pour arrondir au plus proche, utilise round(). Pour descendre toujours, math.floor().

Les pièges du calcul

Cinq surprises classiques quand on calcule en Python.

/ donne toujours un float

10 / 2 # 5.0 (pas 5 !) 10 // 2 # 5 (division entière)

La simple barre / renvoie un float même si ça tombe juste. Pour un entier, utilise //.

int() coupe, n'arrondit pas

int(3.99) # 3 (pas 4) round(3.99) # 4 ✓

Si tu veux le nombre le plus proche, c'est round(). int() jette simplement la partie décimale.

La virgule flottante n'est pas exacte

0.1 + 0.2 # 0.30000000000000004 round(0.1 + 0.2, 2) # 0.3 ✓

Les float sont des approximations. Pour comparer ou afficher, arrondis avec round().

Les réels ne se comparent pas

0.1 + 0.2 == 0.3 # False (!?) math.isclose(0.1 + 0.2, 0.3) # True ✓ abs(a - b) < 1e-9 # True si très proches

Jamais == sur des float : l'erreur d'arrondi le fait mentir. Compare une proximité avec math.isclose() (ou abs(a - b) < seuil).

Diviser par zéro plante

5 / 0 # ZeroDivisionError if diviseur != 0: # vérifie d'abord resultat = a / diviseur

Python refuse la division par zéro. Vérifie le diviseur avec un if avant de calculer.

numpy : `.mean()` donne un float, `.sum()` garde le type

np.array([1, 2, 3]).sum() # 6 (entier numpy) np.array([1, 2, 3]).mean() # 2.0 (toujours float)

Sur un tableau numpy, .mean() renvoie toujours un float, mais .sum() conserve le type du tableau : des entiers restent entiers (et un int64 peut déborder en silence), des flottants restent flottants.