Algorithmes de calcul de termes de suites et simulations Python en Première.
Mis à jour le
En Première spé, Python devient un outil au service de tout le programme : calculer des termes et des sommes de suites, chercher un seuil, approcher une solution d'équation par la méthode de Newton, construire l'exponentielle par la méthode d'Euler, estimer une aire ou le nombre ππ par la méthode de Monte-Carlo, simuler des variables aléatoires et des échantillons.
Au programme (2026) : la notion de liste (création en extension, par ajouts successifs avec append, en compréhension ; itération sur les éléments ; accès à un élément par son indice) ; termes et sommes de suites, seuil, factorielle, suites de Syracuse et de Fibonacci ; coefficients directeurs des sécantes ; méthode de Newton ; méthode d'Euler ; Monte-Carlo ; espérance, variance et écart type d'une variable aléatoire ; moyenne d'un échantillon et écart à l'espérance ; fréquence des lettres d'un texte.
Pièges classiques : confondre un élément et son indice (range(n) parcourt 0 à n−1n-1) ; oublier l'indentation ; mal initialiser un accumulateur. Conseil : exécuter mentalement le programme sur un petit cas (n=3n=3) avant de le lancer, et afficher les variables clés avec print.
Teste tes connaissances et vérifie que tu maîtrises le chapitre.
QCM — Algorithmique et Python (51 questions)
Leçon complète
Algorithmique et Python en Première spé maths : cours complet
Rappels et fonctions
Méthode — Programmation modulaire.
On découpe un problème en fonctions courtes : chacune a des entrées (paramètres) et une sortie (return). L'affectation s'écrit x = 3 en Python et x←3x ← 3 en langage naturel.
def f(x):
return x**2 - 2
def signe(y):
if y > 0:
return "positif"
elif y < 0:
return "négatif"
return "nul"
print(signe(f(1.5))) # positif
Les listes
Méthode — Générer une liste.
L = [2, 3, 5, 7] # en extension
C = []
for k in range(1, 6):
C.append(k**2) # ajouts successifs : [1, 4, 9, 16, 25]
P = [k for k in range(20) if k % 3 == 0] # en compréhension : [0, 3, 6, ..., 18]
La liste en compréhension traduit l'ensemble {k∈{0,1,…,19}∣k multiple de 3}{k ∈ {0, 1, …, 19} | k multiple de 3} : la condition est un filtre logique.
Méthode — Manipuler et parcourir.L[0] est le premier élément, L[-1] le dernier, len(L) la longueur ; L.append(x) ajoute, L.remove(x) supprime la première occurrence de x, del L[i] supprime l'élément d'indice i.
def moyenne(L):
s = 0
for x in L: # itérer sur les éléments
s = s + x
return s / len(L)
def indice_max(L):
i_max = 0
for i in range(len(L)): # parcourir les indices
if L[i] > L[i_max]:
i_max = i
return i_max
Suites
Exemple — Terme, somme, seuil.
Pour u0=100u₀ = 100 et un+1=0,9un+20uₙ₊₁ = 0,9uₙ + 20 :
def terme(n):
u = 100
for k in range(n):
u = 0.9 * u + 20
return u
def seuil(s): # premier n tel que u_n > s
n, u = 0, 100
while u <= s:
u = 0.9 * u + 20
n = n + 1
return n
Exemple — Factorielle, Syracuse, Fibonacci.
def factorielle(n):
p = 1
for k in range(1, n + 1):
p = p * k
return p # factorielle(10) = 3628800
def syracuse(n):
L = [n]
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
L.append(n)
return L # syracuse(6) = [6, 3, 10, 5, 16, 8, 4, 2, 1]
def fibonacci(n):
F = [1, 1]
while len(F) < n:
F.append(F[-1] + F[-2])
return F # fibonacci(10) = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
Dérivation et exponentielle
Exemple — Coefficients directeurs des sécantes.
def secantes(f, a, pas):
return [(f(a + h) - f(a)) / h for h in pas]
def carre(x):
return x**2
print(secantes(carre, 1, [1, 0.1, 0.01])) # [3.0, 2.1, 2.01]
Les coefficients se rapprochent de 22, le nombre dérivé de x↦x2x ↦ x² en 11.
Exemple — Méthode de Newton.
Pour approcher une solution de f(x)=0f(x) = 0, on remplace la courbe par sa tangente : xn+1=xn−f′(xn)f(xn)xₙ₊₁ = xₙ - f(xₙ)/f'(xₙ). Avec f(x)=x2−2f(x) = x² - 2 et x0=1x₀ = 1 : 1,51,5 ; 1,41671,416 7 ; 1,4142161,414 216… qui converge très vite vers 2√2.
def newton(f, fp, x, n):
for k in range(n):
x = x - f(x) / fp(x)
return x
Exemple — Exponentielle : méthode d'Euler et nombre ee.exp′=expexp' = exp et exp(0)=1exp(0) = 1 : avec un pas hh, yk+1=yk+hyk=(1+h)ykyₖ₊₁ = yₖ + h yₖ = (1 + h)yₖ. Avec h=0,1h = 0,1, on obtient exp(1)≈1,110≈2,594exp(1) ≈ 1,1¹⁰ ≈ 2,594. La suite (1+n1)n(1 + 1/n)ⁿ donne 2,5942,594 ; 2,7052,705 ; 2,7172,717 pour n=10n = 10, 100100, 10001 000 : elle s'approche de e≈2,718e ≈ 2,718.
Trigonométrie : Archimède
Exemple — Approcher ππ.
Archimède encadre ππ par les demi-périmètres de polygones réguliers inscrits dans un cercle de rayon 11 : en doublant le nombre de côtés, le côté cc devient 2−4−c2√(2 - √(4 - c²)).
from math import sqrt
def archimede(etapes):
n, c = 6, 1.0 # hexagone : côté 1
for k in range(etapes):
c = sqrt(2 - sqrt(4 - c**2))
n = 2 * n
return n * c / 2 # demi-périmètre
On obtient 33 ; 3,1063,106 ; 3,1333,133 ; 3,1393,139 ; 3,1413,141 pour 66, 1212, 2424, 4848, 9696 côtés.
Probabilités
Exemple — Monte-Carlo.
from random import random
def estime_pi(N):
c = 0
for k in range(N):
if random()**2 + random()**2 <= 1:
c = c + 1
return 4 * c / N
Une exécution avec N=100000N = 100 000 a donné 3,1383,138. Le même principe estime l'aire sous la parabole y=x2y = x² entre 00 et 11 (environ 311/3).
Exemple — Espérance, variance, écart type.
from math import sqrt
def esperance(X, P):
return sum([X[i] * P[i] for i in range(len(X))])
def variance(X, P):
E = esperance(X, P)
return sum([P[i] * (X[i] - E)**2 for i in range(len(X))])
X, P = [0, 1, 2, 3], [0.1, 0.3, 0.4, 0.2]
print(esperance(X, P), variance(X, P), sqrt(variance(X, P))) # 1.7 0.81 0.9
Erreurs classiques
Attention — À éviter.
Oublier que les indices commencent à 00 : le dernier élément est L[len(L) - 1], soit L[-1].
Utiliser / au lieu de // pour une division entière (Syracuse).
Placer return à l'intérieur de la boucle.
Confondre la condition d'arrêt d'une boucle while et la condition qu'on cherche : on boucle tant que le seuil n'est pas dépassé.
Fiche de synthèse
Générer
[2, 3, 5] ; append dans une boucle ; [f(k) for k in … if …]
Manipuler
L[i], L[-1], len, append, remove, del
Parcourir
for x in L ; for i in range(len(L))
Suites
boucle for (terme, somme) ; while (seuil)
Newton
x←x−f′(x)f(x)x ← x - f(x)/f'(x)
Euler
y←y+hy′y ← y + h y'
Exercices d'application
Exercice 1 – Liste en compréhension
Écrire la liste des carrés des entiers pairs compris entre 00 et 1010.
Exercice 2 – Somme
Écrire une fonction somme(L) qui renvoie la somme des éléments d'une liste, sans utiliser sum.
Exercice 3 – Seuil
Pour la suite u0=1000u₀ = 1 000, un+1=1,05unuₙ₊₁ = 1,05uₙ, écrire une fonction qui renvoie le premier nn tel que un>2000uₙ > 2 000, et donner le résultat.
Corrigés des exercices
Corrigé de l'exercice 1
Corrigé.[k**2 for k in range(0, 11, 2)], soit [0, 4, 16, 36, 64, 100].
Corrigé de l'exercice 2
Corrigé.
def somme(L):
s = 0
for x in L:
s = s + x
return s
Corrigé de l'exercice 3
Corrigé.
def seuil():
n, u = 0, 1000
while u <= 2000:
u = 1.05 * u
n = n + 1
return n
Elle renvoie 1515 (1,0514≈1,981,05¹⁴ ≈ 1,98 et 1,0515≈2,081,05¹⁵ ≈ 2,08).
FAQ — Algorithmique et Python en Première spé
Pourquoi utiliser des fonctions ?
Pour réutiliser du code, organiser un programme, le rendre plus lisible et testable.
À quoi servent les simulations ?
À estimer des probabilités difficiles à calculer théoriquement, à vérifier un modèle, à explorer un phénomène.
Comment éviter les boucles infinies ?
Vérifier que la condition de sortie sera atteinte : la variable de boucle doit être modifiée à chaque tour.
Tout sur algorithmique et python au lycée
Variables, fonctions, boucles, listes, puis seuils, dichotomie et simulations : le Python du programme de la Seconde à la Terminale.