Ce que le bac demande vraiment en Python
Le correcteur n'attend pas que vous sachiez programmer. Il attend que vous compreniez la logique d'un algorithme et que vous puissiez compléter ou lire un programme court. En pratique, trois types de questions reviennent systématiquement.
Type 1 Compléter un programme à trous. Le plus fréquent. On vous donne un programme partiellement rédigé, avec des lignes vides matérialisées par des pointillés. Il faut identifier ce qui manque : une condition de boucle, une ligne de mise à jour, un return. La logique est toujours guidée par le contexte mathématique (la relation de récurrence, le seuil à atteindre, la somme à calculer).
Type 2 Lire et interpréter un programme. On vous demande ce que renvoie le programme pour une valeur donnée, ou ce que calcule une variable à la fin de l'exécution. Il faut simuler mentalement l'exécution, tour de boucle par tour de boucle.
Type 3 Écrire un programme court. Plus rare. On vous demande de rédiger un algorithme de seuil ou de somme, souvent après une question de cours sur la suite concernée. La structure est toujours la même, seuls les paramètres changent.
La grande majorité des questions relève du type 1 ou 2. Comprendre la structure des deux algorithmes classiques (seuil et somme) couvre l'essentiel de ce qui peut tomber.
La syntaxe indispensable
Le tableau suivant couvre l'intégralité de la syntaxe utile pour le bac. Aucune bibliothèque complexe, aucune notion avancée n'est attendue au-delà de ce périmètre.
| Élément | Syntaxe Python | Point de vigilance |
|---|---|---|
| Affectation | u = 5 | Le signe = affecte, il n'exprime pas une égalité mathématique |
| Puissance | u**2 | Jamais ^ — c'est une erreur de syntaxe en Python |
| Multiplication | 2*u | L'astérisque est obligatoire, 2u provoque une erreur |
| Nombre décimal | 0.92 | Toujours un point, jamais une virgule |
| Racine carrée | sqrt(u) | Nécessite from math import * en début de programme |
| Valeur absolue | abs(u - limite) | Utile pour les seuils de précision |
| Boucle bornée | for i in range(n): | range(n) va de 0 à n−1 ; pour aller jusqu'à n, écrire range(n+1) |
| Boucle non bornée | while condition: | La condition est celle qui maintient la boucle, pas celle qu'on cherche |
| Ajouter à une liste | L.append(x) | Ajoute x à la fin de la liste L |
| Longueur d'une liste | len(L) | Retourne le nombre d'éléments |
| Définir une fonction | def f(x): | Le bloc doit être indenté ; se termine par return |
Une seule erreur de syntaxe invalide un programme entier. Les deux erreurs les plus fréquentes : l'oubli des deux-points (:) en fin de ligne def, for ou while, et l'utilisation d'une virgule à la place d'un point pour les décimaux.
Les deux algorithmes classiques à maîtriser
L'algorithme de seuil
C'est l'algorithme le plus fréquent au bac. Son but : trouver le premier rang $n$ à partir duquel les termes d'une suite $u_n$ dépassent (ou passent en dessous de) une valeur limite.
La logique centrale est une inversion : si on cherche quand $u_n$ dépasse 20, on écrit while u <= 20:, c'est-à-dire "tant que la condition n'est pas atteinte, continue". Dès que la condition cherchée devient vraie, la boucle s'arrête.
Structure type :
def seuil():
u = u0 # valeur initiale (premier terme)
n = 0 # rang initial
while u <= 20: # condition inverse de ce qu'on cherche
u = f(u) # relation de récurrence
n = n + 1 # on passe au rang suivant
return n # renvoie le premier rang qui dépasse 20Pour compléter ce type de programme à l'examen, il faut identifier trois éléments dans l'énoncé :
- La valeur initiale $u_0$ (initialisation de
u) - La relation de récurrence (ligne
u = f(u)) - Le seuil à atteindre (condition du
while)
Ces trois informations sont toujours données dans le contexte mathématique de l'exercice.
L'algorithme de somme
Moins fréquent que le seuil, mais présent régulièrement dans les exercices de suites. Il s'agit de calculer $S = u_0 + u_1 + \cdots + u_n$.
La logique repose sur une variable d'accumulation. On initialise $S$ à $u_0$, puis on ajoute chaque terme au fur et à mesure.
Structure type :
def calcul_somme(n):
u = u0 # premier terme
S = u0 # on commence la somme avec u0
for i in range(1, n + 1): # on calcule u1 jusqu'à un
u = f(u) # terme suivant
S = S + u # on l'ajoute à la somme
return SPoint de vigilance sur range() : range(1, n+1) fait varier i de 1 à n inclus. Si on écrit range(1, n), le terme $u_n$ est exclu — erreur classique qui fausse le résultat sans message d'erreur.
Les 4 erreurs qui font perdre des points
Erreur 1 : la condition du while à l'envers. Si on cherche le rang $n$ tel que $u_n > 100$, il faut écrire while u <= 100: et non while u > 100:. La boucle exprime la condition de continuation, pas la condition d'arrêt. Lire mentalement "tant que..." avant d'écrire la condition.
Erreur 2 : l'ordre des instructions dans la boucle. Pour un algorithme de seuil, la mise à jour du terme doit précéder l'incrémentation du compteur. Si on inverse les deux lignes, le rang retourné est décalé de 1. Vérifier systématiquement l'ordre en simulant le premier tour.
Erreur 3 : la borne de range(). range(n) exclut n. Pour calculer jusqu'au rang n inclus quand on a déjà initialisé $u_0$, il faut range(1, n+1). Choisir la mauvaise borne décale le calcul sans erreur apparente.
Erreur 4 : l'oubli de n = n + 1 dans la boucle while. Contrairement à la boucle for, la boucle while n'incrémente pas automatiquement de compteur. Si on oublie cette ligne, le programme tourne à l'infini (boucle infinie) et le correcteur ne peut pas exécuter le code.
Méthode de résolution en 4 étapes
Quand une question Python apparaît dans un sujet, la démarche suivante permet de traiter la question en 3 à 5 minutes.
Identifier le type d'algorithme (seuil, somme, calcul de terme) à partir du contexte mathématique et du verbe de la question : "trouver le premier rang", "calculer la valeur", "compléter le programme".
Repérer les valeurs dans l'énoncé : valeur initiale $u_0$, relation de récurrence, seuil ou nombre de termes. Ces informations figurent toujours dans les questions précédentes de l'exercice.
Associer chaque information à sa ligne dans le programme : $u_0$ à l'initialisation de u, la relation au corps de boucle, le seuil à la condition du while.
Vérifier mentalement en simulant les 2 premiers tours de boucle. Si les valeurs obtenues correspondent à ce que la suite doit faire, la réponse est correcte. Cette vérification prend 30 secondes et évite la plupart des erreurs.