Algorithmique et programmation — Terminale

Python en Terminale spécialité maths : les algorithmes utiles

Q: Faut-il apprendre une liste d’algorithmes Python par cœur pour le Bac ?

Non. Cette page ne présente pas une liste officielle fermée. Le plus utile est de savoir lire, compléter et adapter des structures courantes à un problème mathématique.

Q: Quelle différence entre une boucle for et une boucle while ?

On utilise généralement for lorsque le nombre de répétitions est connu, et while lorsque la répétition continue tant qu’une condition reste vraie, par exemple avant le dépassement d’un seuil.

Q: Pourquoi range(1, 6) s’arrête-t-il à 5 ?

Dans range(debut, fin), la valeur fin est exclue. range(1, 6) produit donc 1, 2, 3, 4 et 5.

Q: Une simulation donne-t-elle la probabilité exacte ?

Non. Elle produit une fréquence expérimentale. Quand le nombre d’essais augmente, cette fréquence peut se rapprocher de la probabilité théorique, mais elle reste issue d’une expérience aléatoire.

Apprends à traduire un problème mathématique en instructions Python : calculer une suite, rechercher un seuil, approcher une solution ou simuler une expérience aléatoire.

Il ne s’agit pas d’une liste officielle fermée à réciter. Les exemples présentent des structures courantes à comprendre, expliquer et adapter aux données de l’exercice.

Tableau problème → structure Python

Problème mathématique	Structure Python à envisager
Mémoriser ou mettre à jour une valeur	variable et affectation
Répéter un nombre connu de fois	boucle for avec range
Répéter jusqu’à atteindre un seuil	boucle while
Choisir entre plusieurs cas	condition if / elif / else
Réutiliser un calcul	fonction définie avec def
Accumuler des termes	variable somme initialisée à 0
Conserver plusieurs résultats	liste, seulement si elle est utile
Simuler un tirage	fonction aléatoire adaptée à l’expérience

Variables

Un nom mémorise une valeur qui peut ensuite être remplacée.

Boucles et conditions

for, while et if organisent les répétitions et les choix.

Fonctions et listes

def rend un calcul réutilisable ; une liste conserve plusieurs valeurs si nécessaire.

1. Les bases Python réellement utiles

Comprendre une affectation et une condition simple.

u = 2
# On remplace u par la valeur suivante
u = 3 * u - 1

# On choisit un message selon la valeur obtenue
if u > 4:
    message = "seuil dépassé"
else:
    message = "seuil non dépassé"

print(u, message)

Résultat attendu : 5 seuil dépassé

Explication ligne par ligne

1.u reçoit d’abord la valeur 2.
2.La deuxième affectation remplace u par 3 × 2 − 1, donc par 5.
3.La condition u > 4 est vraie : Python exécute le premier bloc indenté.
4.print affiche la valeur finale et le message choisi.

Erreur fréquente

Lire u = 3 * u - 1 comme une égalité mathématique. En Python, = affecte une nouvelle valeur à la variable.

Exercice rapide

Remplace la valeur initiale par u = 1 et prévois l’affichage avant d’exécuter le programme.

2. Calculer les termes d’une suite définie par récurrence

Calculer u₅ pour u₀ = 2 et uₙ₊₁ = 0,5uₙ + 3.

u = 2  # valeur de u_0

for n in range(5):
    # u reçoit le terme suivant
    u = 0.5 * u + 3

print(u)

Résultat attendu : 5.875

Explication ligne par ligne

1.Avant la boucle, u contient u₀.
2.range(5) produit cinq passages, associés ici au calcul de u₁ à u₅.
3.À chaque passage, l’ancienne valeur de u sert à calculer la suivante.
4.Après cinq mises à jour, u contient u₅.

Erreur fréquente

Écrire range(6) en pensant qu’il faut inclure l’indice 5 : cela calculerait u₆, car u₀ est déjà connu avant la boucle.

Exercice rapide

Modifie le programme pour afficher successivement u₁, u₂, …, u₅.

3. Rechercher le premier rang dépassant un seuil

Trouver le premier rang n pour lequel uₙ > 5,9.

u = 2  # valeur de u_0
n = 0

# On continue tant que le seuil n'est pas dépassé
while u <= 5.9:
    u = 0.5 * u + 3
    n = n + 1

print(n, u)

Résultat attendu : 6 5.9375

Explication ligne par ligne

1.u et n représentent au départ u₀ et son rang 0.
2.La boucle continue tant que le seuil 5,9 n’est pas strictement dépassé.
3.u et n sont mis à jour ensemble afin de conserver le bon indice.
4.À la sortie, la condition est fausse : uₙ > 5,9 et n est le premier rang correspondant.

Erreur fréquente

Oublier n = n + 1 ou utiliser u < 5.9 lorsque l’énoncé demande un dépassement strict et qu’une égalité est possible.

Exercice rapide

Recherche de la même manière le premier rang pour lequel uₙ > 5,99.

4. Calculer une somme

Calculer 1² + 2² + … + 10².

somme = 0  # accumulateur

for k in range(1, 11):
    # On ajoute le carré courant
    somme = somme + k ** 2

print(somme)

Résultat attendu : 385

Explication ligne par ligne

1.La variable somme est initialisée à 0, élément neutre de l’addition.
2.range(1, 11) fournit les entiers de 1 à 10 : la borne 11 est exclue.
3.k ** 2 calcule le carré de k.
4.Chaque carré est ajouté au total déjà accumulé.

Erreur fréquente

Commencer à 1 sans initialiser somme, ou écrire range(1, 10) et oublier 10².

Exercice rapide

Adapte le programme pour calculer 1³ + 2³ + … + 20³.

5. Approcher une solution par dichotomie

Approcher la solution positive de x² = 2 à 10⁻³ près.

a = 1
b = 2

# On réduit l'encadrement [a, b]
while b - a > 0.0001:
    m = (a + b) / 2
    if m ** 2 < 2:
        a = m
    else:
        b = m

print(round((a + b) / 2, 3))

Résultat attendu : 1.414 (arrondi au millième).

Explication ligne par ligne

1.La solution positive est encadrée au départ entre 1 et 2.
2.m est le milieu de l’intervalle courant.
3.Si m² < 2, la solution se trouve entre m et b ; sinon, elle se trouve entre a et m.
4.La boucle s’arrête lorsque la largeur de l’encadrement ne dépasse plus 0,0001, ce qui suffit ici pour afficher un millième fiable.

Erreur fréquente

Mettre à jour la mauvaise borne. Il faut d’abord relier le test à la monotonie de la fonction étudiée sur l’intervalle.

Exercice rapide

Adapte le test pour approcher la solution positive de x² = 5.

6. Simuler une expérience aléatoire

Simuler un lancer de dé équilibré et tester si le résultat vaut 6.

from random import randint

# Un lancer de dé équilibré
resultat = randint(1, 6)
succes = resultat == 6

print(resultat, succes)

Le premier affichage est un entier de 1 à 6 ; le second vaut True uniquement si cet entier est 6.

Explication ligne par ligne

1.randint(1, 6) choisit un entier parmi 1, 2, …, 6, bornes incluses.
2.== compare deux valeurs, contrairement à = qui réalise une affectation.
3.La variable succes contient un booléen : True ou False.
4.Une simulation fournit une issue possible, pas la probabilité théorique à elle seule.

Erreur fréquente

Utiliser randint(1, 7), qui peut produire 7, ou confondre resultat = 6 et resultat == 6.

Exercice rapide

Modifie le succès pour simuler l’événement « obtenir un nombre pair ».

7. Estimer une probabilité par répétition

Estimer la probabilité d’obtenir 6 avec 10 000 lancers simulés.

from random import randint, seed

# La graine rend l'exemple reproductible
seed(0)
nombre_succes = 0
N = 10_000

for _ in range(N):
    # On compte uniquement les 6
    if randint(1, 6) == 6:
        nombre_succes = nombre_succes + 1

frequence = nombre_succes / N
print(frequence)

Le programme affiche une fréquence proche de 1/6 ; dans l’environnement de vérification utilisé ici, elle vaut 0.1669.

Explication ligne par ligne

1.seed(0) rend ici la suite de tirages reproductible pour vérifier l’exemple.
2.Le compteur augmente seulement lorsque le lancer simulé vaut 6.
3.La fréquence est le nombre de succès divisé par le nombre total d’essais.
4.Elle est proche de 1/6, sans être obligatoirement égale à la probabilité théorique.

Erreur fréquente

Présenter la fréquence simulée comme une preuve que la probabilité vaut exactement 1/6.

Exercice rapide

Estime la probabilité d’obtenir un nombre supérieur ou égal à 5.

8. Traduire un algorithme écrit en français en Python

Traduire : « calculer le carré d’un réel puis retrancher 2 ».

def image(x):
    # Carré de x, puis retrait de 2
    resultat = x ** 2 - 2
    return resultat

print(image(3))

Résultat attendu : 7

Explication ligne par ligne

1.def image(x) crée une fonction qui reçoit le nombre x.
2.Le bloc indenté traduit les deux opérations dans l’ordre demandé.
3.return renvoie le résultat au point d’appel.
4.image(3) calcule 3² − 2.

Erreur fréquente

Utiliser print à la place de return dans la fonction : la valeur serait affichée mais difficile à réutiliser dans un calcul.

Exercice rapide

Écris une fonction qui renvoie 2x³ + 1.

9. Compléter un programme à trous

Pour un entier naturel n, compléter une fonction qui calcule uₙ avec u₀ = 1 et uₖ₊₁ = 2uₖ + 1.

def terme(n):
    u = 1
    # La relation est appliquée n fois
    for k in range(n):
        u = 2 * u + 1
    return u

print(terme(3))

Résultat attendu : 15

Explication ligne par ligne

1.u = 1 correspond à la valeur initiale u₀.
2.Pour n entier naturel, atteindre uₙ demande d’appliquer la relation de récurrence n fois.
3.La variable k compte les passages mais n’intervient pas dans la formule.
4.terme(3) calcule successivement 3, 7 puis 15.

Erreur fréquente

Placer return u dans la boucle : la fonction s’arrêterait dès le premier passage.

Exercice rapide

Sans exécuter le programme, détermine terme(4), puis vérifie ta réponse.

10. Repérer et corriger une erreur dans un programme

Corriger le calcul de la somme des entiers de 1 à 5.

somme = 0  # correction : partir de 0

# 6 est exclu, donc la boucle va de 1 à 5
for k in range(1, 6):
    somme = somme + k

print(somme)

Programme corrigé — résultat attendu : 15

Explication ligne par ligne

1.La version erronée initialisait somme à 1 et utilisait range(1, 5).
2.Un accumulateur additif doit commencer à 0.
3.La borne finale de range étant exclue, il faut écrire 6 pour inclure 5.
4.Le résultat 15 peut être contrôlé mentalement avec 1 + 2 + 3 + 4 + 5.

Erreur fréquente

Corriger une seule des deux erreurs et s’arrêter parce que le programme s’exécute sans message d’erreur.

Exercice rapide

Introduis volontairement une erreur de borne, puis explique précisément son effet sur le résultat.

Mémo Python imprimable

Huit vérifications avant de valider un programme dans un exercice.

Je repère les données initiales avant la boucle.
Je choisis for si le nombre de répétitions est connu, while si l’arrêt dépend d’une condition.
Je vérifie si la borne finale de range doit être incluse ou exclue.
J’aligne l’indice de la suite avec le nombre de passages dans la boucle.
J’utilise == pour comparer et = pour affecter.
J’initialise un compteur ou une somme avant de l’actualiser.
Je contrôle l’indentation de chaque bloc.
Je teste le résultat sur un cas calculable à la main.

Continuer avec les chapitres associés

Étudier une suite Probabilités conditionnelles Calculer une limite Programme de Terminale Exercices sur les suites Exercices de probabilités Exercices type bac guidés Questions de quiz sur Python

Teste maintenant tes réflexes Python

Le quiz Terminale contient trois questions d’algorithmique parmi les vingt questions corrigées.

Ouvrir le quiz

Questions fréquentes

Faut-il apprendre une liste d’algorithmes Python par cœur pour le Bac ?

Non. Cette page ne présente pas une liste officielle fermée. Le plus utile est de savoir lire, compléter et adapter des structures courantes à un problème mathématique.

Quelle différence entre une boucle for et une boucle while ?

On utilise généralement for lorsque le nombre de répétitions est connu, et while lorsque la répétition continue tant qu’une condition reste vraie, par exemple avant le dépassement d’un seuil.

Pourquoi range(1, 6) s’arrête-t-il à 5 ?

Dans range(debut, fin), la valeur fin est exclue. range(1, 6) produit donc 1, 2, 3, 4 et 5.

Une simulation donne-t-elle la probabilité exacte ?

Non. Elle produit une fréquence expérimentale. Quand le nombre d’essais augmente, cette fréquence peut se rapprocher de la probabilité théorique, mais elle reste issue d’une expérience aléatoire.