Python Random : Générer des nombres aléatoires, des choix et des échantillons

Name

Soren Atelier

Updated on 10/02/2026

La génération de données aléatoires est fondamentale en programmation -- du mélange d'une playlist à l'échantillonnage de répondants, en passant par les simulations de Monte Carlo et la création de jeux de données de test. Mais le module random de Python possède des dizaines de fonctions, et il est facile d'utiliser la mauvaise. Appeler random.random() quand on a besoin d'un entier, utiliser choice() quand on a besoin de plusieurs éléments uniques, ou oublier que random n'est pas cryptographiquement sûr peut mener à des bugs subtils ou des vulnérabilités de sécurité.

Le module random de Python fournit une boîte à outils complète pour la génération de nombres pseudo-aléatoires. Ce guide couvre chaque fonction dont vous aurez couramment besoin, avec des exemples clairs montrant quand utiliser chacune.

Entiers aléatoires

randint(a, b)

Retourne un entier aléatoire N tel que a <= N <= b (les deux bornes incluses).

import random
 
# Random integer between 1 and 10 (inclusive)
print(random.randint(1, 10))  # e.g., 7
 
# Simulate a dice roll
dice = random.randint(1, 6)
print(f"You rolled a {dice}")
 
# Generate random ages for test data
ages = [random.randint(18, 65) for _ in range(5)]
print(ages)  # e.g., [34, 52, 21, 45, 28]

randrange(start, stop, step)

Comme range() mais retourne un élément aléatoire. La valeur stop est exclue.

import random
 
# Random even number between 0 and 100
print(random.randrange(0, 101, 2))  # e.g., 42
 
# Random number from 0 to 9
print(random.randrange(10))  # e.g., 7
 
# Random multiple of 5 from 0 to 100
print(random.randrange(0, 101, 5))  # e.g., 35

Flottants aléatoires

random()

Retourne un flottant aléatoire dans l'intervalle [0.0, 1.0).

import random
 
print(random.random())  # e.g., 0.7234...
 
# Scale to any range: random float between 10 and 20
value = 10 + random.random() * 10
print(value)  # e.g., 15.23...

uniform(a, b)

Retourne un flottant aléatoire N tel que a <= N <= b.

import random
 
# Random temperature between 98.0 and 99.5
temp = random.uniform(98.0, 99.5)
print(f"Temperature: {temp:.1f}F")  # e.g., Temperature: 98.7F
 
# Random price between 9.99 and 29.99
price = round(random.uniform(9.99, 29.99), 2)
print(f"Price: ${price}")

gauss(mu, sigma) -- Distribution normale

import random
 
# Generate normally distributed values (mean=100, std=15)
iq_scores = [round(random.gauss(100, 15)) for _ in range(10)]
print(iq_scores)  # e.g., [112, 95, 103, 88, 107, ...]

Sélections aléatoires

choice(seq)

Retourne un seul élément aléatoire d'une séquence non vide.

import random
 
colors = ['red', 'blue', 'green', 'yellow', 'purple']
print(random.choice(colors))  # e.g., 'green'
 
# Random character from a string
print(random.choice('abcdefghij'))  # e.g., 'f'

choices(population, weights, k)

Retourne une liste de k éléments choisis AVEC remise (doublons possibles). Supporte les pondérations.

import random
 
# Pick 5 random colors (duplicates allowed)
colors = ['red', 'blue', 'green']
print(random.choices(colors, k=5))  # e.g., ['blue', 'red', 'blue', 'green', 'red']
 
# Weighted selection (red is 5x more likely)
weighted = random.choices(
    ['red', 'blue', 'green'],
    weights=[5, 1, 1],
    k=10
)
print(weighted)  # Mostly 'red'

sample(population, k)

Retourne k éléments uniques choisis SANS remise (pas de doublons).

import random
 
# Lottery numbers: 6 unique numbers from 1-49
lottery = random.sample(range(1, 50), 6)
print(sorted(lottery))  # e.g., [3, 12, 27, 33, 41, 48]
 
# Random survey sample
employees = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank']
survey_group = random.sample(employees, 3)
print(survey_group)  # e.g., ['Diana', 'Alice', 'Frank']

choice vs choices vs sample

Mélange

shuffle(seq)

Mélange une liste sur place. Retourne None.

import random
 
deck = list(range(1, 53))  # 52 cards
random.shuffle(deck)
print(deck[:5])  # e.g., [37, 12, 48, 3, 21]
 
# Deal 5 cards
hand = deck[:5]
remaining = deck[5:]

Graines et reproductibilité

Définir une graine rend la sortie aléatoire reproductible -- essentiel pour les tests et le débogage.

import random
 
random.seed(42)
print(random.randint(1, 100))  # Always 81
print(random.random())          # Always 0.0744...
 
# Reset seed for same sequence
random.seed(42)
print(random.randint(1, 100))  # 81 again
print(random.random())          # 0.0744... again

Quand utiliser les graines

Générer des données de test

import random
import string
 
def random_string(length=10):
    """Generate a random alphanumeric string."""
    chars = string.ascii_letters + string.digits
    return ''.join(random.choices(chars, k=length))
 
def random_email():
    """Generate a random email address."""
    name = random_string(8).lower()
    domains = ['gmail.com', 'yahoo.com', 'outlook.com']
    return f"{name}@{random.choice(domains)}"
 
def random_user():
    """Generate a random user record."""
    first_names = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve']
    last_names = ['Smith', 'Jones', 'Brown', 'Wilson', 'Taylor']
    return {
        'name': f"{random.choice(first_names)} {random.choice(last_names)}",
        'email': random_email(),
        'age': random.randint(18, 65),
        'score': round(random.uniform(0, 100), 1),
    }
 
# Generate 5 test users
users = [random_user() for _ in range(5)]
for user in users:
    print(user)

Random et science des données

Pour les workflows d'analyse de données, le module random aide pour l'échantillonnage, le bootstrapping et la création de jeux de données synthétiques. Combiné avec pandas, vous pouvez générer rapidement des DataFrames de test :

import random
import pandas as pd
 
random.seed(42)
n = 1000
 
df = pd.DataFrame({
    'age': [random.randint(18, 80) for _ in range(n)],
    'income': [round(random.gauss(50000, 15000), 2) for _ in range(n)],
    'category': random.choices(['A', 'B', 'C'], weights=[5, 3, 2], k=n),
})
print(df.describe())

Pour l'exploration interactive de vos jeux de données aléatoires, PyGWalker (opens in a new tab) transforme n'importe quel DataFrame pandas en une interface de visualisation style Tableau directement dans Jupyter :

import pygwalker as pyg
walker = pyg.walk(df)

Avertissement de sécurité : random vs secrets

Le module random N'EST PAS adapté aux usages de sécurité. Sa sortie est déterministe et prévisible si la graine est connue. Pour les mots de passe, tokens et applications cryptographiques, utilisez le module secrets :

import secrets
 
# Cryptographically secure random token
token = secrets.token_hex(16)
print(token)  # e.g., 'a3f2b8c9d1e4f5a6b7c8d9e0f1a2b3c4'
 
# Secure random integer
secure_int = secrets.randbelow(100)
 
# Secure random choice
secure_choice = secrets.choice(['option1', 'option2', 'option3'])

FAQ

Comment générer un entier aléatoire en Python ?

Utilisez random.randint(a, b) pour obtenir un entier aléatoire entre a et b (inclus). Par exemple, random.randint(1, 10) retourne un nombre de 1 à 10. Pour un intervalle excluant la borne supérieure, utilisez random.randrange(start, stop).

Quelle est la différence entre random.choice et random.sample ?

random.choice(seq) retourne un seul élément aléatoire. random.sample(population, k) retourne k éléments uniques sans remise. Pour sélectionner plusieurs éléments avec doublons autorisés, utilisez random.choices(population, k=n).

Comment rendre les résultats aléatoires reproductibles ?

Appelez random.seed(value) avant de générer des nombres aléatoires. Utiliser la même graine produit la même séquence de valeurs aléatoires à chaque fois. C'est essentiel pour les tests unitaires et le débogage.

Le module random de Python est-il sécurisé ?

Non. Le module random utilise l'algorithme Mersenne Twister, qui est déterministe et prévisible. Pour les applications sensibles à la sécurité comme les mots de passe ou tokens, utilisez le module secrets à la place, qui utilise des sources aléatoires cryptographiquement sûres.

Comment mélanger une liste aléatoirement en Python ?

Utilisez random.shuffle(my_list) pour mélanger une liste sur place. Il modifie la liste originale et retourne None. Si vous avez besoin de la liste originale inchangée, faites d'abord une copie : shuffled = my_list.copy(); random.shuffle(shuffled).

Conclusion

Le module random de Python couvre tous les besoins courants de randomisation : randint pour les entiers, uniform pour les flottants, choice/choices/sample pour la sélection dans des séquences, shuffle pour le mélange et seed pour la reproductibilité. Retenez la distinction clé : choices autorise les doublons (avec remise), sample non (sans remise). Et n'utilisez jamais random pour la sécurité -- utilisez secrets à la place.