Programme en vigueur — arrêté du 26 février 2026, applicable en Seconde depuis la rentrée 2026. Voir le texte
Variables, conditionnelles, boucles (for/while), fonctions. Algorithmes : somme, maximum, Euclide, test de primalité.
La règle d'or
Un algorithme qui ne marche pas est rarement un problème de langage : c'est un raisonnement incomplet, que le programme se contente de dire tout haut.
L'erreur que tout le monde fait
Écrire une boucle « while » dont la condition ne peut jamais devenir fausse.
Le programme tourne indéfiniment. Rien ne s'affiche, rien ne plante : la machine attend une fin qui ne viendra pas. C'est la seule erreur du chapitre qui ne produise aucun message, et donc la plus longue à diagnostiquer.
Se demander, avant d'écrire le corps de la boucle, quelle ligne à l'intérieur rapproche de la sortie. Si la réponse n'est pas immédiate, la boucle est infinie.
Programmer, en mathématiques, ne sert pas à faire de l'informatique : cela sert à écrire un raisonnement de façon si précise qu'une machine puisse l'exécuter. Un algorithme qui ne marche pas n'est presque jamais un problème de langage — c'est un raisonnement incomplet, et le programme se contente de le dire tout haut.
1Les briques du langage
Définition
variable et affectation — Une variable est un nom qui désigne une valeur. L'affectation `n = 5` ne signifie pas « n égale 5 » mais « range 5 dans la case appelée n ». La différence apparaît dès qu'on écrit `n = n + 1` : mathématiquement absurde, cette ligne est parfaitement claire en programmation — elle remplace le contenu de n par ce contenu augmenté de 1.
Deux points, puis un bloc indenté : l'indentation fait le programme.
En Python, l'indentation n'est pas une commodité de lecture : c'est la syntaxe elle-même. Ce qui est décalé sous un `if` s'exécute quand la condition est vraie ; ce qui revient à gauche s'exécute dans tous les cas. Un décalage mal placé change le programme sans provoquer d'erreur, ce qui en fait la faute la plus difficile à trouver.
Piège
Écrire `if n = 3:` au lieu de `if n == 3:`.
Pourquoi — un seul signe égal affecte une valeur ; le double signe compare. Python refuse la première forme dans un test, et signale une erreur de syntaxe — ce qui, ici, est une chance : dans d'autres langages, le programme s'exécuterait en donnant un résultat faux.
Le réflexe — un `=` range, un `==` demande. Dans un `if`, on demande toujours.
2Les deux boucles
Règle
La boucle `for` répète un nombre de fois connu à l'avance : `for i in range(1, 11)` fait prendre à `i` les valeurs 1 à 10 — la borne de droite est exclue, et c'est l'erreur d'un débutant sur deux. La boucle `while` répète tant qu'une condition reste vraie : le nombre de tours n'est pas connu, et il faut garantir que la condition finira par devenir fausse.
Nombre de tours connu : for. Condition d'arrêt : while.
Piège
Écrire une boucle `while` dont la condition ne peut jamais devenir fausse.
Pourquoi — le programme tourne indéfiniment. Rien ne s'affiche, rien ne plante : la machine attend une fin qui ne viendra pas. C'est la seule erreur qui ne produit aucun message.
Le réflexe — avant d'écrire le corps de la boucle, se demander : quelle ligne, à l'intérieur, rapproche de la sortie ? Si la réponse n'est pas immédiate, la boucle est infinie.
3Les fonctions
Définition
fonction et return — Une fonction regroupe un traitement sous un nom, avec des paramètres en entrée. L'instruction `return` renvoie une valeur à celui qui a appelé la fonction, et interrompt son exécution. Elle ne doit pas être confondue avec `print`, qui affiche sans rien renvoyer : une fonction qui affiche mais ne renvoie rien ne peut pas être réutilisée dans un calcul.
Une fonction renvoie ; elle n'affiche pas.
4Quatre algorithmes à connaître
Chercher un maximum
Initialiser avec le premier élément de la liste, jamais avec 0 : une liste de nombres négatifs donnerait un maximum faux.
Parcourir tous les éléments, y compris le premier — le comparer à lui-même ne coûte rien et simplifie l'écriture.
Remplacer la valeur retenue chaque fois qu'on rencontre plus grand.à la fin du parcours, la variable contient nécessairement le plus grand élément rencontré.
Exemple
L'algorithme d'Euclide calcule le PGCD de deux entiers. Le suivre à la main sur 48 et 18.
Le principe : on remplace le plus grand par le reste de sa division par le plus petit, et on recommence jusqu'à ce que le reste soit nul.
Premier tour : reste de 48 par 18.48−2×18=12
Deuxième tour : reste de 18 par 12.18−12=6
Troisième tour : reste de 12 par 6.12−2×6=0
Le reste est nul : le PGCD est le dernier diviseur employé, soit 6.en Python, la boucle s'écrit `while b != 0 :` puis `a, b = b, a % b`, et l'on renvoie `a`.
PGCD(48 ; 18) = 6, en trois tours de boucle
Le test de primalité illustre le seul souci d'efficacité du programme de seconde. Tester tous les diviseurs de 2 à n−1 fonctionne, mais devient très lent pour un grand n. Or si n a un diviseur supérieur à n, il en a nécessairement un inférieur : il suffit donc de tester jusqu'à n. Pour n=106, on passe d'un million de tests à mille.
Le test `d * d <= n` évite d'appeler une racine carrée : plus rapide, et exact.
Deux détails de ce programme méritent d'être remarqués. Le `return False` à l'intérieur de la boucle est ici volontaire : dès qu'un diviseur est trouvé, il n'y a plus rien à chercher, et sortir immédiatement fait gagner tout le reste du parcours. Et la condition s'écrit `d * d <= n` plutôt que `d <= sqrt(n)` : on compare deux entiers au lieu d'un entier et d'un décimal approché, ce qui supprime tout risque d'arrondi.
Piège
Écrire `return True` à l'intérieur de la boucle, symétriquement au `return False`.
Pourquoi — la fonction renverrait `True` dès le premier diviseur qui ne convient pas — c'est-à-dire dès d=2 pour tout nombre impair. Elle déclarerait 9 premier.
Le réflexe — on ne peut conclure « premier » qu'après avoir tout testé : le `return True` va donc à l'extérieur de la boucle, aligné avec le `while`.
▢`=` range une valeur, `==` compare : ai-je le bon signe dans mon test ?
▢L'indentation correspond-elle exactement à ce que je veux répéter ?
▢`range(1, 11)` s'arrête à 10 : ai-je vérifié mes bornes ?
▢Dans un `while` : quelle ligne rapproche de la sortie ?
▢Ma fonction renvoie-t-elle avec `return`, ou se contente-t-elle d'afficher ?
▢Ai-je testé mon programme sur un cas dont je connais la réponse ?
L'essentiel en 8 points
·`=` range une valeur · `==` compare. Dans un `if`, toujours `==`.
·L'indentation est la syntaxe : elle décide de ce qui se répète.
·`range(a, b)` s'arrête à b−1 · le nombre de tours vaut b−a.
·`for` : nombre de tours connu · `while` : condition d'arrêt.
·Dans un `while`, une ligne doit rapprocher de la sortie.
·`return` renvoie et interrompt · `print` affiche et ne renvoie rien.
·Un maximum s'initialise avec le premier élément, jamais avec 0.
·Primalité : tester jusqu'à n suffit.
2
Imprimer
Fiche PDF — Algorithmique et programmation Python
Gratuit · sans compte
Trois documents à imprimer, 7 pages en tout : le cours, les exercices avec la place pour écrire, et le corrigé détaillé avec son barème.
a.`a = 3` puis `b = a + 2` puis `a = 10`. Que valent `a` et `b` à la fin ?
b.`n = 7` puis `n = n * 2` puis `n = n - 4`. Que vaut `n` ?
c.Combien de fois s'exécute le corps de `for i in range(3, 9)` ?
›Voir le corrigéMasquer le corrigé
a. `a` vaut 10 et `b` vaut 5. La valeur de `b` a été calculée avec l'ancien `a` : elle ne se met pas à jour toute seule.
C'est la conséquence directe de l'affectation : `b` a reçu un nombre, pas une formule.
b. Les deux étapes.7×2=14
Puis.14−4=10`n` vaut 10.
c. Six fois : `i` prend 3, 4, 5, 6, 7 et 8. La borne 9 est exclue.
Le nombre de tours vaut toujours la différence des bornes : 9−3=6.
2
Corriger un programme
Analyser
a.`if x = 5:` — quelle erreur ?
b.Une fonction se termine par `print(m)` mais son résultat, réutilisé plus loin, vaut `None`. Pourquoi ?
c.`n = 10` puis `while n > 0:` puis `print(n)`. Que se passe-t-il ?
›Voir le corrigéMasquer le corrigé
a. Un seul `=` affecte au lieu de comparer. Il faut écrire `if x == 5:`.
b. Parce que `print` affiche mais ne renvoie rien. Il faut écrire `return m` pour que la valeur soit utilisable dans un calcul.
C'est la distinction la plus importante du chapitre : afficher est pour l'humain, renvoyer est pour le programme.
c. Boucle infinie : rien à l'intérieur ne diminue `n`, donc la condition `n > 0` reste vraie indéfiniment.
Le programme affiche 10 sans discontinuer, sans jamais s'arrêter ni signaler d'erreur.
Il manque une ligne indentée, par exemple `n = n - 1`, qui rapproche de la sortie.
3
Écrire une boucle for
Écrire
a.Écrire un programme qui calcule la somme des entiers de 1 à 100.
b.Le modifier pour ne sommer que les nombres pairs.
c.Vérifier le premier résultat par une formule.
›Voir le corrigéMasquer le corrigé
a. `total = 0`, puis `for i in range(1, 101):` et, indenté, `total = total + i`. On affiche `total` à la fin.
La borne 101 est nécessaire pour que 100 soit inclus.
b. Deux solutions. Soit `for i in range(2, 101, 2):` — le troisième argument est le pas.
Soit garder la boucle et ajouter `if i % 2 == 0:` avant l'addition, `%` donnant le reste de la division.
c. La somme des n premiers entiers vaut 2n(n+1).2100×101=5050
Le programme doit afficher 5050 : c'est le contrôle qu'il faut toujours prévoir avant de lancer.
4
Une fonction avec return
Écrire
a.Écrire une fonction `est_pair(n)` qui renvoie `True` si `n` est pair.
b.Écrire une fonction `compte_pairs(liste)` qui renvoie le nombre d'éléments pairs, en réutilisant la première.
›Voir le corrigéMasquer le corrigé
a. `def est_pair(n):` puis, indenté, `return n % 2 == 0`.
L'expression `n % 2 == 0` vaut déjà `True` ou `False` : il est inutile d'écrire un `if` pour renvoyer l'un ou l'autre.
b. `def compte_pairs(liste):`, puis `c = 0`, puis `for x in liste:`, puis `if est_pair(x):` et `c = c + 1`.
On termine par `return c`, aligné avec le `for` — donc exécuté après la boucle, et non à chaque tour.
Placer le `return` à l'intérieur de la boucle est l'erreur classique : la fonction s'arrêterait au premier élément.
C'est là que l'indentation devient un raisonnement : sa position décide de ce que fait le programme.
5
Algorithme d'Euclide
Raisonner
a.Dérouler l'algorithme sur 91 et 35.
b.Combien de tours de boucle ?
c.Que se passe-t-il si on l'applique à 17 et 5 ?
›Voir le corrigéMasquer le corrigé
a. Reste de 91 par 35.91−2×35=21
Reste de 35 par 21.35−21=14
Reste de 21 par 14.21−14=7
Reste de 14 par 7 : il vaut 0. Le PGCD est 7.14−2×7=0
b. Quatre tours.
c. On obtient successivement les restes 2, 1, puis 0 : le PGCD vaut 1.
Un PGCD égal à 1 signifie que les deux nombres sont premiers entre eux — ils n'ont aucun diviseur commun autre que 1.
6
Test de primalité
Raisonner
a.Pour tester si 97 est premier, jusqu'à quel diviseur faut-il aller si l'on s'arrête à n ?
b.Justifier qu'il est inutile d'aller au-delà.
c.Combien de tests économise-t-on par rapport à un parcours jusqu'à 96 ?
›Voir le corrigéMasquer le corrigé
a. La racine de 97.97≈9,85
Il suffit donc de tester les diviseurs de 2 à 9.
b. Si n=a×b avec a>n, alors nécessairement b<n — sans quoi le produit dépasserait n.
Autrement dit, tout diviseur supérieur à la racine a un complice inférieur, déjà testé. Chercher au-delà, c'est retrouver les mêmes couples dans l'autre sens.
c. On teste 8 diviseurs au lieu de 95.95−8=87
Quatre-vingt-sept tests économisés sur un petit nombre ; l'écart devient décisif sur de grands entiers.
97 n'étant divisible par aucun de 2 à 9, il est premier.
Ce qui rapporte des points, ce qui en coûte
Distinguer affectation et comparaison2 ptsPerdu si : `if x = 5:`
Indenter conformément au raisonnement voulu4 ptsPerdu si : Un `return` placé dans la boucle
Maîtriser les bornes de `range`3 ptsPerdu si : Oublier la dernière valeur
Garantir la terminaison d'une boucle `while`3 ptsPerdu si : Une boucle infinie
Employer `return` pour rendre une fonction réutilisable3 ptsPerdu si : Une fonction qui affiche et renvoie `None`
Prévoir un cas de test dont on connaît la réponse2 ptsPerdu si : Lancer un programme sans savoir ce qu'il doit donner
4
La méthode
Écrire une boucle qui se termine
1
Choisir la boucle d'après ce que l'on sait : « for » si le nombre de tours est connu, « while » sinon.
2
Écrire la condition d'arrêt avant le corps de la boucle.
3
Vérifier qu'une ligne du corps rapproche de la sortie à chaque tour.
4
Contrôler les bornes, la borne de droite de « range » étant exclue.
5
Placer le résultat renvoyé hors de la boucle lorsqu'il faut tout avoir testé pour conclure.
5
Se tester
Touches 1 à 4
MathématiquesSeconde
Question 1
Le code suivant est censé vérifier si une liste L est triée par ordre croissant :
```python
L = [1, 3, 2, 4]
est_trie = True
for i in range(1, len(L)):
if L[i] < L[i - 1]:
est_trie = False
print(est_trie)
```
Quelle affirmation est VRAIE concernant ce programme ?
Aucun compte requis — réponds, la correction s'affiche aussitôt.
Algorithmique et programmation Python : c'est en quelle classe ?+
Ce chapitre est au programme de Mathématiques au lycée, en classe de Seconde. Il est défini par le Bulletin Officiel de l'Éducation nationale, le texte de référence qui fixe ce qui doit être enseigné dans chaque matière.
Que faut-il savoir sur Algorithmique et programmation Python ?+
Variables, conditionnelles, boucles (for/while), fonctions. Algorithmes : somme, maximum, Euclide, test de primalité. Les notions à maîtriser sont : variable, boucle for, boucle while, fonction, return, Python.
Où télécharger la fiche PDF de Algorithmique et programmation Python ?+
Sur cette page, dans le bloc « Imprimer » : 3 documents à télécharger — le cours, les exercices et le corrigé — soit 7 pages au format A4, prêtes à imprimer. Le téléchargement est gratuit, immédiat, et ne demande ni compte ni adresse e-mail.
Le corrigé de Algorithmique et programmation Python est-il fourni ?+
Oui, et c'est un document à part : chaque exercice y est repris étape par étape, avec le barème détaillé en fin de fiche — ce qui est attendu, combien de points, et ce qui fait perdre le point. Un parent qui ne se souvient plus du programme peut corriger une copie avec.
Comment réviser Algorithmique et programmation Python efficacement ?+
Commence par lire la fiche de révision pour remettre la règle en place, puis enchaîne immédiatement sur le quiz de cette page. Répondre juste après avoir lu ne suffit pas : reviens sur le chapitre deux ou trois jours plus tard. C'est l'espacement des révisions, plus que leur durée, qui fait tenir une notion en mémoire. Une session de quinze minutes répétée vaut mieux qu'une heure unique.
Faut-il un compte pour s'entraîner sur Algorithmique et programmation Python ?+
Non. Les quiz, les corrections détaillées et les fiches de révision sont accessibles sans créer de compte et sans donner d'adresse e-mail. Le compte gratuit sert uniquement à conserver la progression d'un appareil à l'autre.
Notions voisines
Les chapitres qui traitent des mêmes notions, ici ou dans une autre année.