Matières › 📐 Mathématiques › Lycée › Algorithmique et programmation (Python)
💻

Algorithmique et programmation (Python)

Variables, boucles, conditions en Python

Explique à quelqu'un comment préparer des pâtes. Tu diras sans doute : « fais bouillir de l'eau, jette les pâtes, attends dix minutes, égoutte ».

Parfait pour un humain. Catastrophique pour une machine.

Combien d'eau ? Dans quoi ? Bouillir, c'est quoi — quelle température, et comment le sait-on ? « Jette les pâtes » : toutes, d'un coup, depuis quelle hauteur ? Et « attends dix minutes » : à partir de quand exactement ?

Chacune de ces questions, ton interlocuteur y répond tout seul, sans même remarquer qu'elle se posait. Une machine, elle, ne comble aucun sous-entendu. Elle fait exactement ce qui est écrit — ni plus, ni moins, ni autrement.

C'est toute la difficulté d'un algorithme : une suite d'instructions si précises qu'aucune interprétation n'est possible. Et c'est aussi sa force, car une instruction non ambiguë peut être répétée un million de fois sans fatigue et sans erreur.

Tu as déjà programmé au collège. Ce que la seconde ajoute, c'est l'écriture en Python, où la moindre imprécision se paie comptant : une indentation de travers, et le programme change de sens ou refuse de démarrer.

Tu verras d'ailleurs très vite un cas où la machine fait scrupuleusement ce que tu as écrit, alors que tu voulais dire autre chose — c'est l'erreur la plus fréquente de tout ce chapitre.

📖 Vocabulaire clé

Algorithme : Suite finie d'instructions non ambiguës qui, à partir de données d'entrée, produit un résultat en un nombre fini d'étapes.
Variable : Espace mémoire nommé qui stocke une valeur. En Python : x = 5\texttt{x = 5} crée la variable xx avec la valeur 55.
Boucle for\texttt{for} : Répète un bloc un nombre fixé de fois. for i in range(n)\texttt{for i in range(n)} exécute le bloc nn fois avec i=0,1,…,n−1i = 0, 1, \ldots, n-1.
Boucle while\texttt{while} : Répète un bloc tant qu'une condition est vraie. Risque de boucle infinie si la condition ne devient jamais fausse.
Division entière //\texttt{//} : a // b\texttt{a // b} donne le quotient entier de la division de aa par bb : le nombre de fois où bb « rentre » dans aa, sans la partie décimale.

Exemple : 10 // 2\texttt{10 // 2} vaut 55, 5 // 2\texttt{5 // 2} vaut 22 (et non 2,52{,}5), 2 // 2\texttt{2 // 2} vaut 11.

📋 Écrire un algorithme en Python

  1. 1 Déclarer les variables et leurs valeurs initiales. Exemple : s = 0\texttt{s = 0} (accumulateur initialisé à zéro pour une somme).
  2. 2 Utiliser for i in range(n)\texttt{for i in range(n)} pour répéter nn fois. Exemple : for i in range(1, 6):\texttt{for i in range(1, 6):} fait varier ii de 11 à 55 inclus.
  3. 3 Utiliser while condition\texttt{while condition} pour répéter tant qu'une condition est vraie. Exemple : while n > 1: n = n // 2\texttt{while n > 1: n = n // 2} remplace nn par le quotient entier de nn par 22 (division entière //\texttt{//}) jusqu'à ce que nn atteigne 11 : pour n=7n = 7, on obtient 7→3→17 \to 3 \to 1.
  4. 4 Tester avec des exemples pour vérifier la correction de l'algorithme. Exemple : Pour un programme de somme 1+…+51+\ldots+5, vérifier que le résultat est bien 1515.

✅ Exemple résolu

Énoncé : Écrire un algorithme Python qui calcule la factorielle de nn (c'est-à-dire n!=1×2×…×nn! = 1 \times 2 \times \ldots \times n). Tester pour n=5n = 5.
Démarche :
  1. Initialiser le résultat : resultat = 1\texttt{resultat = 1}.
  2. Boucle : for i in range(1, n+1):\texttt{for i in range(1, n+1):} puis resultat = resultat * i\texttt{resultat = resultat * i}.
  3. Afficher le résultat à la fin, hors de la boucle (sans indentation) : print(resultat)\texttt{print(resultat)}.
  4. Exécution pour n=5n = 5 : i=1i = 1 → 11, i=2i = 2 → 22, i=3i = 3 → 66, i=4i = 4 → 2424, i=5i = 5 → 120120.
Réponse : 5!=1205! = 120. Le programme affiche 120\texttt{120}.

📐 Formules clés

for i in range(a, b)\texttt{for i in range(a, b)} : ii prend les valeurs a,a+1,…,b−1a, a+1, \ldots, b-1
range(n)\texttt{range(n)} est équivalent à range(0, n)\texttt{range(0, n)}
Indentation obligatoire en Python (4 espaces ou 1 tabulation)
a // b\texttt{a // b} : quotient entier de aa par bb (exemple : 7 // 2\texttt{7 // 2} vaut 33)

🎨 Illustrations

Algorithmique — boucle for
Organigramme de l'exemple du cours : factorielle avec une boucle for

Traduction en organigramme normalisé de l'exemple du cours (resultat = 1\texttt{resultat = 1} puis for i in range(1, n+1): resultat = resultat * i\texttt{for i in range(1, n+1): resultat = resultat * i}), déroulé pour n=5n = 5.

Organigramme de la boucle for pour calculer une factorielle Organigramme vertical : terminal Debut, rectangle d'initialisation resultat egal 1 et i egal 1, puis losange de condition i inferieur ou egal a n. Si oui, deux rectangles d'action a droite : resultat = resultat fois i, puis i = i plus 1, avec une boucle de retour qui ramene vers le cote gauche du losange. Si non, un rectangle affiche le resultat puis le terminal Fin. Exemple : n = 5 -> resultat = 120 (5!) Début resultat = 1 i = 1 i <= n ? Oui resultat = resultat * i i = i + 1 Retour au test (boucle for) Non Afficher resultat Fin
  • 1 En Python, l'incrémentation i = i + 1\texttt{i = i + 1} est gérée automatiquement par range()\texttt{range()} ; l'organigramme la rend explicite pour montrer l'équivalence avec une boucle while\texttt{while}.
  • 2 Pour n=5n = 5, range(1, n+1)\texttt{range(1, n+1)} vaut range(1, 6)\texttt{range(1, 6)} et fournit i=1,2,3,4,5i = 1, 2, 3, 4, 5 (le 66 est exclu, comme rappelé dans le piège du cours).
  • 3 Trace de l'exécution : i=1→resultat=1i=1 \to resultat=1, i=2→2i=2 \to 2, i=3→6i=3 \to 6, i=4→24i=4 \to 24, i=5→120i=5 \to 120, puis i=6i=6 fait sortir de la boucle (i≤ni \le n devient faux) : le programme affiche 120=5!120 = 5!.
Ce qu'il faut lire : Suis la branche « Oui » autour du losange tant que i≤ni \le n est vrai ; dès que ii dépasse nn, la branche « Non » affiche le résultat final.
Organigramme normalisé de l'exemple du cours (calcul de 5!5! avec une boucle for\texttt{for}) : Début → initialisation → test i≤ni \le n → action répétée ou sortie.
Le premier réflexe à corriger
Une liste qui commence à zéro

En Python, range(5)\texttt{range(5)} ne donne pas 1,2,3,4,51, 2, 3, 4, 5. Il donne 0,1,2,3,40, 1, 2, 3, 4.

Le compte y est — cinq valeurs dans les deux cas — mais ce ne sont pas les mêmes. C'est ce décalage d'un cran qui fausse silencieusement un programme sur deux.

Les valeurs produites par range comparees a un comptage de un a cinq Deux rangees de cinq cases de meme taille sont alignees a la meme origine. La rangee du haut contient les valeurs zero, un, deux, trois et quatre : ce sont celles que produit range de cinq en Python. La rangee du bas contient les valeurs un, deux, trois, quatre et cinq : c'est le comptage que l'eleve attend spontanement. Les deux rangees comptent exactement cinq cases, mais la premiere valeur et la derniere valeur different d'une unite. ce que range(5) produit 0 1 2 3 4 ce que l'on attend spontanément 1 2 3 4 5 5 cases 5 cases
  • 1 range(5)\texttt{range(5)} produit 0,1,2,3,40, 1, 2, 3, 4 : il commence à 00 et s'arrête avant 55. La borne supérieure est toujours exclue.
  • 2 Pour obtenir 1,2,3,4,51, 2, 3, 4, 5, il faut écrire range(1, 6)\texttt{range(1, 6)} : on donne le début, et une fin qui dépasse d'un cran la dernière valeur voulue.
  • 3 Le nombre de tours, lui, est le même dans les deux cas. Une boucle range(5)\texttt{range(5)} tourne bien 55 fois — c'est la valeur de la variable qui change, pas le compte.
Ce qu'il faut lire : Quand un programme donne un résultat décalé d'un cran, c'est presque toujours ici que cela se joue.

Pose-toi alors deux questions séparées : « combien de tours ? » et « quelles valeurs prend la variable ? ». Ce sont deux choses différentes, et range\texttt{range} répond honnêtement aux deux — à condition de les avoir distinguées.
range(5)\texttt{range(5)} produit 0,1,2,3,40, 1, 2, 3, 4 : cinq valeurs, mais décalées d'un cran par rapport au comptage habituel.
Dérouler au lieu de deviner
Le tableau de suivi tranche là où l'intuition se trompe

Voici un programme de trois lignes : s = 0\texttt{s = 0}, puis for i in range(4)\texttt{for i in range(4)}, et dans la boucle s = s + i\texttt{s = s + i}.

Beaucoup répondent 1010, en additionnant 1+2+3+41+2+3+4. Le tableau ci-dessous déroule chaque tour et donne 66. Il ne discute pas : il exécute.

Tableau de suivi des variables tour par tour Un tableau de trois colonnes et cinq lignes. La premiere colonne donne la valeur de la variable de boucle a chaque tour : zero, un, deux, puis trois. La deuxieme colonne donne la valeur de la somme avant l'addition : zero, zero, un, puis trois. La troisieme colonne donne la valeur de la somme apres l'addition : zero, un, trois, puis six. La derniere valeur, six, est le resultat final du programme, et il differe de dix que l'on obtiendrait en additionnant un, deux, trois et quatre. tour somme avant somme après 0 0 0 1 0 1 2 1 3 3 3 6 résultat affiché : 6, et non 10
  • 1 La variable de boucle prend les valeurs 0,1,2,30, 1, 2, 3 — celles de range(4)\texttt{range(4)} — et non 1,2,3,41, 2, 3, 4. Le premier tour ajoute donc 00, qui ne change rien.
  • 2 La somme vaut 0+1+2+3=60 + 1 + 2 + 3 = 6. La réponse 1010 correspondrait à 1+2+3+41+2+3+4, c'est-à-dire à range(1, 5)\texttt{range(1, 5)} : un programme différent.
  • 3 Deux colonnes valent mieux qu'une. Séparer la valeur avant et après l'affectation évite de se perdre : s = s + i\texttt{s = s + i} n'est pas une égalité, c'est un remplacement.
Ce qu'il faut lire : Prends l'habitude de ce tableau dès qu'un programme te résiste. Une colonne par variable, une ligne par tour, et tu remplis case par case sans jamais anticiper.

C'est lent, et c'est exactement pour cela que ça marche : l'erreur vient presque toujours d'un tour qu'on a sauté en croyant le connaître.
Déroulé de s = s + i\texttt{s = s + i} sur range(4)\texttt{range(4)} : la somme vaut 66, et non 1010.
Une seule route est prise
Un test choisit, il n'exécute pas les deux branches

Devant un if\texttt{if} suivi d'un else\texttt{else}, beaucoup lisent les deux blocs et additionnent leurs effets.

Or un test est un aiguillage : selon la réponse, une seule voie est empruntée. L'autre reste éteinte, comme si elle n'existait pas.

Un aiguillage ou une seule voie est empruntee Un losange de condition porte la question : la note est-elle superieure ou egale a dix. Deux fleches en sortent. Celle de gauche, tracee en trait plein et marquee oui, mene a une case affichant le mot recu. Celle de droite, tracee en tirets et marquee non, mene a une case affichant les mots a repasser. Pour une note de quatorze, seule la voie de gauche est parcourue ; la case de droite reste inutilisee, ce qu'indique la mention voie non empruntee. note ≥ 10 ? oui non afficher « reçu » afficher « à repasser » voie parcourue voie non empruntée exemple déroulé pour une note de 14
  • 1 Pour une note de 1414, la condition est vraie : la machine exécute le premier bloc, puis saute le second sans le lire.
  • 2 Pour une note de 77, c'est l'inverse exact. Le programme n'affiche jamais les deux messages : il en affiche toujours un, et un seul.
  • 3 C'est ce qui distingue else\texttt{else} de deux if\texttt{if} écrits à la suite. Deux if\texttt{if} indépendants sont évalués chacun de leur côté, et peuvent très bien s'exécuter tous les deux.
Ce qu'il faut lire : Quand tu lis un programme, ne lis jamais un if\texttt{if} comme une liste d'instructions. Lis-le comme une question posée à la machine, dont la réponse décide de la suite.

Et pour vérifier, choisis une valeur précise — ici 1414 — puis suis une seule route du doigt. Tu verras immédiatement quelle case est atteinte, et laquelle ne l'est pas.
Un test oriente vers une seule branche : pour une note de 1414, seule la voie « reçu » est parcourue.

❌ Une erreur, une suggestion

❌ L'erreur fréquente

En Python, range(1,6)\texttt{range(1,6)} produit 1,2,3,4,51,2,3,4,5 (pas 66).

✅ La suggestion

La borne supérieure est exclue !

💡 À retenir

  • range(a, b)\texttt{range(a, b)} produit les entiers de aa à b−1b-1 : la borne supérieure est toujours exclue.
  • La boucle for\texttt{for} est utilisée quand le nombre de répétitions est connu à l'avance ; while\texttt{while} sinon.
  • L'indentation est obligatoire en Python : elle délimite les blocs de code (pas d'accolades).
  • Pour déboguer, exécuter le code à la main pas à pas avec des valeurs test.
← Échantillonnage et estimation 14 / 36 → La Dérivation