TP Python n°3 — Probabilités & Statistiques

1

Palier guidé

🔵 Guidé — lire et compléter

🪙

Contexte — simuler le hasard avec Python La fonction random.random() renvoie un nombre décimal tiré au hasard entre 0 et 1 (valeur différente à chaque appel). En comparant ce nombre à une probabilité p, on simule n'importe quelle épreuve aléatoire — sans dé, sans pièce, sans rien.

💡 L'idée clé

random.random() < 0.5 est vrai environ une fois sur deux — comme pile ou face.
random.random() < 0.7 est vrai environ 7 fois sur 10 — comme un événement de probabilité 0,7.
En répétant cela des milliers de fois dans une boucle, on estime des probabilités : c'est la méthode Monte-Carlo.

❓ Exercice 1 — Lire et comprendre

Voici un programme qui simule 1 000 lancers d'une pièce équilibrée et compte le nombre de « pile ». Que représente la variable compteur à la fin du programme ?

pile_ou_face.py

import random
compteur = 0
for i in range(1000) :
    if random.random() < 0.5 :
        compteur = compteur + 1
print(compteur)

AToujours exactement 500, car P(pile) = 0,5

BLe nombre de fois où random.random() a renvoyé exactement 0,5

CLe nombre de lancers simulés « pile », un résultat aléatoire proche de 500

DLe nombre de lancers simulés « face »

✅ Bonne réponse : C.

compteur augmente d'1 chaque fois que random.random() renvoie un nombre strictement inférieur à 0,5, ce qui arrive environ une fois sur deux. Le résultat est aléatoire — proche de 500 mais rarement exactement 500. En relançant le programme on obtiendrait une valeur différente. La réponse B est fausse : random.random() tire dans [0 ; 1[ en continu, la probabilité d'obtenir exactement 0,5 est nulle.

✏️ Exercice 2 — Compléter

On veut simuler 10 000 lancers d'une pièce biaisée, où « pile » sort avec une probabilité de 0,3. Le programme compte le nombre de « pile » et affiche la fréquence obtenue. Complète les deux trous.

exercice2.py

import random
N        = 10000
compteur = 0
for i in range(N) :
    if random.random() <  :
        compteur = compteur + 1
print(compteur / )
# affiche un nombre proche de 0.3

Pour simuler un événement de probabilité p, on compare random.random() à cette valeur p. La fréquence se calcule en divisant le compteur par le nombre total de lancers.

Terminal Python

2

Palier semi-guidé

🟠 Semi-guidé — déboguer et adapter

🏥

Contexte — test de dépistage On reprend le tableau croisé étudié en cours. Sur 1 000 personnes testées :

	Test +	Test −	Total
Malade	36	4	40
Non malade	48	912	960
Total	84	916	1000

🐛 Exercice 3 — Corriger le code

Un élève veut calculer P_Malade(Positif) — la probabilité d'avoir un test positif chez les malades — puis P_Positif(Malade). Son code contient deux bugs de dénominateur.

proba_cond_bugue.py

total         = 1000
malades       = 40
positifs      = 84
malade_et_pos = 36

# P_Malade(Positif)
p1 = malade_et_pos / total       # ← bug 1
print(p1)

# P_Positif(Malade)
p2 = malade_et_pos / malades     # ← bug 2
print(p2)

Pour chaque probabilité conditionnelle, quel dénominateur faut-il utiliser ?

Bug 1 — malade_et_pos /

Bug 2 — malade_et_pos /

Pour P_A(B), on restreint l'univers à A : le dénominateur est l'effectif de A. Identifie dans chaque cas qui joue le rôle de A.

Terminal Python

✏️ Exercice 4 — Adapter

On sait que P_Malade(Positif) = 0,9 et P_{Non malade}(Positif) = 0,05. Le programme ci-dessous simule le test sur une population de 10 000 personnes (dont 4 % sont malades) et estime ces deux probabilités conditionnelles. Deux trous à compléter.

exercice4.py

import random
N = 10000
malade_et_pos = 0
malades_total = 0

for i in range(N) :
    malade = random.random() < 0.04   # 4% de malades
    if malade :
        malades_total = malades_total + 1
        if random.random() <  :  # sensibilité du test
            malade_et_pos = malade_et_pos + 1

print(malade_et_pos / )
# affiche un nombre proche de 0.9

Le premier trou est la probabilité qu'un malade soit détecté positif. Le second trou : on veut estimer P_Malade(Positif), donc on divise le nombre de malades positifs par le nombre total de malades simulés.

Terminal Python

❓ Exercice 5 — Interpréter

Deux élèves exécutent chacun ce programme et obtiennent des résultats différents. Laquelle de ces affirmations est correcte ?

question5.py

import random
compteur = 0
for i in range(100) :
    if random.random() < 0.5 :
        compteur += 1
print(compteur / 100)

Mia obtient 0.47, Tom obtient 0.53.

AL'un des deux a fait une erreur, car la fréquence doit être exactement 0,5.

BAvec 100 lancers c'est insuffisant, le programme est mal écrit.

CLes deux résultats sont faux car ils ne sont pas égaux entre eux.

DLes deux résultats sont corrects : c'est la variabilité naturelle d'une simulation.

✅ Bonne réponse : D.

Une simulation produit des résultats aléatoires — deux exécutions du même programme donnent des valeurs différentes. Avec seulement 100 lancers, les fluctuations peuvent être importantes (ici ±3 points). Si on portait N à 100 000, les deux résultats seraient bien plus proches de 0,5, mais toujours pas exactement égaux.

3

Palier autonome

🟣 Autonome — écrire son propre code

🎲

Contexte — lancer de deux dés On lance simultanément deux dés équilibrés à 6 faces. En Python, random.randint(1, 6) simule le lancer d'un dé (renvoie un entier entre 1 et 6 inclus). On s'intéresse à la somme des deux dés et à d'autres événements.

⌨️ Exercice 6 — Écrire

Écris un programme qui simule 10 000 lancers de deux dés et estime la probabilité d'obtenir une somme égale à 7.

Tu auras besoin de : import random, random.randint(1, 6), une boucle for, un compteur, et un print de la fréquence.

La valeur théorique est 6/36 ≈ 0,167 — vérifie que ta simulation s'en approche.

exercice6.py

corrigé6.py

import random
N        = 10000
compteur = 0
for i in range(N) :
    d1 = random.randint(1, 6)
    d2 = random.randint(1, 6)
    if d1 + d2 == 7 :
        compteur = compteur + 1
print(compteur / N)

Les 6 combinaisons gagnantes sont (1,6), (2,5), (3,4), (4,3), (5,2), (6,1) sur 36 possibles → P = 6/36 ≈ 0,167. La simulation devrait donner un résultat proche.

⌨️ Exercice 7 — Aller plus loin

Modifie ton programme pour estimer la probabilité d'obtenir un double (les deux dés affichent la même valeur). Affiche la fréquence obtenue pour N = 100, N = 1 000, puis N = 100 000 dans trois print() séparés.

Observe comment la fréquence se stabilise autour de la valeur théorique quand N augmente : c'est la loi des grands nombres.

exercice7.py

corrigé7.py

import random

def simul(N) :
    compteur = 0
    for i in range(N) :
        d1 = random.randint(1, 6)
        d2 = random.randint(1, 6)
        if d1 == d2 :
            compteur = compteur + 1
    return compteur / N

print(simul(100))
print(simul(1000))
print(simul(100000))

Il y a 6 doubles sur 36 issues → P(double) = 1/6 ≈ 0,167. Avec N = 100, la fréquence peut varier entre 0,10 et 0,24 ; avec N = 100 000, elle sera généralement entre 0,165 et 0,169. C'est la loi des grands nombres en action. La version avec une fonction def simul(N) est élégante mais pas obligatoire — trois boucles séparées sont aussi correctes.