Le module random en langage Python

En informatique, la simulation de phénomènes physiques, les calculs de probabilités (méthode de Monte-Carlo), les jeux vidéo, l'apprentissage automatique (mélange de jeux de données d'entraînement) et la génération de jeux de tests reposent sur le module standard random.

Python implémente l'algorithme réputé du Mersenne Twister (MT19937), l'un des meilleurs générateurs de nombres pseudo-aléatoires au monde, doté d'une période astronomique de \(2^{19937} - 1\).

---

1. Reproductibilité des résultats : random.seed()

Les ordinateurs sont des machines strictement déterministes : ils ne peuvent pas produire de hasard parfait sans capteur matériel externe. Le module random calcule une suite mathématique pseudo-aléatoire à partir d'une valeur de départ appelée la graine (seed).

En fixant la graine avec random.seed(valeur), vous forcez Python à produire exactement la même séquence lors de chaque exécution, ce qui est indispensable pour rendre vos expériences scientifiques et tests unitaires reproductibles :

import random

# Initialisation de la graine
random.seed(42)
print([random.randint(1, 100) for _ in range(4)])
# Affichera TOUJOURS [82, 15, 4, 95] sur n'importe quel ordinateur !

---

2. Génération de nombres aléatoires

A. Nombres réels (Flottants)

• random.random() : génère un réel uniformément distribué sur l'intervalle semi-ouvert \([0.0, 1.0[\).
• random.uniform(a, b) : génère un réel uniformément distribué entre a et b.

import random

# Flottant entre 0.0 et 1.0
proba = random.random()
print(f"Probabilite : {proba:.4f}")

# Flottant entre 18.5 et 25.0 (ex: température)
temperature = random.uniform(18.5, 25.0)
print(f"Temperature simulee : {temperature:.2f} C")

B. Nombres entiers

• random.randint(a, b) : tire un entier au hasard dans l'intervalle \([a, b]\) (bornes a et b incluses).
• random.randrange(start, stop, step) : tire un entier dans la séquence définie par range().

# Lancer d'un dé à 6 faces (1 et 6 inclus)
de = random.randint(1, 6)
print(f"Resultat du de : {de}")

# Tirer un multiple de 10 entre 100 et 500 (500 exclu)
palier = random.randrange(100, 500, 10)
print(f"Palier choisi : {palier}")

---

3. Échantillonnage et sélections dans des collections

Le module random propose des outils sophistiqués pour tirer des éléments dans des séquences (listes, tuples) :

couleurs = ["Rouge", "Vert", "Bleu", "Jaune", "Noir", "Blanc"]

# 1. choice() : tire UN SEUL élément au hasard
elu = random.choice(couleurs)
print(f"Couleur tiree au sort : {elu}")

# 2. choices() : tirage de k éléments AVEC REMISE (un élément peut être tiré plusieurs fois)
tirage_avec_remise = random.choices(couleurs, k=4)
print("Avec remise    :", tirage_avec_remise)

# 3. sample() : tirage de k éléments SANS REMISE (tous les éléments tirés sont uniques)
# Requiert k <= len(collection), sinon lève un ValueError
tirage_sans_remise = random.sample(couleurs, k=3)
print("Sans remise    :", tirage_sans_remise)

Tirage pondéré avec des probabilités asymétriques

La méthode choices() accepte un paramètre weights pour simuler des événements non équiprobables (ex: probabilité de pluie) :

meteo = ["Ensoleille", "Nuageux", "Pluvieux"]
poids = [0.60, 0.30, 0.10]  # 60% soleil, 30% nuages, 10% pluie

prevision = random.choices(meteo, weights=poids, k=1)[0]
print("Prevision du jour :", prevision)

---

4. Mélanger une liste in-place : random.shuffle()

La fonction random.shuffle(liste) permute aléatoirement les éléments d'une liste modifiable sur place :

paquet_cartes = ["As", "Roi", "Dame", "Valet", "10", "9"]
print("Avant melange :", paquet_cartes)

random.shuffle(paquet_cartes)
print("Apres melange :", paquet_cartes)

---

5. Sécurité cryptographique : Le module secrets

[!CAUTION] Avertissement de cybersécurité :
Les nombres générés par le module random sont pseudo-aléatoires et prévisibles. Ne les utilisez JAMAIS pour des applications de sécurité (mots de passe, jetons d'authentification API, clés de chiffrement, tokens de réinitialisation).
Pour la sécurité, Python fournit le module standard secrets basé sur le générateur cryptographique du système d'exploitation :

import secrets

# Jeton hexadécimal sécurisé de 16 octets
token_securise = secrets.token_hex(16)
print("Token JWT securise :", token_securise)

---

6. Mise en pratique : Simulation d'un tirage de loterie (Loto)

Concevons un simulateur officiel de loterie tirant 5 numéros distincts entre 1 et 49 et 1 numéro chance entre 1 et 10 :

import random

def simuler_tirage_loto():
    # 1. Tirage de 5 numéros uniques sans remise parmi 49
    boules_disponibles = list(range(1, 50))
    numeros_gagnants = sorted(random.sample(boules_disponibles, k=5))

    # 2. Tirage du numéro chance (1 à 10)
    numero_chance = random.randint(1, 10)

    print("=============================================")
    print("        TIRAGE OFFICIEL DE LA LOTERIE        ")
    print("=============================================")
    print("Numeros gagnants :", " - ".join(f"{n:02d}" for n in numeros_gagnants))
    print(f"Numero Chance    : [{numero_chance:02d}]")
    print("=============================================")

simuler_tirage_loto()

---

7. Défi d'application

Écrivez une fonction lancer_des(nb_des: int = 2, nb_lancers: int = 1000) -> dict qui simule nb_lancers lancers d'une paire de dés à 6 faces, calcule la somme obtenue à chaque lancer (entre 2 et 12) et retourne un dictionnaire récapitulant la fréquence d'apparition de chaque somme. Observez quelle somme apparaît le plus souvent (loi normale discrète centrée sur 7).

Partagez sur les réseaux sociaux

Commentaires