Importer et utiliser des modules de la bibliothèque standard (ex: `math`, `random`)

Qu'est-ce qu'un module et la bibliothèque standard Python ?

En Python, un module est simplement un fichier contenant des définitions et des instructions Python. Ces définitions peuvent inclure des variables, des fonctions, des classes, etc. L'idée derrière les modules est d'organiser le code de manière logique, de le rendre réutilisable et d'éviter les conflits de noms. Au lieu d'écrire tout votre code dans un seul fichier gigantesque, vous pouvez le diviser en plusieurs modules, chacun se concentrant sur un aspect spécifique de votre application.

Python est livré avec une vaste collection de modules appelée la bibliothèque standard. C'est l'un des grands atouts de Python. Elle fournit des outils prêts à l'emploi pour une multitude de tâches courantes, allant des opérations mathématiques avancées à la manipulation de fichiers, en passant par la gestion des connexions réseau, la création d'interfaces graphiques, le travail avec des dates et heures, la compression de données, et bien plus encore. Vous n'avez pas besoin de réinventer la roue pour ces fonctionnalités ; elles sont déjà disponibles et optimisées au sein de la bibliothèque standard.

Utiliser la bibliothèque standard vous permet de gagner un temps considérable en développement, d'écrire du code plus robuste (car ces modules sont largement testés) et de vous concentrer sur la logique spécifique de votre projet. Savoir naviguer dans la documentation de la bibliothèque standard et utiliser ses modules efficacement est une compétence clé pour tout développeur Python. Dans cette section, nous allons explorer comment importer et utiliser deux modules très courants : math pour les opérations mathématiques et random pour la génération de nombres et de séquences aléatoires.

L'instruction `import` : comment accéder aux modules Python ?

Pour pouvoir utiliser les fonctionnalités définies dans un module, vous devez d'abord le rendre accessible dans votre script ou votre session interactive. C'est le rôle de l'instruction import. Il existe plusieurs façons d'utiliser import.

La manière la plus simple et la plus courante est d'importer le module entier :

import math

# Pour utiliser une fonction du module math, vous devez la préfixer
# par le nom du module suivi d'un point.
racine_carree = math.sqrt(25)
print(f"La racine carrée de 25 est : {racine_carree}") # Affiche: La racine carrée de 25 est : 5.0

pi_valeur = math.pi
print(f"La valeur de pi est : {pi_valeur}") # Affiche: La valeur de pi est : 3.141592653589793

Cette méthode crée un espace de noms (namespace) pour le module. Toutes les fonctions, variables ou classes du module math sont accessibles via math.nom_de_la_fonction. C'est une bonne pratique car cela évite les conflits de noms si votre propre code définit une fonction ou une variable avec le même nom qu'un élément du module importé.

Vous pouvez également importer un module en lui donnant un alias (un nom plus court ou plus pratique) en utilisant le mot-clé as :

import random as rnd

nombre_aleatoire = rnd.randint(1, 10) # Génère un entier aléatoire entre 1 et 10 (inclus)
print(f"Nombre aléatoire entre 1 et 10 : {nombre_aleatoire}")

liste_ex = [1, 2, 3, 4, 5]
rnd.shuffle(liste_ex) # Mélange la liste sur place
print(f"Liste mélangée : {liste_ex}")

Ici, rnd devient un raccourci pour random.

Une autre façon d'importer est de ne charger que des éléments spécifiques d'un module en utilisant la syntaxe from ... import ... :

from math import sqrt, pi
from random import choice

# Maintenant, sqrt et pi sont directement accessibles sans préfixe
racine_de_16 = sqrt(16)
print(f"Racine de 16 : {racine_de_16}") # Affiche: Racine de 16 : 4.0
print(f"Valeur de pi directement : {pi}") # Affiche: Valeur de pi directement : 3.141592653589793

ma_liste = ['pomme', 'banane', 'cerise']
element_choisi = choice(ma_liste) # Choisit un élément au hasard dans la liste
print(f"Elément choisi au hasard : {element_choisi}")

Cette méthode peut rendre le code plus concis, mais elle peut aussi introduire des conflits de noms si vous définissez une fonction sqrt dans votre propre code, par exemple. Elle est donc à utiliser avec discernement.

Il est également possible d'importer tous les noms d'un module directement dans l'espace de noms courant en utilisant from module import * :

# from math import * # Exemple, déconseillé en général
# print(sqrt(9)) # Fonctionnerait, mais potentiellement dangereux

Attention : L'utilisation de from module import * est généralement déconseillée dans les scripts Python. Bien que cela puisse sembler pratique, cela pollue l'espace de noms courant avec tous les noms du module, ce qui peut rendre difficile de savoir d'où provient une fonction ou une variable particulière, et augmente considérablement le risque de conflits de noms (surtout si vous importez plusieurs modules de cette manière). Préférez import module ou from module import nom_specifique.

Le module `math` : votre boîte à outils mathématiques en Python

Le module math de la bibliothèque standard Python fournit un accès à des fonctions mathématiques définies par le standard C. Il est indispensable dès que vous avez besoin d'effectuer des calculs allant au-delà des opérateurs arithmétiques de base (+, -, *, /).

Pour l'utiliser, commencez par l'importer :

import math

Voici quelques-unes des fonctions et constantes les plus couramment utilisées du module math :

• math.sqrt(x): Retourne la racine carrée de x.
• math.pow(x, y): Retourne x élevé à la puissance y (équivalent à x**y, mais math.pow retourne toujours un flottant).
• math.exp(x): Retourne e élevé à la puissance x (e^x), où e est la base des logarithmes naturels.
• math.log(x[, base]): Retourne le logarithme de x. Si base est omis, retourne le logarithme naturel (base e) de x. Sinon, retourne le logarithme de x en base base.
• math.log10(x): Retourne le logarithme en base 10 de x.
• math.sin(x), math.cos(x), math.tan(x): Fonctions trigonométriques sinus, cosinus, tangente (x est en radians).
• math.asin(x), math.acos(x), math.atan(x): Fonctions trigonométriques inverses.
• math.degrees(x): Convertit l'angle x de radians en degrés.
• math.radians(x): Convertit l'angle x de degrés en radians.
• math.ceil(x): Retourne le plus petit entier supérieur ou égal à x (plafond).
• math.floor(x): Retourne le plus grand entier inférieur ou égal à x (plancher).
• math.fabs(x): Retourne la valeur absolue de x (en flottant).
• math.factorial(x): Retourne la factorielle de x (x doit être un entier non négatif).
• math.gcd(a, b): Retourne le plus grand commun diviseur des entiers a et b.

Le module math définit également des constantes mathématiques importantes :

import math

print(f"Pi (π) : {math.pi}")         # Affiche: Pi (π) : 3.141592653589793
print(f"Nombre d'Euler (e) : {math.e}") # Affiche: Nombre d'Euler (e) : 2.718281828459045
print(f"Infini (positif) : {math.inf}") # Affiche: Infini (positif) : inf
print(f"Non un nombre (NaN) : {math.nan}")# Affiche: Non un nombre (NaN) : nan

Exemples d'utilisation :

import math

# Calcul de l'hypoténuse d'un triangle rectangle (côtés a=3, b=4)
a = 3
b = 4
hypotenuse = math.sqrt(math.pow(a, 2) + math.pow(b, 2))
# ou plus simplement avec math.hypot(a,b) depuis Python 3.8
# hypotenuse = math.hypot(a,b)
print(f"L'hypoténuse est : {hypotenuse}") # Affiche: L'hypoténuse est : 5.0

angle_degres = 45
angle_radians = math.radians(angle_degres)
sinus_angle = math.sin(angle_radians)
print(f"Le sinus de {angle_degres}° est : {sinus_angle:.4f}") # Affiche: Le sinus de 45° est : 0.7071

nombre = 3.7
print(f"Arrondi au plafond de {nombre} : {math.ceil(nombre)}")   # Affiche: Arrondi au plafond de 3.7 : 4
print(f"Arrondi au plancher de {nombre} : {math.floor(nombre)}") # Affiche: Arrondi au plancher de 3.7 : 3

Pour une liste complète des fonctions et constantes, consultez la documentation officielle du module math.

Le module `random` : introduire l'aléatoire dans vos programmes Python

Le module random est utilisé pour générer des nombres pseudo-aléatoires et effectuer des sélections aléatoires. Il est très utile dans de nombreuses applications, comme les jeux, les simulations, les tests statistiques, ou simplement pour introduire une part d'imprévu dans un programme.

Comme pour math, la première étape est d'importer le module :

import random

Voici quelques-unes des fonctions les plus utilisées du module random :

• random.random(): Retourne un nombre flottant aléatoire dans l'intervalle [0.0, 1.0) (1.0 est exclu).
• random.uniform(a, b): Retourne un nombre flottant aléatoire N tel que a <= N <= b si a <= b ou b <= N <= a si b < a.
• random.randint(a, b): Retourne un entier aléatoire N tel que a <= N <= b. Les bornes a et b sont incluses.
• random.randrange(start, stop[, step]): Retourne un élément sélectionné aléatoirement à partir de range(start, stop, step). La borne stop est exclue.
• random.choice(seq): Retourne un élément aléatoire à partir d'une séquence non vide seq (liste, tuple, chaîne de caractères). Si seq est vide, lève IndexError.
• random.choices(population, weights=None, *, cum_weights=None, k=1): Retourne une liste de k éléments choisis aléatoirement avec remise à partir de population. On peut spécifier des poids (weights) pour influencer la probabilité de sélection de chaque élément.
• random.sample(population, k): Retourne une liste de k éléments uniques choisis aléatoirement sans remise à partir de population. Utile pour les tirages au sort sans répétition.
• random.shuffle(seq): Mélange la séquence seq sur place (in-place). La fonction ne retourne rien (None). Ne fonctionne pas sur les séquences immuables comme les tuples.

Exemples d'utilisation du module random :

import random

# Générer un flottant entre 0.0 et 1.0
flottant_aleatoire = random.random()
print(f"Flottant aléatoire [0.0, 1.0) : {flottant_aleatoire}")

# Générer un entier entre 1 et 100 (inclus)
de_a_lancer = random.randint(1, 100)
print(f"Résultat du lancer de dé (1-100) : {de_a_lancer}")

# Choisir un élément dans une liste
options = ["pierre", "feuille", "ciseaux"]
element_choisi = random.choice(options)
print(f"Choix aléatoire : {element_choisi}")

# Mélanger une liste
cartes = ["As", "Roi", "Dame", "Valet", 10, 9, 8, 7]
print(f"Cartes avant mélange : {cartes}")
random.shuffle(cartes)
print(f"Cartes après mélange : {cartes}")

# Echantillonner sans remise
population_nombres = list(range(1, 50))
tirage_loto = random.sample(population_nombres, k=5)
print(f"Tirage de 5 numéros (sans remise) : {sorted(tirage_loto)}")

Le module random utilise un générateur de nombres pseudo-aléatoires. Cela signifie que les séquences générées ne sont pas véritablement aléatoires mais sont produites par un algorithme déterministe. Vous pouvez initialiser le générateur avec une valeur de "graine" (seed) en utilisant random.seed(valeur). Si vous utilisez la même graine, vous obtiendrez toujours la même séquence de nombres aléatoires, ce qui est utile pour la reproductibilité des tests ou des simulations.