Écrire, lire et utiliser en Python les algorithmes cités par le programme de Terminale : terme, somme et seuil d'une suite ; méthode de dichotomie et méthode de Newton ; méthode des rectangles ; seuils avec l'exponentielle et le logarithme ; simulation d'un schéma de Bernoulli, d'une loi binomiale et d'échantillons ; génération de listes en dénombrement.
Programmes de Seconde et de Première : variables, fonctions def, instructions if, boucles for et while, listes (voir la notion « Notion de liste »). Terminale : suites et limites, continuité, logarithme, calcul intégral, loi binomiale, loi des grands nombres, dénombrement.
ILes outils
Le programme de Terminale n'introduit aucune instruction nouvelle : il applique les outils de Seconde et de Première à chaque partie du cours.
def f(x):puisreturn …définit une fonction qui renvoie un résultat.if condition:…else:… exécute un bloc ou l'autre.for k in range(n):répète un bloc fois ;kprend les valeurs , , …, .while condition:répète un bloc tant que la condition est vraie.- Un accumulateur s'initialise avant la boucle :
pour une somme ou un compteur, pour un produit. L.append(x)ajoutexà la fin de la listeL.
| Algorithme | Boucle utilisée |
|---|---|
| terme | for : nombre de tours connu |
| seuil, dichotomie | while : tant que le but n'est pas atteint |
| simulation de | for et un compteur |
Le module random produit des nombres pseudo-aléatoires : ils sont calculés à partir d'un point de départ, la graine. L'instruction seed(2026) fixe cette graine : le programme donne alors toujours le même affichage, et c'est celui que l'on imprime ici. Sans seed, ou avec une autre graine, on obtient d'autres résultats, de même allure.
IISuites numériques
1. Terme de rang et somme de termes
La suite
- Terme
: on part de et on applique fois la relation de récurrence (boucleforde tours). - Somme
: un accumulateurset le termeuavancent ensemble ; il y a termes, donc tours.
def terme(n):
u = 1
for k in range(n):
u = 0.8 * u + 2
return u
def somme(n):
s = 0
u = 1
for k in range(n + 1):
s = s + u
u = 0.8 * u + 2
return s
print(round(terme(3), 4))
print(round(somme(3), 4))5.392
13.432On vérifie :
La suite définie par
Elle est géométrique de raison
2. Algorithme de seuil
On calcule les termes un par un tant que le seuil n'est pas dépassé, en comptant les tours. La condition du while est le contraire de la condition cherchée : on veut n est le rang cherché.
def seuil(A):
n = 0
u = 1
while u <= A:
u = 0.8 * u + 2
n = n + 1
return n
print(seuil(9))10
On a divisé par
3. Une suite majorée qui ne dépasse jamais le seuil
Un algorithme de seuil ne s'arrête que si le seuil est réellement dépassé à partir d'un certain rang. Ici, l'appel seuil(10) ne se termine jamais.
Par récurrence. Initialisation :
La condition u <= 10 reste donc toujours vraie : la boucle est infinie. La suite converge vers
On limite le nombre de tours avec un second paramètre nmax, puis on teste si le seuil a bien été dépassé. La fonction renvoie None (« rien ») sinon.
def seuil2(A, nmax):
n = 0
u = 1
while u <= A and n < nmax:
u = 0.8 * u + 2
n = n + 1
if u > A:
return n
return None
print(seuil2(9, 1000))
print(seuil2(10, 1000))10
NoneIIIContinuité : résoudre
La fonction
1. La méthode de dichotomie
On part d'un intervalle
- si
et sont de signes contraires, c'est-à-dire , la solution est dans : on remplace par ; - sinon, elle est dans
: on remplace par .
On s'arrête quand l'amplitude
def f(x):
return x**3 + x - 1
def dichotomie(a, b, e):
while b - a > e:
m = (a + b) / 2
if f(a) * f(m) <= 0:
b = m
else:
a = m
return a, b
print(dichotomie(0, 1, 0.01))(0.6796875, 0.6875)| Tour | signe de | nouvel intervalle | |
|---|---|---|---|
| 1 | |||
| 2 | |||
| 3 | |||
| 4 |
L'amplitude est divisée par
2. La méthode de Newton
On part d'une valeur
Dans les cas favorables (comme ici), la suite
La tangente au point d'abscisse
def fp(x):
return 3 * x**2 + 1
x = 1
for k in range(4):
x = x - f(x) / fp(x)
print(k + 1, x)1 0.75
2 0.686046511627907
3 0.6823395825973142
4 0.6823278039465127Après 0.6823278038280194). La dichotomie, elle, gagne environ une décimale tous les
Il faut connaître la dérivée
IVCalcul intégral : la méthode des rectangles
Soit
- À gauche, les hauteurs sont
, …, ; - à droite, les hauteurs sont
, …, .
Si
La fonction inverse est décroissante sur
def f(x):
return 1 / x
def gauche(a, b, n):
h = (b - a) / n
S = 0
for k in range(n):
S = S + h * f(a + k*h)
return S
def droite(a, b, n):
h = (b - a) / n
s = 0
for k in range(1, n + 1):
s = s + h * f(a + k*h)
return s
for n in [4, 10, 100]:
s = round(droite(1, 2, n), 4)
S = round(gauche(1, 2, n), 4)
print(n, s, S)4 0.6345 0.7595
10 0.6688 0.7188
100 0.6907 0.6957
Avec
VExponentielle et logarithme : seuils
- Par un algorithme : on teste
, , , … avec une bouclewhile; on obtient le plus petit entier qui convient. - Par le calcul : on résout l'inéquation avec la fonction
(croissante) ou la fonction . C'est le calcul qui démontre le résultat.
Un capital de
n = 0
c = 1000
while c <= 2000:
c = c * 1.03
n = n + 1
print(n, round(c, 2))24 2032.79Par le calcul, comme
Le capital a doublé au bout de
La masse d'un produit radioactif vaut
from math import exp
t = 0
while 100 * exp(-0.3*t) >= 1:
t = t + 1
print(t)16Par le calcul :
On a divisé par
En remplaçant t = t + 1 par t = round(t + 0.01, 2), la même boucle avance de 15.36 : c'est une valeur approchée par excès, au centième, de round efface les erreurs d'arrondi des décimaux en machine.
VIProbabilités : simuler
1. Schéma de Bernoulli et loi binomiale
random() renvoie un nombre au hasard dans random() < p est vrai avec la probabilité bernoulli(p) simule donc une épreuve de Bernoulli de paramètre
from random import random, seed
def bernoulli(p):
if random() < p:
return 1
return 0
def binomiale(n, p):
x = 0
for k in range(n):
x = x + bernoulli(p)
return x
seed(2026)
R = []
for k in range(10):
R.append(bernoulli(0.3))
print(R)
print(binomiale(10, 0.3))[1, 0, 0, 0, 1, 1, 0, 0, 0, 0]
2La liste R contient les résultats de
2. Fréquences observées et probabilités
On simule E compte combien de fois chaque valeur E[k] est l'effectif de
seed(2026)
N = 1000
E = [0] * 11
for i in range(N):
x = binomiale(10, 0.3)
E[x] = E[x] + 1
for k in range(11):
print(k, E[k])0 32
1 123
2 219
3 265
4 198
5 110
6 40
7 10
8 2
9 1
10 0On compare les fréquences comb du module math.
from math import comb
def p_binom(n, p, k):
q = 1 - p
c = comb(n, k)
return c * p**k * q**(n - k)
for k in range(6):
pk = p_binom(10, 0.3, k)
f = E[k] / N
print(k, f, round(pk, 3))0 0.032 0.028
1 0.123 0.121
2 0.219 0.233
3 0.265 0.267
4 0.198 0.2
5 0.11 0.103
3. Calculer un seuil pour une loi binomiale
On ajoute les probabilités p_binom ci-dessus.
def seuil_binom(n, p, a):
k = 0
s = p_binom(n, p, 0)
while s < a:
k = k + 1
s = s + p_binom(n, p, k)
return k, round(s, 4)
print(seuil_binom(10, 0.3, 0.95))(5, 0.9527)Pour
4. Échantillons et loi des grands nombres
La fréquence des succès dans un échantillon de taille
seed(2026)
for n in [10, 100, 1000, 10000]:
s = 0
for i in range(n):
s = s + bernoulli(0.3)
print(n, s / n)10 0.3
100 0.21
1000 0.285
10000 0.308Les fréquences fluctuent beaucoup pour de petits échantillons, puis se stabilisent autour de
VIIDénombrement : générer des listes
1. Le triangle de Pascal
Pour
def suivante(L):
M = [1]
for k in range(len(L) - 1):
M.append(L[k] + L[k + 1])
M.append(1)
return M
L = [1]
for n in range(6):
print(L)
L = suivante(L)[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]La ligne
2. Les parties à éléments d'un ensemble
Deux boucles imbriquées : pour chaque indice i, l'indice j parcourt les indices suivants ; chaque partie est ainsi obtenue une seule fois.
E = ["a", "b", "c", "d"]
P = []
for i in range(len(E)):
for j in range(i + 1, len(E)):
P.append([E[i], E[j]])
for c in P:
print(c)
print(len(P))['a', 'b']
['a', 'c']
['a', 'd']
['b', 'c']
['b', 'd']
['c', 'd']
6On retrouve
VIIIBilan
| Partie du programme | Algorithmes |
|---|---|
| Suites | terme for) ; seuil, suite majorée (while) |
| Continuité | dichotomie (while, if) ; méthode de Newton |
| Calcul intégral | rectangles (for, accumulateur) |
| Exp et ln | seuils (while, puis |
| Probabilités | Bernoulli, binomiale, échantillons (random, compteur) |
| Dénombrement | triangle de Pascal, parties (listes) |
Méthode de la sécante, algorithme de Briggs (logarithme), méthode d'Euler pour
- Dans un algorithme de seuil, la condition du
whileest le contraire de la condition cherchée. - Avant de chercher un seuil, on vérifie qu'il sera dépassé (suite majorée : boucle infinie).
- Diviser une inégalité par
(quand ) change son sens. - Dichotomie : on garde la moitié où
change de signe, et on s'arrête sur l'amplitude , pas sur . - Rectangles :
range(n)pour les rectangles à gauche ( à ),range(1, n + 1)à droite. - Une simulation sans
seeddonne un résultat différent à chaque exécution.
- Seuil :
while u <= A:et un compteur, puis vérification par le logarithme. - Dichotomie : l'amplitude est divisée par
à chaque tour. - Newton :
. - Rectangles :
(somme des hauteurs), avec . - Bernoulli :
random() < p; binomiale : somme de Bernoulli ; la fréquence tend vers . - Pascal : chaque coefficient est la somme des deux nombres voisins de la ligne du dessus.
Fiche de synthèse dans l'onglet Fiches !
Cours lu ? Continue avec :