Fiches · MathématiquesFR · Bac

Algorithmique et programmation

Python est l'outil numérique transversal du programme de spécialité : il sert à calculer des termes de suites, des sommes et des intégrales approchées, à rechercher un seuil, à encadrer une solution d'équation et à simuler des expériences aléatoires. Ce thème rassemble les bases du langage (variables, conditions, boucles for/while), les fonctions et les listes, les algorithmes liés au programme (seuils, sommes, suites, dichotomie/balayage, méthode des rectangles) et la simulation aléatoire (module random, estimation d'une probabilité par fréquence). On y apprend aussi à lire un programme, à en faire la trace d'exécution et à corriger une erreur.

5 sections~25 min de lecture4 compétencesNiveau Base 1 · Standard 2 · Approfondissement 2Vérifié · 06/2026

T·121212 / 12

Profil d’examen

Écrire, lire, modifier et exécuter « à la main » un programme Python en lien avec le programme (variables, conditions, boucles, fonctions, listes).Programmer un algorithme de recherche de seuil (boucle while) ou de balayage / dichotomie pour encadrer la solution d'une équation f(x)=0.Utiliser fonctions et listes pour structurer un calcul : termes de suites, sommes (accumulateur ou sum), intégrale approchée par la méthode des rectangles.Simuler une expérience aléatoire (loi binomiale, fréquence d'un événement, moyenne d'un échantillon), estimer une probabilité ou une aire et interpréter le résultat.

Opérateurs :écrireliremodifierexécuterprogrammersimulerestimerinterpréterjustifiercorriger

niveau de base

Maîtriser d'abord la lecture et la trace d'exécution d'un programme court (variables, boucle for/while, condition), savoir compléter une ligne manquante et reconnaître l'algorithme attendu (seuil, somme, simulation).

niveau approfondi

En spécialité, savoir écrire entièrement une fonction Python demandée (recherche de seuil, dichotomie, méthode des rectangles, simulation), relier la sortie du programme à un résultat d'analyse (limite, aire, probabilité) et repérer puis corriger une erreur en justifiant la correction.

Profondeur

Texte

Sommaire · 5 sections

Algorithmique et programmation

Bases du langage Python : variables, affectations, conditions, boucles for et while#

BaseBO-2019-spe-maths-terminale-§Algorithmique-et-programmation

for vs while : choisir la bonne boucle

Fig. 1On choisit `for` quand le nombre de tours est connu (parcours, somme de n termes) et `while` quand on s'arrête sur une condition (recherche de seuil, précision atteinte).

Variable et affectation : une variable est un nom associé à une valeur stockée en mémoire ; l'affectation s'écrit `x = 3` et signifie « ranger la valeur

3

dans la case nommée x » (le `=` n'est PAS une égalité mathématique). Une réaffectation comme `x = x + 1` se lit de droite à gauche : on calcule d'abord `x + 1` avec l'ancienne valeur, puis on la range dans x (on dit qu'on incrémente x). Les types usuels au lycée sont `int` (entier), `float` (réel à virgule, le séparateur décimal est le POINT : `3.5`) et `bool` (`True` / `False`).

Instruction conditionnelle : `if condition: ... elif autre_condition: ... else: ...` exécute un bloc selon la valeur d'un test booléen. Les comparaisons s'écrivent `==` (égal), `!=` (différent), `<`, `<=`, `>`, `>=` ; on combine des tests avec `and`, `or`, `not`. ATTENTION : en Python, c'est l'INDENTATION (le décalage par espaces) qui délimite les blocs — il n'y a ni accolades ni `begin/end`.

Boucle `for` (nombre d'itérations CONNU) : `for k in range(n):` répète le bloc en faisant prendre à k les valeurs

0, 1, 2, \dots, n-1

— soit

n

tours. Plus généralement `range(a, b)` parcourt

a, a+1, \dots, b-1

et `range(a, b, p)` avance de

p

p

. On l'utilise pour calculer une somme, parcourir une liste, ou itérer une suite explicite.

Boucle `while` (CONDITION D'ARRÊT) : `while condition:` répète le bloc TANT QUE la condition est vraie ; on l'emploie quand on ignore à l'avance le nombre d'itérations, typiquement pour une RECHERCHE DE SEUIL (« combien d'années pour dépasser un capital ? »). Il faut que la condition finisse par devenir fausse, sinon la boucle est infinie.

Différence essentielle : on choisit `for` quand le nombre de répétitions est fixé d'avance (par exemple parcourir une liste ou sommer

n

termes) et `while` quand on s'arrête sur un événement (dépassement d'un seuil, précision atteinte). Dans une recherche de seuil, le compteur d'itérations donne directement le rang ou le nombre de pas cherché.

\texttt{for k in range(n):}\quad\longrightarrow\quad k \in \{0,\,1,\,2,\,\dots,\,n-1\}\ \ (n\ \text{tours})

Sémantique de range

`range(n)` produit les entiers de $0$ à $n-1$ inclus : la boucle effectue exactement $n$ itérations, et la borne $n$ N'est PAS atteinte.

x \leftarrow x + 1 \qquad (\texttt{x = x + 1})

Affectation / incrémentation

On évalue le membre de droite avec l'ANCIENNE valeur de x, puis on range le résultat dans x : c'est une instruction, pas une équation.

Exemple corrigé

Trace d'un programme et choix de la boucle

On donne le programme Python suivant. Indiquer ce qu'il affiche, puis le réécrire avec une boucle `while` produisant le même résultat. ``` s = 0 for k in range(1, 5): s = s + k print(s) ```

Suivre la valeur de s tour par tour
La variable `s` part de $0$ ; `k` prend successivement les valeurs $1, 2, 3, 4$ (range(1, 5) exclut $5$ ). À chaque tour on ajoute `k` à `s`.
$s : 0 \to 0{+}1{=}1 \to 1{+}2{=}3 \to 3{+}3{=}6 \to 6{+}4{=}10$
Conclure l'affichage
Après la boucle, `s` vaut $10$ : le programme calcule $1+2+3+4=10$ et affiche `10`.
$\sum_{k=1}^{4} k = \frac{4\times 5}{2} = 10$
Réécrire avec une boucle while
On introduit un compteur `k` initialisé à $1$ , qu'on incrémente tant qu'il ne dépasse pas $4$ : ``` s = 0 k = 1 while k <= 4: s = s + k k = k + 1 print(s) ``` La condition `k <= 4` joue le rôle de la borne de `range`.

Résultat : Le programme affiche `10` ; la version `while` (compteur `k` de $1$ à $4$ ) donne le même résultat. Ici une boucle `for` est plus naturelle car le nombre de tours est connu.

Erreurs fréquentes

Croire que `for k in range(n)` parcourt $1, 2, \dots, n$ : il parcourt $0, 1, \dots, n-1$ ; la borne $n$ est EXCLUE et le premier indice est $0$ . Pour obtenir $1$ à $n$ , on écrit `range(1, n+1)`.
Confondre `=` (affectation) et `==` (test d'égalité) : `if x = 0:` provoque une erreur ; un test s'écrit `if x == 0:`. De même, oublier l'indentation ou les deux-points `:` après `if`, `for`, `while` casse le programme.

Révision active

Écrire un programme qui demande un entier $n$ (`n = 50` par exemple), puis affiche le nombre d'entiers entre $1$ et $n$ qui sont multiples de $3$ (on utilisera une boucle `for`, un test avec l'opérateur `%` de reste, et un compteur incrémenté).

Rappel actif

Rappelle-toi les points clés — puis révèle.

Sources : Programme de spécialité mathématiques — classe terminale (BO spécial n° 8 du 25 juillet 2019) (Ministère de l'Éducation nationale — Éduscol)

Fonctions et listes : définition, paramètres, valeur de retour, parcours, listes en compréhension#

StandardBO-2019-spe-maths-terminale-§Algorithmique-et-programmation

Anatomie d'une fonction Python

Fig. 2Une fonction reçoit un (ou plusieurs) paramètre, exécute son bloc, puis RENVOIE une valeur via `return` — réutilisable dans un calcul (ici l'accumulateur d'une somme).

Définir une FONCTION : `def f(x): ... return resultat`. Le mot-clé `def` ouvre la définition, `x` est un PARAMÈTRE (une variable d'entrée), et `return` renvoie la VALEUR DE RETOUR puis termine l'exécution de la fonction. On appelle ensuite la fonction par `f(2)`, qui vaut la valeur renvoyée. Une fonction peut avoir plusieurs paramètres : `def somme(a, b): return a + b`. Sans `return`, la fonction renvoie `None` (rien d'utilisable).

Distinguer `return` et `print` : `return` RENVOIE une valeur réutilisable dans un calcul (`y = f(3)`), tandis que `print` se contente d'AFFICHER à l'écran sans renvoyer de valeur exploitable. Pour structurer un calcul (sommer, comparer, itérer), il faut `return`.

Une LISTE est une collection ordonnée et modifiable de valeurs, notée entre crochets : `L = [3, 7, 1, 9]`. On accède au terme d'indice

i

par `L[i]` — les indices commencent à

0

, donc `L[0]` vaut

3

et `L[-1]` vaut le dernier terme. `len(L)` donne la longueur, `L.append(v)` ajoute `v` à la fin, et on parcourt la liste par `for x in L:` (sur les valeurs) ou `for i in range(len(L)):` (sur les indices).

LISTE EN COMPRÉHENSION : `[f(k) for k in range(n)]` construit en une ligne la liste

[f(0), f(1), \dots, f(n-1)]

. C'est l'outil idéal pour fabriquer la liste des termes d'une suite

u_k

, des images

f(x_k)

ou des valeurs d'une simulation. On peut filtrer : `[k for k in range(20) if k % 2 == 0]` ne garde que les entiers pairs.

Sommer une liste de valeurs : soit avec la fonction intégrée `sum(L)`, soit « à la main » avec un ACCUMULATEUR — on initialise `s = 0`, puis `for x in L: s = s + x`. L'accumulateur est le motif universel pour calculer une somme

\sum u_k

ou une aire approchée ; `sum` est un raccourci équivalent.

\texttt{def f(x): return ...}\qquad\text{appel : } y = f(a)\ \text{vaut la valeur renvoyée}

Définition et appel d'une fonction

`def` crée la fonction, `return` fixe la valeur de sortie ; l'appel `f(a)` remplace le paramètre par l'argument $a$ et renvoie le résultat.

\texttt{[f(k) for k in range(n)]} \;=\; \big[\,f(0),\ f(1),\ \dots,\ f(n-1)\,\big]

Liste en compréhension

Construit en une instruction la liste des $n$ premières images : c'est la traduction directe d'une famille $(f(k))_{0\le k\le n-1}$ .

\texttt{s = 0} \;;\; \texttt{for x in L: s = s + x} \quad\Longleftrightarrow\quad \texttt{sum(L)} \;=\; \sum_{k=0}^{\,|L|-1} L[k]

Somme par accumulateur

L'accumulateur `s` cumule les termes un à un ; `sum(L)` réalise exactement la même somme.

Exemple corrigé

Fonction renvoyant un terme de suite et somme par accumulateur

Soit la suite définie par $u_n = \dfrac{1}{n+1}$ pour $n \ge 0$ . 1. Écrire une fonction Python `u(n)` qui renvoie $u_n$ . 2. Écrire une fonction `somme(N)` qui renvoie la somme $S_N = u_0 + u_1 + \dots + u_N$ à l'aide d'un accumulateur. 3. Donner la valeur affichée par `somme(3)`.

Définir la fonction u
Le terme est explicite : on renvoie directement $\frac{1}{n+1}$ . ``` def u(n): return 1 / (n + 1) ```
Construire la somme par accumulateur
On initialise l'accumulateur `s = 0`, puis on ajoute `u(k)` pour `k` de $0$ à $N$ inclus (donc `range(N + 1)`). ``` def somme(N): s = 0 for k in range(N + 1): s = s + u(k) return s ```
$S_N = \sum_{k=0}^{N} \frac{1}{k+1}$
Évaluer somme(3)
On somme les quatre premiers termes $u_0, u_1, u_2, u_3$ .
$S_3 = 1 + \tfrac{1}{2} + \tfrac{1}{3} + \tfrac{1}{4} = \tfrac{12+6+4+3}{12} = \tfrac{25}{12} \approx 2{,}083$

Résultat : `u(n)` renvoie $\frac{1}{n+1}$ , `somme(N)` cumule les termes par accumulateur, et `somme(3)` affiche $\frac{25}{12} \approx 2{,}083$ .

Erreurs fréquentes

Confondre `return` et `print` : une fonction qui se contente de `print(x)` ne renvoie rien d'exploitable, donc `y = f(3)` vaut `None` et tout calcul ultérieur échoue. Pour réutiliser la valeur, il faut `return`.
Se tromper d'indice : `L[0]` est le PREMIER terme (pas `L[1]`), et `L[len(L)]` n'existe pas (dernier indice valide $= \text{len}(L)-1$ ), ce qui provoque une erreur d'« index out of range ».

Révision active

On considère la suite définie par $u_0 = 2$ et $u_{n+1} = 0{,}5\,u_n + 3$ . Écrire une fonction `terme(n)` qui renvoie $u_n$ en itérant la relation de récurrence avec une boucle `for`, puis construire par compréhension la liste `[terme(k) for k in range(8)]` des huit premiers termes.

Rappel actif

Rappelle-toi les points clés — puis révèle.

Sources : Programme de spécialité mathématiques — classe terminale (BO spécial n° 8 du 25 juillet 2019) (Ministère de l'Éducation nationale — Éduscol)

Algorithmes du programme : recherche de seuil, sommes et calcul de termes de suites#

StandardBO-2019-spe-maths-terminale-§Algorithmique-et-programmation

Organigramme d'une recherche de seuil (boucle while)

Fig. 3On part de

u = u_0

n = 0

, puis tant que

u < S

on itère la suite (

u \leftarrow g(u)

) et on incrémente

n

; dès que

u \ge S

, on sort et

n

est le rang cherché.

RECHERCHE DE SEUIL : pour une suite

(u_n)

qui tend vers

+\infty

(ou converge), on cherche le plus petit rang

n

tel que

u_n

dépasse (ou approche à

\varepsilon

près) une valeur fixée. On itère la relation de récurrence dans une boucle `while` qui s'arrête dès que le seuil est atteint, en comptant les tours. La SORTIE de l'algorithme est le rang cherché ; l'analyse (comportement de

q^n

, croissances comparées, limite monotone) garantit ensuite que ce rang existe.

Calcul d'un TERME de suite : si

u_n

est explicite (

u_n = f(n)

), on renvoie directement `f(n)` ; si la suite est définie par récurrence

u_{n+1} = g(u_n)

, on part de

u_0

et on applique

g

exactement

n

fois dans une boucle `for k in range(n)`. C'est le squelette de toute fonction `terme(n)`.

Calcul d'une SOMME : on accumule. Pour

S_N = \sum_{k=0}^{N} u_k

, on initialise `s = 0`, puis on ajoute chaque terme dans une boucle `for k in range(N + 1)`. Variante : construire la liste des termes par compréhension puis appliquer `sum`. Attention au nombre de termes : la somme de

u_0

u_N

comporte

N+1

termes, d'où `range(N + 1)`.

Schéma type de la boucle de seuil : `n = 0 ; u = u0 ; while u < S: u = g(u) ; n = n + 1`. À la sortie, `n` est le premier rang tel que `u >= S`. On adapte le test (`u > S`, `abs(u - L) <= eps`, etc.) selon la question, et on veille à incrémenter `n` au bon endroit pour que le compteur corresponde au rang réel.

LIEN ANALYSE / ALGORITHME : l'algorithme calcule numériquement un seuil ou une somme, mais ne PROUVE rien à lui seul — il faut justifier mathématiquement l'existence du seuil (par exemple «

q^n \to +\infty

donc le seuil est franchi ») ou la valeur de la somme (formule de la somme géométrique). Python donne la valeur, l'analyse la justifie.

\text{Seuil : plus petit } n \text{ tel que } u_n \ge S \quad\longrightarrow\quad \texttt{while u < S: u = g(u); n = n + 1}

Algorithme de recherche de seuil (while)

On itère la suite tant que le seuil $S$ n'est pas atteint ; le compteur `n` donne le rang du premier dépassement.

S_N = \sum_{k=0}^{N} u_k \quad\longrightarrow\quad \texttt{s = 0; for k in range(N+1): s = s + u(k)}

Somme par accumulateur

L'accumulateur cumule les $N+1$ termes de rang $0$ à $N$ : la borne `range(N+1)` garantit le bon compte.

Recherche de seuil : u₀ = 100, uₙ₊₁ = 1,08 uₙ ; premier rang où uₙ > 200

Fig. 4La suite géométrique de raison 1,08 croît jusqu'à franchir le seuil 200 : la boucle `while` s'arrête au premier rang dépassant la barre, ici n = 10 (u₁₀ ≈215,9).

Exemple corrigé

Recherche de seuil par boucle while

Une espèce végétale invasive couvre une surface $S_0 = 12$ hectares et s'étend de $20\%$ par an : $S_{n+1} = 1{,}2\,S_n$ . On souhaite connaître le nombre d'années au bout duquel la surface dépasse $50$ hectares. 1. Écrire une fonction Python `seuil()` qui renvoie ce nombre d'années. 2. Déterminer sa valeur par une trace, et justifier que ce seuil existe.

Écrire la fonction
On part de la surface initiale et on multiplie par $1{,}2$ tant qu'on n'a pas dépassé $50$ , en comptant les années. ``` def seuil(): S = 12 n = 0 while S <= 50: S = 1.2 * S n = n + 1 return n ```
Tracer les valeurs successives
On suit $S$ jusqu'au premier dépassement de $50$ .
$S: 12 \to 14{,}4 \to 17{,}3 \to 20{,}7 \to 24{,}9 \to 29{,}9 \to 35{,}8 \to 43{,}0 \to 51{,}6$
Conclure et justifier
Le seuil $50$ est franchi au $8^{\text{e}}$ tour ( $S_8 \approx 51{,}6 > 50$ ), donc `seuil()` renvoie $8$ . L'existence du seuil est garantie car $(S_n)$ est géométrique de raison $1{,}2 > 1$ , donc $S_n = 12 \times 1{,}2^{\,n} \to +\infty$ : toute valeur, en particulier $50$ , finit par être dépassée.
$S_n = 12 \times 1{,}2^{\,n} \xrightarrow[n\to+\infty]{} +\infty$

Résultat : `seuil()` renvoie $8$ : il faut $8$ ans pour dépasser $50$ hectares. Le franchissement est certain car $1{,}2 > 1$ entraîne $S_n \to +\infty$ .

Erreurs fréquentes

Incrémenter le compteur au mauvais endroit ou décaler le test : selon que l'on incrémente avant ou après la mise à jour de `u`, le rang renvoyé peut être décalé de $1$ . Il faut tracer un ou deux tours pour vérifier que `n` correspond bien au rang du premier dépassement.
Mettre une condition d'arrêt qui ne devient jamais fausse (boucle infinie) : par exemple `while u < S` avec une suite DÉCROISSANTE qui n'atteint jamais $S$ , ou un oubli de la mise à jour de `u` dans la boucle.

Révision active

Un capital de $1500$ € placé à $4\%$ par an suit $C_0 = 1500$ , $C_{n+1} = 1{,}04\,C_n$ . Écrire une fonction `annees()` qui renvoie le nombre d'années nécessaires pour que le capital dépasse $2000$ €, puis justifier mathématiquement que ce seuil est forcément atteint.

Rappel actif

Rappelle-toi les points clés — puis révèle.

Sources : Programme de spécialité mathématiques — classe terminale (BO spécial n° 8 du 25 juillet 2019) (Ministère de l'Éducation nationale — Éduscol)

Encadrer une solution et approcher une aire : balayage, dichotomie, méthode des rectangles#

ApprofondissementBO-2019-spe-maths-terminale-§Algorithmique-et-programmation

Dichotomie : encadrement successif d'une racine

Fig. 5À chaque étape, on calcule le milieu

m

et on garde la moitié où

f

change de signe : l'encadrement de la racine

\alpha

est divisé par deux à chaque tour.

BALAYAGE : pour encadrer une solution de

f(x) = 0

sur

[a\,;b]

(où

f

est continue et monotone, avec

f(a)

f(b)

de signes contraires), on parcourt l'intervalle par petits pas

p

depuis

a

et on s'arrête dès que

f

change de signe ; on obtient alors un encadrement de la racine d'amplitude

p

. C'est simple mais lent : pour une précision

p = 10^{-k}

, il faut beaucoup de pas.

DICHOTOMIE : méthode plus efficace, qui DIVISE l'intervalle en DEUX à chaque étape. On calcule le milieu

m = \frac{a+b}{2}

; si

f(a)

f(m)

sont de signes contraires, la racine est dans

[a\,;m]

(on pose

b = m

), sinon elle est dans

[m\,;b]

(on pose

a = m

). À chaque tour, l'amplitude de l'encadrement est DIVISÉE PAR DEUX ; on répète jusqu'à atteindre la précision voulue

b - a \le \varepsilon

Théorème sous-jacent (admis au lycée) : si

f

est continue sur

[a\,;b]

et change de signe (

f(a) \times f(b) < 0

), alors l'équation

f(x) = 0

admet (au moins) une solution dans

[a\,;b]

; si de plus

f

est strictement monotone, cette solution est unique. La dichotomie en construit un encadrement aussi fin qu'on veut.

MÉTHODE DES RECTANGLES : pour approcher

\int_a^b f(x)\,dx

(aire sous la courbe pour

f \ge 0

), on découpe

[a\,;b]

n

sous-intervalles de même largeur

h = \frac{b-a}{n}

. L'aire est approchée par la somme des aires de

n

rectangles, chacun de largeur

h

et de hauteur

f(x_k)

où

x_k = a + k\,h

\int_a^b f \approx h \sum_{k=0}^{n-1} f(a + k\,h)

. Plus

n

est grand, plus l'approximation est précise.

En Python : la dichotomie s'écrit avec une boucle `while b - a > eps` qui met à jour `a` ou `b` selon le signe de `f(m)` ; la méthode des rectangles avec une boucle `for k in range(n)` qui accumule `h f(a + kh)`. Dans les deux cas, l'algorithme fournit une valeur approchée que l'analyse (continuité, signe, valeur de l'intégrale exacte) vient encadrer ou justifier.

\int_a^b f(x)\,dx \;\approx\; h\sum_{k=0}^{n-1} f(a + k\,h), \qquad h = \frac{b-a}{n}

Méthode des rectangles (à gauche)

On somme les aires de $n$ rectangles de largeur $h$ et de hauteur $f(x_k)$ : c'est une somme de Riemann qui tend vers l'intégrale quand $n \to +\infty$ .

m = \frac{a+b}{2}, \quad f(a)\,f(m) < 0 \Rightarrow b \leftarrow m, \quad \text{sinon } a \leftarrow m \quad (\text{amplitude } \div 2 \text{ par tour})

Dichotomie

À chaque étape, le milieu remplace la borne du même signe : l'intervalle contenant la racine est divisé par deux, donc l'encadrement converge très vite.

Méthode des rectangles sous la courbe

Fig. 6On découpe

[a\,;b]

n

tranches de largeur

h

; chaque rectangle a pour hauteur

f(x_k)

. La somme de leurs aires approche

\int_a^b f

— d'autant mieux que

n

est grand.

Méthode des rectangles : approximation de ∫₀¹ x² dx = 1/3 ≈ 0,333 selon n

Fig. 7L'approximation par rectangles (à gauche) de ∫₀¹ x² dx se rapproche de la valeur exacte 1/3 quand le nombre de subdivisions n augmente : sous-estimation qui converge par le bas.

Exemple corrigé

Méthode des rectangles pour approcher une intégrale

On veut approcher $I = \displaystyle\int_0^1 x^2\,dx$ par la méthode des rectangles à gauche. 1. Écrire une fonction Python `rectangles(n)` qui renvoie l'approximation de $I$ avec $n$ rectangles. 2. Donner l'approximation obtenue pour $n = 4$ . 3. Comparer à la valeur exacte et expliquer le sens de l'écart.

Écrire la fonction
La largeur d'un rectangle est $h = \frac{1 - 0}{n}$ ; on accumule $h \times f(x_k)$ avec $f(x) = x^2$ et $x_k = k\,h$ pour $k$ de $0$ à $n-1$ . ``` def rectangles(n): a, b = 0, 1 h = (b - a) / n s = 0 for k in range(n): x = a + k * h s = s + h x*2 return s ```
Calculer pour n = 4
Avec $n = 4$ , $h = 0{,}25$ et les abscisses $x_k = 0,\ 0{,}25,\ 0{,}5,\ 0{,}75$ . On somme les aires $h \times x_k^2$ .
$0{,}25\,(0^2 + 0{,}25^2 + 0{,}5^2 + 0{,}75^2) = 0{,}25\times 0{,}875 = 0{,}21875$
Comparer à la valeur exacte
La valeur exacte de l'intégrale est $\frac{1}{3} \approx 0{,}333$ . L'approximation $0{,}21875$ est INFÉRIEURE : avec des rectangles à gauche et $f$ croissante, chaque rectangle est entièrement sous la courbe, d'où une SOUS-ESTIMATION qui se réduit quand $n$ grandit.
$\int_0^1 x^2\,dx = \left[\frac{x^3}{3}\right]_0^1 = \frac{1}{3} \approx 0{,}333$

Résultat : `rectangles(4)` renvoie $0{,}21875$ , valeur approchée par défaut de $\frac{1}{3} \approx 0{,}333$ ; l'écart vient des rectangles à gauche sous une fonction croissante (sous-estimation), et il diminue lorsque $n$ augmente.

Erreurs fréquentes

Mal tester le changement de signe : il faut comparer le signe de `f(a) * f(m)` (produit négatif = signes contraires), pas comparer $f(m)$ à une valeur. Une erreur de signe envoie la dichotomie dans la mauvaise moitié et fausse l'encadrement.
Pour les rectangles, se tromper de bornes ou de hauteur : la somme va de $k = 0$ à $n-1$ (rectangles à GAUCHE : hauteur $f(a + k\,h)$ ) ; oublier le facteur de largeur $h$ , ou faire $n+1$ rectangles, donne un résultat faux.

Révision active

Soit $f(x) = x^3 + x - 1$ . Vérifier que $f$ est strictement croissante et que l'équation $f(x) = 0$ a une unique solution dans $[0\,;1]$ , puis écrire une fonction `dichotomie(eps)` qui renvoie un encadrement de cette solution d'amplitude inférieure à `eps`.

Rappel actif

Rappelle-toi les points clés — puis révèle.

Sources : Programme de spécialité mathématiques — classe terminale (BO spécial n° 8 du 25 juillet 2019) (Ministère de l'Éducation nationale — Éduscol)

Simulation aléatoire et estimation : module random, fréquences, loi binomiale, lecture et correction d'un programme#

ApprofondissementBO-2019-spe-maths-terminale-§Algorithmique-et-programmation

Trace d'exécution tabulée d'une boucle de simulation

Fig. 8Faire la trace d'une boucle, c'est suivre la valeur de chaque variable tour par tour ; ici un compteur de succès `s` croît selon les tirages, et la fréquence `s/N` estime la probabilité.

GÉNÉRATION DE NOMBRES ALÉATOIRES : le module `random` fournit `random()` qui renvoie un réel pseudo-aléatoire dans

[0\,;1[

(loi uniforme), et `randint(a, b)` qui renvoie un entier aléatoire entre

a

b

INCLUS (par exemple `randint(1, 6)` simule un dé). Pour simuler un événement de probabilité

p

, on teste `random() < p` (vrai avec probabilité

p

ESTIMER UNE PROBABILITÉ PAR FRÉQUENCE : on répète

N

fois l'expérience, on compte le nombre de succès, et la FRÉQUENCE observée

\frac{\text{succès}}{N}

estime la probabilité

p

. La loi des grands nombres garantit que cette fréquence se rapproche de

p

quand

N

devient grand : plus on répète, plus l'estimation est fiable.

SIMULER UNE LOI BINOMIALE : une variable

X \sim \mathcal{B}(n, p)

compte le nombre de succès en

n

épreuves de Bernoulli indépendantes de paramètre

p

. On la simule par une fonction qui répète

n

tirages `random() < p` et compte les succès. En répétant cette simulation un grand nombre de fois, l'HISTOGRAMME des valeurs obtenues approche la distribution théorique de

X

(centrée autour de

np

ESTIMER UNE AIRE / PROBABILITÉ PAR MONTE-CARLO : on peut estimer une aire (ou une probabilité géométrique) en tirant des points aléatoires et en comptant la proportion qui tombe dans une région ; cette fréquence approche l'aire cherchée. La MOYENNE EMPIRIQUE d'un échantillon (moyenne des valeurs simulées) estime de même l'espérance théorique.

LIRE, TRACER ET CORRIGER un programme : faire la TRACE D'EXÉCUTION consiste à dresser un tableau des valeurs successives des variables, tour par tour, pour comprendre ou vérifier un programme. Pour CORRIGER une erreur, on repère le symptôme (résultat faux, boucle infinie, sortie décalée), on localise l'instruction fautive (borne de `range` erronée, test mal placé, compteur non incrémenté, `==`/`=` confondus) et on COMMENTE la correction apportée.

P(\text{succès}) = p \;\longrightarrow\; \texttt{random() < p}, \qquad \widehat{p} = \frac{\text{nombre de succès}}{N} \xrightarrow[N\to+\infty]{} p

Estimation d'une probabilité par fréquence

Le test `random() < p` réussit avec probabilité $p$ ; la fréquence des succès sur $N$ répétitions estime $p$ et s'en rapproche (loi des grands nombres).

X \sim \mathcal{B}(n, p) : \quad X = \#\{\text{succès parmi } n \text{ tirages}\}, \qquad E(X) = np

Loi binomiale simulée

On simule $X$ en comptant les succès de $n$ épreuves de Bernoulli ; la moyenne empirique des simulations approche l'espérance $np$ .

Histogramme d'une simulation de X ∼ B(10 ; 0,5) (1 000 répétitions)

Fig. 9En répétant la simulation de X (nombre de piles sur 10 lancers), l'histogramme des fréquences se concentre autour de E(X) = np = 5 et approche la loi binomiale théorique.

Exemple corrigé

Simuler une probabilité par fréquence et corriger un programme

On veut estimer la probabilité d'obtenir « au moins un $6$ » en lançant un dé équilibré $4$ fois. Un élève propose le programme suivant, qui renvoie un résultat manifestement trop faible. ``` from random import randint def estime(N): succes = 0 for i in range(N): six = False for j in range(4): if randint(1, 5) == 6: six = True if six: succes = succes + 1 return succes / N ``` 1. Repérer l'erreur. 2. Corriger le programme et commenter. 3. Donner la probabilité théorique pour valider l'ordre de grandeur attendu.

Repérer l'erreur
Le tirage `randint(1, 5)` ne produit JAMAIS la valeur $6$ (les entiers tirés vont de $1$ à $5$ inclus). La condition `== 6` est donc toujours fausse, `six` reste `False`, et la fonction renvoie toujours $0$ : c'est pourquoi le résultat est trop faible (nul).
Corriger et commenter
On simule un vrai dé à six faces avec `randint(1, 6)` (les deux bornes sont incluses) : ``` from random import randint def estime(N): succes = 0 for i in range(N): six = False for j in range(4): if randint(1, 6) == 6: # dé à 6 faces : borne haute = 6 six = True if six: succes = succes + 1 return succes / N ``` La correction porte sur la borne supérieure du `randint`, qui doit valoir $6$ pour qu'un $6$ puisse sortir.
Valider par le calcul théorique
La probabilité de n'obtenir AUCUN $6$ sur $4$ lancers est $\left(\frac{5}{6}\right)^4$ ; donc « au moins un $6$ » a pour probabilité son complément.
$P(\text{au moins un } 6) = 1 - \left(\frac{5}{6}\right)^4 = 1 - \frac{625}{1296} \approx 0{,}518$

Résultat : L'erreur était `randint(1, 5)` au lieu de `randint(1, 6)` (le $6$ ne pouvait jamais sortir). Après correction, la fréquence simulée pour $N$ grand approche la valeur théorique $1 - (5/6)^4 \approx 0{,}518$ .

Erreurs fréquentes

Mal traduire la probabilité $p$ : pour simuler un succès de probabilité $p$ , on teste `random() < p`, et NON `random() < 1 - p` qui simule l'échec (probabilité $1 - p$ ). À noter : comme `random()` renvoie un réel sur $[0\,;1[$ , l'égalité exacte est de probabilité nulle, donc `random() <= p` a la même probabilité $p$ que `random() < p` — la vraie distinction utile est `< p` (succès) contre `< 1 - p` (échec). Oublier que `randint(1, 6)` inclut les DEUX bornes est une autre erreur fréquente.
Confondre estimation et valeur exacte : une fréquence simulée APPROCHE la probabilité, elle ne la prouve pas et varie d'une exécution à l'autre ; annoncer « la probabilité vaut exactement $0{,}48$ » à partir d'une seule simulation est faux.

Révision active

Écrire une fonction `frequence(N)` qui simule $N$ lancers de deux dés à six faces (avec `randint`) et renvoie la fréquence de l'événement « la somme des deux dés vaut $7$ ». Faire tourner pour $N = 10\,000$ et comparer à la probabilité théorique $\frac{6}{36} = \frac{1}{6} \approx 0{,}167$ .

Rappel actif

Rappelle-toi les points clés — puis révèle.

Sources : Programme de spécialité mathématiques — classe terminale (BO spécial n° 8 du 25 juillet 2019) (Ministère de l'Éducation nationale — Éduscol)

Références et sources

Sources

Ministère de l'Éducation nationale — Éduscol

Programme de spécialité mathématiques — classe terminale (BO spécial n° 8 du 25 juillet 2019)

Algorithmique et programmation

Points clés

Trace d'un programme et choix de la boucle

Points clés

Fonction renvoyant un terme de suite et somme par accumulateur

Points clés

Recherche de seuil par boucle while

Points clés

Méthode des rectangles pour approcher une intégrale

Points clés

Simuler une probabilité par fréquence et corriger un programme

Sources