Fiche récapitulative générée pour impression / export PDF.

2nde · Algorithmique et programmation en Python

Simuler des phénomènes aléatoires en Python

Le module random

Pour simuler le hasard en Python, on utilise le module random, qu'il faut importer en début de programme :

`python
import random
`

Deux fonctions essentielles


FonctionRenvoieExemple
|---|---|---|


random.random()un décimal aléatoire dans [0 ; 1[[0\ ;\ 1[0.7234...
random.randint(a, b)un entier aléatoire entre a et b inclusrandom.randint(1, 6)

Simuler un lancer de pièce

`python
import random

resultat = random.randint(0, 1)
if resultat == 0:
print("Pile")
else:
print("Face")
`

Simuler un lancer de dé

`python
import random

de = random.randint(1, 6)
print("Le dé affiche", de)
`

Répéter une simulation avec une boucle

Pour étudier la fréquence d'un événement, on répète l'expérience un grand nombre de fois à l'aide d'une boucle, en comptant les occurrences favorables.

`python
import random

compteur = 0
n = 1000
for i in range(n):
de = random.randint(1, 6)
if de == 6:
compteur = compteur + 1

frequence = compteur / n
print("Fréquence du 6 :", frequence)
`

Rappel (loi des grands nombres) : plus le nombre de répétitions nn est grand, plus la fréquence observée se rapproche de la probabilité théorique (ici 160,1667\dfrac{1}{6}\approx0{,}1667).

Exemples

✅ Exemple simple — Simuler un tirage à pile ou face

`python
import random

piece = random.randint(0, 1)
print(piece)
`

Ce programme affiche 0 ou 1 au hasard, chacun avec une probabilité 12\dfrac{1}{2}.

📘 Exemple intermédiaire — Compter les « Face » sur 10 lancers

`python
import random

compteur = 0
for i in range(10):
piece = random.randint(0, 1)
if piece == 1:
compteur = compteur + 1

print("Nombre de Face :", compteur)
`

À chaque tour de boucle, on simule un lancer et on incrémente compteur si on obtient 1 (« Face »).

🔴 Exemple avancé — Estimer une probabilité par simulation

`python
import random

compteur = 0
n = 5000
for i in range(n):
de = random.randint(1, 6)
if de == 1 or de == 2:
compteur = compteur + 1

frequence = compteur / n
print("Fréquence d'obtenir 1 ou 2 :", frequence)
`

La probabilité théorique d'obtenir 11 ou 22 avec un dé équilibré est 26=130,333\dfrac{2}{6}=\dfrac{1}{3}\approx0{,}333. Avec n=5000n=5000 répétitions, la fréquence observée doit s'en approcher.

À retenir

- import random permet d'utiliser des fonctions de tirage aléatoire.
- random.randint(a, b) renvoie un entier aléatoire entre a et b inclus ; random.random() renvoie un décimal dans [0 ; 1[[0\ ;\ 1[.
- Pour estimer une probabilité, on répète une simulation dans une boucle for en comptant les occurrences favorables, puis on divise par le nombre total de répétitions.
- D'après la loi des grands nombres, la fréquence observée se rapproche de la probabilité théorique quand nn augmente.

Exercices de la leçon

Exercice 1

Quelle instruction permet de simuler le lancer d'un dé à 6 faces en Python ?

Corrigé

random.randint(a, b) renvoie un entier aléatoire entre a et b inclus ; pour un dé à 6 faces (résultats 11 à 66), on écrit random.randint(1, 6).

Exercice 2

random.random() renvoie toujours un nombre entier.

Corrigé

random.random() renvoie un nombre décimal (de type float) compris dans [0 ; 1[[0\ ;\ 1[, pas un entier.

Exercice 3

Que fait ce programme ?

`python
compteur = 0
for i in range(200):
piece = random.randint(0, 1)
if piece == 0:
compteur = compteur + 1
frequence = compteur / 200
`

Corrigé

Le programme répète 200200 tirages, compte le nombre de fois où piece == 0, puis divise par 200200 pour obtenir la fréquence observée, qui est une estimation (et non la valeur théorique exacte).

Exercice 4

On simule n=10000n=10000 lancers de dé à 6 faces et on obtient une fréquence de 0,1680{,}168 pour l'événement « obtenir un 6 ». Que peut-on en conclure ?

Corrigé

Avec un grand nombre de répétitions, la fréquence observée se rapproche de la probabilité théorique (loi des grands nombres) ; un petit écart comme 0,1680{,}168 contre 0,1670{,}167 est normal et cohérent avec un dé équilibré.

Exercice 5

Écris un programme Python qui simule n=2000n=2000 lancers d'une pièce équilibrée (random.randint(0, 1), où 1 représente « Face »), compte le nombre de fois où on obtient « Face », puis calcule et affiche la fréquence observée.

Corrigé

C'est le schéma classique de simulation : initialiser un compteur, répéter l'expérience dans une boucle for, incrémenter le compteur selon une condition, puis diviser par le nombre total de répétitions pour obtenir la fréquence.

AlphaMath Académie · Simuler des phénomènes aléatoires en Python · Algorithmique et programmation en Python