Mathématiques (spécialité) · TerminaleBac

Simulation de variables aléatoires : cours de Terminale

Publié le 6 novembre 2026 · Mis à jour le 6 novembre 2026 · Signaler une erreur

L'essentiel

Simuler, c'est faire fabriquer par l'ordinateur des valeurs qui se comportent comme une variable aléatoire donnée, à partir d'un générateur de nombres pseudo-aléatoires uniformes sur [0 ; 1].²⁴
Une épreuve de Bernoulli de paramètre $p$ se simule par le test « nombre tiré $< p$ » : succès codé 1, échec codé 0.
Des tirages répétés avec des appels indépendants du générateur donnent des variables indépendantes de même loi (iid) ; la somme de $n$ telles variables de Bernoulli suit une loi binomiale.⁴
Estimer une probabilité par simulation : répéter l'expérience un grand nombre de fois et calculer la fréquence observée ; le résultat varie d'une exécution à l'autre.
Une simulation ne démontre rien : elle donne une valeur approchée, à comparer avec le calcul exact quand il est possible.

Pourquoi simuler le hasard ?

Calculer une probabilité à la main est parfois facile : pour un dé équilibré, chaque face a une probabilité de $\frac{1}{6}$ . Mais dès que l'expérience devient compliquée (dix lancers, des conditions qui s'enchaînent, un jeu avec plusieurs règles), le calcul exact devient long, voire impossible à mener à la main. Une idée très puissante prend alors le relais : faire jouer l'ordinateur. Il répète l'expérience des milliers de fois en une fraction de seconde, et tu observes ce qui se passe.

C'est ce qu'on appelle la simulation. Dans ce cours, tu vas apprendre à écrire, en Python, des programmes qui reproduisent le comportement d'une variable aléatoire : une pièce, un dé, une répétition d'épreuves. Tu verras aussi ce qu'une simulation peut te dire, et ce qu'elle ne peut pas te dire.

Le programme de Terminale prolonge ce qui a été vu en classe de première sur les variables aléatoires. Il s'appuie sur les probabilités conditionnelles, l'indépendance et les variables aléatoires, et met au premier plan la répétition d'un nombre quelconque d'épreuves de Bernoulli qui se suivent.¹ La simulation permet justement de manipuler cela concrètement.

Tu connais déjà les algorithmes de seuil et de dichotomie, ainsi que la méthode d'Euler : tu sais donc écrire une boucle while, une boucle for, une fonction, et utiliser une condition if. Ces outils suffisent ici.

Rappels : variable aléatoire et loi de Bernoulli

La variable aléatoire la plus simple est celle du pile ou face, qui prend deux valeurs seulement.³ En codant 1 pour pile et 0 pour face, on obtient une variable de Bernoulli.⁴ Les variables qui, comme celle-ci, prennent des valeurs bien séparées sont qualifiées de discrètes.³

Le générateur aléatoire : la brique de départ

Un ordinateur ne lance pas de dé. Pour simuler le hasard, tous les langages proposent une fonction qui renvoie un nombre « au hasard » entre 0 et 1. En Python, c'est random() du module random. Des appels successifs à un tel algorithme fournissent des variables aléatoires de loi uniforme sur $[0\,;1]$ , indépendantes.²

Cette phrase contient des idées à bien distinguer :

loi uniforme sur $[0\,;1]$ : le nombre tiré a autant de chances de tomber dans un intervalle que dans n'importe quel autre intervalle de même longueur ;
indépendantes : le résultat d'un appel n'influence pas celui du suivant.

Tirer Urandom() donne un nombre uniforme sur [0 ; 1]
ComparerUn test avec des seuils donne la valeur de X
RépéterUn nouvel appel à chaque épreuve, dans la boucle
EstimerFréquence ou moyenne sur un grand nombre N

De l'ordinateur à la variable aléatoire · Démarche générale d'une simulation

Simuler une épreuve de Bernoulli

Pour simuler un succès de probabilité $p$ , on compare un nombre tiré uniformément dans $[0\,;1]$ à $p$ . Si $U<p$ , c'est un succès ; sinon, c'est un échec.

Démonstration · Pourquoi ça marche

L'événement $\{X=1\}$ est l'événement $\{U<p\}$ , c'est-à-dire que $U$ tombe dans l'intervalle $[0\,;p[$ , de longueur $p$ . Par la propriété de la loi uniforme, $P(X=1)=p-0=p$ . Comme $X$ ne prend que les valeurs 0 et 1, $P(X=0)=1-p$ . C'est bien la loi de Bernoulli de paramètre $p$ .

MéthodeÉcrire la fonction

from random import random

def bernoulli(p):
    """Renvoie 1 avec la probabilité p, 0 sinon."""
    if random() < p:
        return 1
    return 0

Pour une pièce équilibrée, on appelle bernoulli(0.5). Pour un tir réussi avec une probabilité de $0{,}3$ , on appelle bernoulli(0.3).

Simuler une variable à plusieurs valeurs

Le lancer d'un dé équilibré à six faces est un exemple classique de variable que l'on modélise facilement : chaque lancer se fait dans les mêmes conditions, avec le même dé.⁴ Voyons comment le simuler, puis comment généraliser à une loi quelconque.

MéthodePremière méthode : partager [0 ; 1[ en intervalles

On découpe $[0\,;1[$ en autant d'intervalles que de valeurs, chaque intervalle ayant pour longueur la probabilité de la valeur. Pour le dé : $[0\,;\frac16[$ pour la face 1, $[\frac16\,;\frac26[$ pour la face 2, etc. Une manière compacte de l'écrire est de multiplier $U$ par 6 et de prendre la partie entière :

from random import random
from math import floor

def de():
    return floor(6 * random()) + 1

Si $U\in[0\,;1[$ , alors $6U\in[0\,;6[$ , sa partie entière est dans $\{0,1,2,3,4,5\}$ , et en ajoutant 1 on obtient bien un entier de 1 à 6. Chaque valeur correspond à un intervalle de longueur $\frac16$ : le dé est équilibré.

MéthodeDeuxième méthode : une loi quelconque par cumul

Pour une loi non équilibrée, on cumule les probabilités. Exemple : la variable $G$ du jeu précédent vaut 1 avec la probabilité $\frac16$ et $-10$ avec la probabilité $\frac56$ .

def gain():
    if random() < 1/6:
        return 1
    return -10

Pour une loi à trois valeurs $a$ , $b$ , $c$ de probabilités $p_a$ , $p_b$ , $p_c$ , on écrit : si $U<p_a$ alors $a$ ; sinon si $U<p_a+p_b$ alors $b$ ; sinon $c$ .

ExempleUne loi à trois valeurs

Une variable $Y$ prend les valeurs 0, 1 et 5 avec les probabilités $0{,}5$ ; $0{,}3$ et $0{,}2$ . Les seuils cumulés sont $0{,}5$ puis $0{,}8$ .

def y():
    u = random()
    if u < 0.5:
        return 0
    if u < 0.8:
        return 1
    return 5

Si $u=0{,}62$ : $u\ge 0{,}5$ mais $u<0{,}8$ , donc $Y=1$ . L'intervalle $[0{,}8\,;1[$ a pour longueur $0{,}2$ : c'est bien la probabilité de la valeur 5.

Quelques variables et leur simulation
Situation	Variable	Simulation
Pile ou face équilibré	Bernoulli de paramètre 0,5	1 si random() < 0.5, sinon 0
Dé équilibré	Valeurs 1 à 6, chacune de probabilité 1/6	floor(6*random()) + 1
Nombre de piles sur n lancers	Somme de n variables de Bernoulli	Boucle for qui additionne n tests

Quelques variables et leur simulation · Correspondance entre situation et programme

Répéter des épreuves : variables indépendantes et de même loi

Le pile ou face répété est l'exemple type : chaque lancer est représenté par une variable (0 pour face, 1 pour pile), et toutes suivent la même loi de Bernoulli. Comme les lancers se succèdent sans s'influencer, les variables sont indépendantes.⁴ Il en va de même pour le dé ou pour un tirage avec remise dans une urne : chaque tirage se fait dans les mêmes conditions, et la remise garantit que les tirages ne dépendent pas des précédents.⁴

Dit simplement, deux variables sont indépendantes quand savoir ce que vaut la première ne change rien à ce que l'on peut attendre de la seconde.⁴ Dans un programme, on obtient cette indépendance en faisant un nouvel appel à random() à chaque répétition.

MéthodeSimuler la somme de n épreuves de Bernoulli

Pour simuler $S_n=X_1+X_2+\dots+X_n$ , où les $X_i$ sont des variables de Bernoulli de paramètre $p$ indépendantes, on répète bernoulli(p) $n$ fois et on additionne :

def somme(n, p):
    s = 0
    for i in range(n):
        s = s + bernoulli(p)
    return s

La variable $S_n$ compte le nombre de succès : elle suit la loi binomiale $\mathcal{B}(n\,;p)$ , que tu connais par ailleurs. La fonction somme(n, p) est donc une simulation d'une variable binomiale.

Attention, erreur fréquenteNe pas réutiliser la même valeur

Une erreur classique consiste à tirer une seule fois le nombre aléatoire avant la boucle :

u = random()
for i in range(n):
    s = s + (1 if u < p else 0)

Tous les termes sont alors égaux : ils ne sont plus indépendants du tout. Le résultat vaut $0$ ou $n$ et jamais autre chose. Le tirage doit se trouver dans la boucle.

Estimer une probabilité ou une moyenne par simulation

La simulation devient vraiment utile quand on la répète pour estimer une grandeur. C'est le principe des méthodes de type Monte-Carlo, qui reposent sur des variables iid : il faut donc savoir en produire par ordinateur.⁴

MéthodeEstimer une probabilité

Pour estimer $P(A)$ où $A$ est un événement lié à une expérience :

écrire une fonction qui simule une réalisation de l'expérience et renvoie True si $A$ est réalisé, False sinon ;
appeler cette fonction $N$ fois, avec $N$ grand (par exemple 10 000) ;
compter les réalisations de $A$ : la fréquence observée $\frac{\text{nombre de réalisations}}{N}$ est l'estimation.

def estimer(experience, N):
    compte = 0
    for i in range(N):
        if experience():
            compte = compte + 1
    return compte / N

ExempleAu moins un six en trois lancers

On veut estimer la probabilité d'obtenir au moins un six en lançant trois fois un dé équilibré.

def au_moins_un_six():
    for i in range(3):
        if de() == 6:
            return True
    return False

print(estimer(au_moins_un_six, 10000))

Le calcul exact passe par l'événement contraire : aucun six en trois lancers indépendants a pour probabilité $\left(\frac56\right)^3=\frac{125}{216}$ , donc

$P(\text{au moins un six})=1-\frac{125}{216}=\frac{91}{216}\approx 0{,}421.$

La simulation doit donner un nombre proche de $0{,}42$ , par exemple $0{,}419$ ou $0{,}424$ , mais pas toujours le même.

MéthodeEstimer une moyenne

Pour estimer l'espérance d'une variable $X$ , on la simule $N$ fois et on calcule la moyenne des valeurs obtenues.

def moyenne(variable, N):
    total = 0
    for i in range(N):
        total = total + variable()
    return total / N

Avec moyenne(gain, 100000), on obtient un nombre voisin de $E(G)=1\times\frac16-10\times\frac56=-\frac{49}{6}\approx -8{,}17$ : en moyenne, le joueur perd plus de 8 € par partie.

Erreurs fréquentes et conseils de rédaction

Exercices corrigés

Exercice 1 Simuler et calculer le gain d'un jeu

★☆☆Environ 10 min

Un joueur lance un dé équilibré à six faces. Il gagne 3 € s'il obtient 1 ou 2, il ne gagne rien s'il obtient 3 ou 4, et il perd 2 € s'il obtient 5 ou 6. On note $G$ le gain algébrique.

Écris une fonction Python gain() qui simule $G$ à l'aide de random().
Calcule l'espérance de $G$ .
Que devrait renvoyer, approximativement, moyenne(gain, 100000) ?

Indice 1

Chaque valeur de $G$ correspond à deux faces sur six : quelle est sa probabilité ?

Indice 2

Cumule les seuils : $\frac13$ , puis $\frac23$ .

Voir la correction pas à pas

Probabilités : $P(G=3)=\frac{2}{6}=\frac13$ , $P(G=0)=\frac13$ et $P(G=-2)=\frac13$ .
Fonction : on tire u = random(). Si u < 1/3 on renvoie 3 ; sinon si u < 2/3 on renvoie 0 ; sinon on renvoie -2.
Espérance : $E(G)=3\times\frac13+0\times\frac13+(-2)\times\frac13=\frac13$ .
Interprétation : la moyenne simulée sur 100 000 parties doit être voisine de $\frac13\approx 0{,}33$ , sans valoir exactement cette valeur.

L'espérance est $\frac13\approx 0{,}333$ euro par partie : le jeu est légèrement favorable au joueur, et une grande simulation donne une moyenne proche de cette valeur.

Exercice 2 Estimer puis calculer une probabilité

★★☆Environ 15 min

On lance trois fois de suite un dé équilibré à six faces. On s'intéresse à l'événement $A$ : « on obtient au moins un six ».

Écris une fonction experience() qui simule les trois lancers et renvoie True si $A$ est réalisé.
Explique comment estimer $P(A)$ avec 20 000 répétitions.
Calcule la valeur exacte de $P(A)$ et compare-la avec une estimation de $0{,}419$ .

Indice 1

Pense à l'événement contraire : aucun six sur les trois lancers.

Indice 2

Les trois lancers sont indépendants : les probabilités se multiplient.

Voir la correction pas à pas

Fonction : on répète trois fois floor(6*random())+1 et on renvoie True dès qu'une valeur vaut 6, False si aucune ne vaut 6.
Estimation : on appelle estimer(experience, 20000), qui compte les réalisations de $A$ et divise par 20 000.
Probabilité du contraire : à chaque lancer, la probabilité de ne pas obtenir 6 est $\frac56$ . Pour trois lancers indépendants, on obtient $\left(\frac56\right)^3$ .
Calcul : $P(A)=1-\left(\frac56\right)^3=\frac{91}{216}\approx 0{,}4213$ .
Comparaison : l'estimation $0{,}419$ est proche de $0{,}4213$ ; l'écart de quelques millièmes est normal pour une simulation.

La probabilité exacte est $\frac{91}{216}\approx 0{,}421$ . La simulation donne une valeur voisine, sans jamais la certifier.

Exercice 3 Simuler une somme de Bernoulli

★★★Environ 15 min

Un lanceur réussit un tir avec la probabilité $0{,}3$ , les tirs étant indépendants. On note $S$ le nombre de tirs réussis sur 10 tirs.

Écris une fonction tirs() qui simule $S$ en utilisant une boucle.
Quelle est l'espérance de $S$ ?
On exécute tirs() une fois et on obtient 5. Cela contredit-il le résultat de la question 2 ? Justifie.

Indice 1

Chaque tir est une épreuve de Bernoulli de paramètre $0{,}3$ .

Indice 2

L'espérance d'une loi binomiale $\mathcal{B}(n\,;p)$ vaut $np$ .

Voir la correction pas à pas

Fonction : on initialise s = 0, puis dans une boucle de 10 tours on tire random() et on ajoute 1 à s lorsque le tirage est inférieur à 0,3. On renvoie s.
Loi : $S$ est la somme de 10 variables de Bernoulli indépendantes de paramètre $0{,}3$ , donc $S$ suit $\mathcal{B}(10\,;0{,}3)$ .
Espérance : $E(S)=10\times 0{,}3=3$ .
Interprétation : une seule exécution donne une réalisation de $S$ , qui peut très bien valoir 5. Cela ne contredit pas $E(S)=3$ , qui s'interprète comme une moyenne sur un grand nombre d'exécutions.

L'espérance vaut 3 tirs réussis. Une valeur isolée comme 5 est une réalisation possible de la variable ; seule une moyenne sur de nombreuses exécutions se compare à l'espérance.

Les questions qu'on se pose

À quoi sert vraiment de simuler si on peut calculer ?

Le calcul exact n'est pas toujours possible ou rapide : plusieurs règles qui s'enchaînent, beaucoup d'épreuves, des conditions compliquées. La simulation donne alors une valeur approchée. Elle sert aussi à vérifier un calcul : si ton résultat théorique et la fréquence simulée sont très différents, l'un des deux est faux. Les méthodes de type Monte-Carlo reposent entièrement sur ce principe.⁴

Pourquoi mon programme donne-t-il un résultat différent à chaque exécution ?

Parce que les valeurs sont tirées au hasard : chaque exécution produit une réalisation différente. C'est le comportement attendu d'une variable aléatoire. Pour obtenir toujours le même résultat (par exemple pour déboguer), on fixe la graine avec random.seed(...). La graine d'un générateur doit être choisie au hasard et ne plus être modifiée ensuite quand on veut des données de qualité.⁴

Comment savoir si je dois mettre < ou > dans le test ?

Traduis ce que représente le test. random() < p est vrai avec la probabilité $p$ : c'est le bon test pour un succès de probabilité $p$ . Si tu écris random() > p, la probabilité du succès devient $1-p$ . Vérifie toujours avec une valeur extrême : pour $p=0{,}9$ , le succès doit arriver presque tout le temps.

Que faut-il savoir pour le Bac sur ce sujet ?

Il faut savoir lire et écrire de courtes fonctions Python : simuler une épreuve de Bernoulli, une somme de Bernoulli indépendantes, compter des succès, calculer une fréquence ou une moyenne. Il faut aussi savoir interpréter le résultat : une simulation donne une valeur approchée qui fluctue. Le programme indique par ailleurs que la justification de l'indépendance de variables données a priori n'est pas un objectif : elle est fournie par le modèle.¹

Quelle est la différence entre une variable de Bernoulli et une variable binomiale ?

Une variable de Bernoulli décrit une épreuve avec deux issues (1 ou 0). Une variable binomiale compte les succès dans plusieurs épreuves de Bernoulli identiques et indépendantes. En programmation, la première est un simple test avec random(), la seconde est une boucle qui additionne plusieurs de ces tests.

Sources

Programme visé : Programme de Mathématiques - Terminale Générale (Spécialité) - Algorithmique et Programmation · Éduscol - Ministère de l'Éducation Nationale

Programme de Mathématiques - Terminale Générale (Spécialité) - Algorithmique et Programmation, Éduscol - Ministère de l'Éducation Nationale. Consulté le 6 novembre 2026.
Cours de Simulation - Méthodes et Applications, Université de Bordeaux. Consulté le 6 novembre 2026.
Variable aléatoire réelle, Wikipédia. Consulté le 6 novembre 2026.
Variables indépendantes et identiquement distribuées, Wikipédia. Consulté le 6 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Simulation de variables aléatoires : cours de Terminale

L'essentiel

Pourquoi simuler le hasard ?

Rappels : variable aléatoire et loi de Bernoulli

Le générateur aléatoire : la brique de départ

Simuler une épreuve de Bernoulli

Simuler une variable à plusieurs valeurs

Répéter des épreuves : variables indépendantes et de même loi

Estimer une probabilité ou une moyenne par simulation

Erreurs fréquentes et conseils de rédaction

Exercices corrigés

Exercice 1 Simuler et calculer le gain d'un jeu

Exercice 2 Estimer puis calculer une probabilité

Exercice 3 Simuler une somme de Bernoulli

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur