Simuler une expérience aléatoire et la loi binomiale

Simuler une épreuve de Bernoulli

Une épreuve de Bernoulli de paramètre $p$ a deux issues : succès (probabilité $p$) ou échec (probabilité $1-p$). On la simule avec random.random(), qui renvoie un décimal dans $[0\,;\,1[$ :

`python
import random

p = 0.3
tirage = random.random()
if tirage < p:
print("Succès")
else:
print("Échec")
`

Pourquoi ça marche : random.random() renvoie une valeur uniformément répartie dans $[0\,;\,1[$, donc la probabilité que tirage < p soit vraie est exactement $p$.

Simuler une réalisation de la loi binomiale

La loi binomiale $\mathcal{B}(n\,;\,p)$ compte le nombre de succès parmi $n$ répétitions indépendantes d'une épreuve de Bernoulli de paramètre $p$. On simule cela avec une boucle qui répète $n$ fois l'épreuve, en comptant les succès :

`python
import random

n = 10
p = 0.3
succes = 0
for i in range(n):
if random.random() < p:
succes = succes + 1

print("Nombre de succès :", succes)
`

Chaque exécution de ce programme simule une réalisation de la variable aléatoire $X \sim \mathcal{B}(10\,;\,0{,}3)$.

Estimer une probabilité par simulation répétée

Pour estimer $P(X=k)$, on répète la simulation précédente un grand nombre de fois, en comptant combien de fois on obtient exactement $k$ succès :

`python
import random

n = 10
p = 0.3
k = 3
nb_simulations = 5000
compteur = 0

for simulation in range(nb_simulations):
succes = 0
for i in range(n):
if random.random() < p:
succes = succes + 1
if succes == k:
compteur = compteur + 1

frequence = compteur / nb_simulations
print("Fréquence estimée de P(X=3) :", frequence)
`

Remarque : ce programme contient une boucle dans une boucle. La boucle intérieure simule une réalisation de $X$ ; la boucle extérieure répète cette simulation nb_simulations fois pour estimer une fréquence.

Exemples

✅ Exemple simple — Simuler un succès ou un échec

`python
import random

p = 0.5
print(random.random() < p)
`

Ce programme affiche True (succès) ou False (échec), chacun avec une probabilité $0{,}5$.

📘 Exemple intermédiaire — Compter les succès sur 20 répétitions

`python
import random

succes = 0
for i in range(20):
if random.random() < 0.4:
succes = succes + 1

print("Succès :", succes)
`

🔴 Exemple avancé — Estimer $P(X=0)$ par simulation

`python
import random

n = 8
p = 0.2
nb_simulations = 10000
compteur = 0

for simulation in range(nb_simulations):
succes = 0
for i in range(n):
if random.random() < p:
succes = succes + 1
if succes == 0:
compteur = compteur + 1

frequence = compteur / nb_simulations
print("Fréquence estimée de P(X=0) :", frequence)
`

La probabilité théorique est $P(X=0) = \dbinom{8}{0}\times0{,}2^0\times0{,}8^8 = 0{,}8^8 \approx 0{,}168$. Avec $10\,000$ simulations, la fréquence observée doit s'en approcher.

À retenir

- random.random() < p simule une épreuve de Bernoulli de paramètre $p$.
- Répéter cette épreuve $n$ fois en comptant les succès simule une réalisation de la loi binomiale $\mathcal{B}(n\,;\,p)$.
- Pour estimer $P(X=k)$, on répète la simulation de $X$ un grand nombre de fois (boucle dans une boucle) et on calcule la fréquence des simulations où l'on obtient exactement $k$ succès.