Le module math en langage Python#
Le module standard math fournit un accès direct aux fonctions de calcul mathématique en virgule flottante définies par la norme C (C99). Il constitue la boîte à outils essentielle pour la géométrie 2D/3D, la physique numérique, la cryptographie et les calculs statistiques fondamentaux.
1. Constantes mathématiques universelles#
Le module expose les constantes fondamentales de l'analyse avec la plus haute précision matérielle (64 bits IEEE 754) :
import math
print("Pi (pi) :", math.pi) # 3.141592653589793
print("Nombre d'Euler (e) :", math.e) # 2.718281828459045
print("Constante Tau (2*pi):", math.tau) # 6.283185307179586
print("Infini positif :", math.inf) # float('inf')
print("Not a Number (NaN) :", math.nan) # float('nan')
2. Arrondis, troncature et le piège des flottants : isclose()#
Arrondis vers le haut, vers le bas et troncature#
x = 7.85
y = -3.20
# 1. math.ceil() : plus petit entier supérieur ou égal (plafond)
print("Plafond (ceil) :", math.ceil(x)) # 8
# 2. math.floor() : plus grand entier inférieur ou égal (plancher)
print("Plancher (floor):", math.floor(x)) # 7
# 3. math.trunc() : supprime simplement la partie décimale
print("Troncature :", math.trunc(y)) # -3
Le piège de l'égalité des flottants : math.isclose()#
En arithmétique binaire à virgule flottante, certains nombres ne peuvent pas être représentés exactement :
[!TIP] La bonne pratique : Pour comparer deux nombres réels, utilisez toujours
math.isclose(a, b)qui tolère une infime marge d'imprécision relative :
3. Puissances, racines et logarithmes#
import math
# 1. Racines carrées
print("Racine carree (sqrt) :", math.sqrt(144)) # 12.0
print("Racine entiere (isqrt):", math.isqrt(150)) # 12 (exactement l'entier floor(sqrt))
# 2. Logarithmes
print("Logarithme naturel (ln):", math.log(math.e)) # 1.0
print("Logarithme en base 10 :", math.log10(1000)) # 3.0
print("Logarithme en base 2 :", math.log2(256)) # 8.0
# 3. Exponentielle
print("e^2 :", math.exp(2))
4. Dénombrement et arithmétique modulaire#
Le module math intègre des fonctions d'analyse combinatoire très rapides écrites en C :
| Fonction | Mathématiques | Rôle | Exemple |
|---|---|---|---|
math.factorial(n) |
\(n!\) | Factorielle de \(n\) | math.factorial(5) \(\rightarrow\) 120 |
math.comb(n, k) |
\(\binom{n}{k} = \frac{n!}{k!(n-k)!}\) | Nombre de combinaisons de \(k\) parmi \(n\) | math.comb(10, 2) \(\rightarrow\) 45 |
math.perm(n, k) |
\(A_n^k = \frac{n!}{(n-k)!}\) | Nombre d'arrangements de \(k\) parmi \(n\) | math.perm(5, 2) \(\rightarrow\) 20 |
math.gcd(a, b) |
\(\text{PGCD}(a, b)\) | Plus Grand Commun Diviseur | math.gcd(48, 18) \(\rightarrow\) 6 |
math.lcm(a, b) |
\(\text{PPCM}(a, b)\) | Plus Petit Commun Multiple (Python 3.9+) | math.lcm(12, 18) \(\rightarrow\) 36 |
5. Trigonométrie et calcul angulaire#
[!WARNING] Toutes les fonctions trigonométriques de Python (
sin,cos,tan) attendent des angles exprimés en radians et non en degrés !
import math
angle_degres = 60.0
# 1. Conversion obligatoire en radians
angle_radians = math.radians(angle_degres)
# 2. Calcul du cosinus et sinus
cosinus = math.cos(angle_radians)
sinus = math.sin(angle_radians)
print(f"Angle : {angle_degres} deg = {angle_radians:.4f} rad")
print(f"cos(60 deg) = {cosinus:.2f} (Attendu : 0.50)")
print(f"sin(60 deg) = {sinus:.4f}")
# 3. Formule fondamentale : cos^2 + sin^2 == 1
identite = cosinus ** 2 + sinus ** 2
print("Identite remarquable cos^2 + sin^2 == 1 :", math.isclose(identite, 1.0))
6. Mise en pratique : Calcul de trajectoire balistique#
Concevons un script qui calcule la portée maximale horizontale \(R\) d'un projectile lancé avec une vitesse initiale \(v_0\) (en m/s) sous un angle \(\alpha\) (en degrés), selon l'équation de la physique classique : $\(R = \frac{v_0^2 \times \sin(2\alpha)}{g} \qquad (\text{avec } g = 9.81 \text{ m/s}^2)\)$
import math
def calculer_portee_balistique(vitesse_ms: float, angle_deg: float) -> float:
"""Calcule la distance parcourue par un projectile."""
gravite = 9.80665 # Accélération de la pesanteur terrestre standard
angle_rad = math.radians(angle_deg)
portee = (vitesse_ms ** 2 * math.sin(2 * angle_rad)) / gravite
return portee
v0 = 120.0 # Vitesse initiale en m/s
print(f"=== SIMULATION BALISTIQUE (Vitesse = {v0} m/s) ===")
for angle in [15, 30, 45, 60, 75]:
distance = calculer_portee_balistique(v0, angle)
print(f"Tir a {angle:02d} degres -> Portee : {distance:>7.2f} metres")
print("\nConclusion : La portee maximale est mathematiquement atteinte a 45 degres !")
7. Défi d'application#
Écrivez une fonction calculer_hypotenuse_et_angle(adj: float, opp: float) -> tuple[float, float] qui prend en entrée la longueur du côté adjacent et du côté opposé d'un triangle rectangle, et retourne sa longueur d'hypoténuse (via math.hypot(adj, opp)) ainsi que l'angle en degrés calculé à l'aide de l'arc-tangente math.atan2(opp, adj).
Commentaires