Simuler une expérience aléatoire avec Python

Ce qu'il faut comprendre

Quand tu lances un dé, tu ne peux pas prévoir le résultat : c'est une expérience aléatoire. En Python, tu peux simuler ce genre d'expérience pour étudier les probabilités sans avoir à répéter l'expérience des centaines de fois dans la réalité. Par exemple, tu peux simuler 1000 lancers de dé et compter combien de fois tu obtiens un 6. Cela te permet de vérifier que la fréquence observée se rapproche de la probabilité théorique (1/6).

Python utilise le module random pour générer des nombres aléatoires. Avec une boucle, tu répètes l'expérience un grand nombre de fois, et avec des conditions, tu comptes les résultats qui t'intéressent. Tu peux aussi écrire une fonction pour réutiliser facilement ta simulation.

Les notions essentielles

Variable : une boîte qui stocke une valeur. Exemple : nb_lancers = 1000.
Condition : une instruction qui exécute du code seulement si une condition est vraie. En Python, on utilise if, elif, else. Exemple : if resultat == 6:.
Boucle : une structure qui répète un bloc d'instructions. La boucle for est idéale pour un nombre connu de répétitions. Exemple : for i in range(1000):.
Fonction : un bloc de code nommé que tu peux appeler plusieurs fois. Exemple : def simuler_de():.
Simulation : reproduire une expérience aléatoire avec un ordinateur.
Module random : il contient des fonctions pour générer des nombres aléatoires. La fonction randint(a, b) renvoie un entier aléatoire entre a et b inclus.

Méthode

Importer le module random : écris import random en haut de ton programme.
Définir les paramètres : choisis le nombre de répétitions, les valeurs possibles, etc.
Initialiser un compteur : crée une variable qui comptera le nombre de fois où l'événement se produit (ex: compteur = 0).
Boucle de simulation : utilise une boucle for pour répéter l'expérience.
- À chaque tour, génère un résultat aléatoire avec random.randint(1, 6) pour un dé.
- Avec une condition if, vérifie si le résultat correspond à l'événement voulu. Si oui, augmente le compteur de 1.
Afficher les résultats : après la boucle, affiche le compteur et la fréquence (compteur / nombre de lancers).
(Optionnel) Écrire une fonction : mets tout le code dans une fonction pour pouvoir l'appeler avec différents paramètres.

Exemple corrigé

Énoncé : Simule 1000 lancers d'un dé à 6 faces et affiche le nombre de fois où tu obtiens un 6, ainsi que la fréquence.

Code commenté :

import random

def simuler_de(nb_lancers):
    """Simule nb_lancers lancers de dé et renvoie le nombre de 6."""
    compteur = 0
    for i in range(nb_lancers):
        resultat = random.randint(1, 6)
        if resultat == 6:
            compteur = compteur + 1
    return compteur

# Appel de la fonction
nb = 1000
nb_six = simuler_de(nb)
frequence = nb_six / nb
print("Nombre de 6 :", nb_six)
print("Fréquence :", frequence)

Explication :

import random : on importe le module pour utiliser randint.
def simuler_de(nb_lancers): : on définit une fonction qui prend en paramètre le nombre de lancers.
compteur = 0 : on initialise le compteur à 0.
for i in range(nb_lancers): : la boucle s'exécute nb_lancers fois. i prend les valeurs 0, 1, ..., nb_lancers-1.
resultat = random.randint(1, 6) : à chaque tour, on tire un nombre entier aléatoire entre 1 et 6.
if resultat == 6: : si le résultat est 6, on augmente le compteur.
return compteur : la fonction renvoie le nombre de 6.
Ensuite, on calcule la fréquence et on affiche.

Résultat possible :

Nombre de 6 : 168
Fréquence : 0.168

(La fréquence est proche de 1/6 ≈ 0,1667.)

Erreurs fréquentes

Oublier d'importer random : si tu utilises random.randint sans avoir écrit import random, Python lève une erreur.
Confondre randint et randrange : randint(a, b) inclut b, alors que randrange(a, b) exclut b. Pour un dé, utilise randint(1, 6).
Ne pas initialiser le compteur : si tu oublies compteur = 0, tu ne peux pas l'incrémenter.
Placer l'initialisation du compteur dans la boucle : si tu mets compteur = 0 à l'intérieur de la boucle, le compteur sera remis à zéro à chaque tour.
Utiliser une boucle infinie : vérifie que ta boucle for a un nombre fini d'itérations.
Oublier l'indentation : en Python, les blocs (corps de la boucle, condition, fonction) doivent être indentés (4 espaces).

À retenir

Pour simuler une expérience aléatoire, utilise import random et random.randint().
Une boucle for permet de répéter l'expérience un grand nombre de fois.
Un compteur (variable) et une condition if permettent de compter les occurrences d'un événement.
La fréquence observée se rapproche de la probabilité théorique quand le nombre de répétitions est grand.
Une fonction rend le code réutilisable et plus clair.

Pour s'entraîner

Maintenant que tu as compris les bases, tu peux t'entraîner avec des exercices interactifs et des quiz sur AlloSeconde. Tu y trouveras aussi des fiches de révision pour consolider tes connaissances. Bon courage !