Les boucles : pour, tant que, faire
Ce que ce chapitre apporte 4 points
- Reconnaître dans un énoncé une action qui se répète, et compter les tours d'une boucle.
- Choisir entre For, While et Do selon ce que l'on sait du nombre de tours, et passer d'un Répéter … Jusqu'à à un Do.
- Écrire un compteur, un accumulateur, une recherche de maximum et de minimum, initialisés au bon endroit.
- Garantir qu'une boucle While ou Do s'arrête, en identifiant la variable qui fait changer la condition.
Relever douze consommations mensuelles, surveiller une cuve minute par minute, redemander une saisie tant qu'elle est incorrecte : ces traitements répètent la même action, un nombre de fois connu ou non. Flowgorithm propose trois formes pour répéter : For, While et Do. Ce sont les boucles Pour, TantQue et Répéter … Jusqu'à du pseudo-code, avec une différence qui piège : le Do continue tant que sa condition est vraie, là où Jusqu'à s'arrête dès qu'elle l'est. Ce chapitre apprend à choisir la bonne, à écrire les motifs qui reviennent dans presque tous les programmes (compteur, accumulateur, maximum, minimum) et à garantir que chaque boucle s'arrête.
Pourquoi répéter plutôt que recopier
Une balance de contrôle pèse cinq sacs de granulés, et le programme doit afficher la masse totale. Sans boucle, il faut dessiner cinq fois la même paire de formes (lire une masse, l'ajouter au total), soit dix formes. Pour cinquante sacs, il en faudrait cent, et une paire oubliée fausserait le total sans rien signaler. La boucle dessine la paire une seule fois et la fait exécuter autant de fois que nécessaire.
La pesée de cinq sacs. Les deux formes du corps s'exécutent cinq fois ; changer le nombre de sacs ne demande de modifier que la borne 5.
Une boucle répète un groupe de formes, appelé le corps de la boucle. Un tour est une exécution complète du corps.
Le programme affiche Masse totale : 62.8 kg. En pas à pas, la forme surlignée revient cinq fois sur la lecture, et la fenêtre des variables montre somme qui grossit à chaque tour pendant que tour passe de 1 à 5. L'hexagone, lui, est surligné six fois : la sixième fois, tour vaut 6 et dépasse la borne de fin, et la boucle s'arrête sans exécuter le corps.
La boucle For : un nombre de tours connu
La boucle For fait varier une variable sur un intervalle, bornes comprises. For mois = 1 to 12 exécute le corps pour mois valant 1, puis 2, et ainsi de suite jusqu'à 12. La variable de boucle se déclare comme toute variable, en Integer.
La fenêtre de la forme For propose aussi un sens (croissant ou décroissant) et un pas, qui valent par défaut « croissant » et 1. Le Pour i de 10 à 1 pas -1 du pseudo-code s'obtient en choisissant le sens décroissant, avec un pas de 1. Les boucles de ce chapitre gardent les valeurs par défaut, et les organigrammes de la page ne connaissent qu'elles.
Un bureau d'études relève la consommation électrique d'un atelier mois par mois et veut le cumul sur l'année.
Douze tours, un par mois. Le corps lit la variable mois pour annoncer le mois à saisir.
Le programme affiche douze demandes, puis Consommation annuelle : 10490 kWh. La variable de boucle n'est pas qu'un compteur interne : le corps peut s'en servir, ici pour numéroter les demandes.
Compter les tours d'une boucle For. Avec le pas de 1, une boucle For de a à b exécute son corps b − a + 1 fois, puisque les deux bornes sont comprises. For mois = 1 to 12 fait 12 tours ; For i = 5 to 8 en fait 4.
Combien de tours fait la boucle For i = 1 to 5 ?
Compteur et accumulateur
Un compteur est une variable entière qui augmente de 1 chaque fois qu'un événement se produit : lourds = lourds + 1. Un accumulateur reçoit à chaque tour une valeur ajoutée à ce qu'il contient déjà : total = total + masse. Le = de la forme d'affectation se lit « reçoit », comme le ← du pseudo-code.
Les deux suivent la même règle en trois temps : initialiser avant la boucle, mettre à jour dans la boucle, exploiter après. Une plateforme logistique pèse six colis, cumule leur masse et compte ceux qui dépassent 20 kg.
Un accumulateur et un compteur dans la même boucle : initialisations avant, mises à jour dedans, affichages après. Exécuter et vérifier le compte des colis lourds, puis remplacer une masse par 20 exactement : elle ne compte pas, parce que le test est strict.
Le programme affiche Masse du lot : 123.5 kg et Colis de plus de 20 kg : 3. En pas à pas, l'accumulateur change à chaque tour, le compteur seulement quand la condition est vraie : lourds = lourds + 1 s'exécute 3 fois sur les 6 tours.
Si total = 0 est déplacée dans le corps, juste avant la lecture, l'accumulateur repart de zéro à chaque tour. Sur les mêmes saisies, le programme affiche Masse du lot : 16.3 kg, la masse du seul sixième colis. Aucune erreur n'est signalée : le programme tourne, il calcule faux. Un total égal à la dernière valeur lue désigne presque toujours une initialisation dans la boucle.
Une seule forme déplacée d'un cran vers l'intérieur. Exécuter avec les six mêmes masses : le compteur reste juste, le total ne l'est plus. En pas à pas, total retombe à 0 à chaque tour.
Un accumulateur qui multiplie
Une chaîne de conversion d'énergie enchaîne plusieurs étages (transformateur, redresseur, onduleur, moteur), chacun avec son rendement compris entre 0 et 1. Le rendement global est le produit des rendements : l'accumulateur multiplie au lieu d'additionner.
Le nombre d'étages est saisi d'abord, puis sert de borne de fin. L'accumulateur multiplicatif commence à 1.
Pour quatre étages de rendements 0,98, 0,95, 0,96 et 0,90, le programme affiche Rendement global : 80.4 %. La borne de fin n'est pas forcément une constante : n, lu avant la boucle, rend le programme valable pour n'importe quel nombre d'étages. Une somme commence à 0, parce qu'ajouter 0 ne change rien ; un produit commence à 1, parce que multiplier par 1 ne change rien. Initialisé à 0, rendement resterait à 0 quelles que soient les saisies.
1.Où placer somme = 0 dans un programme qui additionne des mesures lues par une boucle ?
2.Un accumulateur calcule un rendement global comme produit de rendements. Quelle valeur initiale lui donner ?
Maximum et minimum
Une chambre froide enregistre six températures ; le programme retient la plus haute, son rang, et la plus basse. Le principe : garder la meilleure valeur rencontrée jusque-là, et la remplacer quand une nouvelle mesure la dépasse.
Tout se joue sur la valeur de départ. Initialiser maxi à 0 semble naturel, mais toutes les températures de la chambre froide sont négatives : aucune ne dépasse 0, et le programme affiche Plus haute : 0.0 °C, une température jamais mesurée. Une valeur « très basse », comme -1000, suppose de connaître d'avance l'étendue des mesures, et si elle n'est jamais dépassée, le résultat affiché n'est pas une valeur mesurée. La première valeur lue ne suppose rien : l'initialisation sûre est la première valeur lue : elle est à la fois le maximum et le minimum des mesures vues jusque-là.
La première mesure, lue avant la boucle, initialise les deux extrêmes. La boucle commence donc au relevé 2. Exécuter et noter le rang du maximum, puis porter la première mesure à -15 : c'est elle qui devient le maximum, et le rang tombe à 1.
Le programme affiche Plus haute : -16.8 °C, relevé 4 et Plus basse : -19.2 °C. La première lecture étant avant la boucle, celle-ci commence au relevé 2 : les six mesures sont lues, aucune deux fois. Le rang se retient dans la même branche que la valeur. Les relevés 4 et 6 valent tous deux -16,8 : la comparaison stricte > ne remplace pas en cas d'égalité et garde le premier rang ; avec >=, le programme afficherait le relevé 6. Flowgorithm ne fournit aucune fonction de maximum ni de minimum : ce motif est la façon de les obtenir.
La boucle While : répéter tant qu'une condition est vraie
Quand le nombre de tours n'est pas connu d'avance, la boucle While répète son corps tant que sa condition est vraie. Elle teste avant chaque tour : si la condition est fausse dès le départ, le corps ne s'exécute jamais.
Ce qui arrête un While. La condition d'un While porte sur une variable modifiée dans le corps. Si rien dans le corps ne peut rendre la condition fausse, la boucle ne s'arrête jamais.
Un opérateur saisit la pression de consigne d'un circuit, qui doit être strictement positive. Tant que la saisie est incorrecte, le programme la redemande.
Une lecture avant la boucle, pour que la condition ait une valeur à tester ; une lecture dans la boucle, pour qu'elle puisse changer.
Avec les saisies -2, 0 puis 3.5, le message s'affiche deux fois et le programme retient 3.5 bar. La valeur 0 est refusée : pression <= 0 traduit « pas strictement positive ». Le déroulé tient en trois tests :
| Test | pression | pression <= 0 | Ce qui suit |
|---|---|---|---|
| 1 | -2 | vrai | message, lecture de 0 |
| 2 | 0 | vrai | message, lecture de 3.5 |
| 3 | 3.5 | faux | sortie de la boucle |
Trois tests, deux tours : un While teste toujours une fois de plus qu'il ne tourne, et c'est ce dernier test, faux, qui le fait sortir. En pas à pas, le losange de la boucle est surligné trois fois. Exécuter à nouveau avec une première saisie correcte, 3.5 : un seul test, faux, et le corps ne s'exécute pas du tout.
Le While sert aussi à simuler. Un liquide sort d'un échangeur à 90 °C et perd 10 % de sa température à chaque minute. Combien de minutes pour passer sous 20 °C ? Le nombre de tours est justement l'inconnue : un While, avec un compteur de minutes.
Perdre 10 % revient à multiplier par 0.9. La condition porte sur temperature, que le corps modifie à chaque tour.
Le programme affiche Sous 20 °C après 15 minutes, puis Température : 18.5 °C. La condition temperature >= 20 fait continuer la boucle tant que le liquide n'est pas encore sous 20 °C. Avec une température saisie de 15, le compteur reste à 0 : le test précède le corps.
Il suffit d'oublier la mise à jour de temperature pour que la condition reste vraie pour toujours. Le contre-exemple ci-dessous peut être exécuté : sur cette page, l'exécution s'interrompt au-delà de 20 000 formes exécutées, avec un message qui signale une boucle qui ne s'arrête sans doute jamais. minutes vaut alors 9997, et l'affichage final n'a jamais lieu. Avant d'écrire un While, une question : quelle variable de la condition le corps modifie-t-il, et dans quel sens ?
Contre-exemple. Le corps ne modifie que minutes ; temperature reste à 90 et la condition reste vraie.
Une boucle While a pour condition niveau < 90, et son corps ne contient que compteur = compteur + 1. Le niveau de départ vaut 40. Que se passe-t-il ?
La boucle Do : au moins une fois
Un While peut n'exécuter son corps aucune fois ; certaines tâches réclament l'inverse. La boucle Do exécute son corps, puis teste sa condition, et recommence tant qu'elle est vraie. Le corps s'exécute donc toujours au moins une fois. C'est la boucle naturelle d'un menu : afficher les choix et lire la commande avant de savoir s'il faut continuer.
Avec les commandes 1, 2, 5 puis 0, le menu s'affiche quatre fois ; la commande 5 ne déclenche aucun message, et 0 termine la session. Aucune lecture n'est nécessaire avant la boucle.
Le même menu s'écrit avec un While précédé d'une lecture : une première commande lue avant la boucle, la suivante à la fin du corps, comme pour la pression. Le Do évite de dessiner deux fois la lecture. Le While précédé d'une lecture a un autre avantage : il se transpose tel quel en Python, qui n'a pas de boucle Do. Il suffit d'une ligne commande = int(input("1 marche, 2 arrêt, 0 quitter : ")), qui affiche le menu et lit la commande, avant while commande != 0:, puis de la même ligne à la fin du corps indenté.
Le parcours d'algorithmique écrit Répéter … Jusqu'à quantite > 0 : la boucle s'arrête quand sa condition devient vraie. Le Do de Flowgorithm fait l'inverse : il continue tant que sa condition est vraie. Les deux boucles testent après le corps, mais leurs conditions sont contraires. Passer de l'une à l'autre demande de nier la condition : Jusqu'à quantite > 0 devient un Do de condition quantite <= 0. Recopier la condition telle quelle donne une boucle qui s'arrête sur une mauvaise saisie et redemande une bonne.
Le Répéter … Jusqu'à quantite > 0 du pseudo-code, traduit en Do : la condition est niée, quantite <= 0. Avec -3, 0 puis 8, la demande s'affiche trois fois, et la commande retenue est de 8 pièces.
1.Quelle différence entre While et Do ?
2.Le pseudo-code écrit Répéter Lire n Jusqu'à n >= 0. Quelle condition donner au Do qui fait la même chose dans Flowgorithm ?
Choisir sa boucle
| Ce que l'on sait avant la boucle | Boucle | Exemple |
|---|---|---|
| Le nombre de tours (constante ou variable lue avant) | For | douze mois, n étages |
| Une condition d'arrêt, et zéro tour est possible | While | refroidir jusqu'à 20 °C, saisie refusée avec un message |
| Une condition d'arrêt, et le corps doit s'exécuter avant qu'elle ait un sens | Do | menu, saisie redemandée avec la même question |
Le tableau se ramène à deux questions, posées dans cet ordre.
- Le nombre de tours est-il calculable avant d'entrer dans la boucle ? S'il tient dans une constante ou dans une variable déjà lue, c'est un For, et le choix est fait.
- Le corps doit-il s'exécuter pour que la condition ait un sens ? Si la variable testée ne reçoit sa valeur que dans le corps, et que rien d'autre ne se fait avant le premier test, c'est un Do. Sinon, c'est un While.
Une saisie à contrôler admet les deux boucles, et c'est le dessin qui tranche. Si la question est la même au premier essai et aux suivants, le Do la dessine une seule fois, dans son corps : c'est la vanne de l'exercice type, plus bas. Si un message d'erreur ne doit s'afficher qu'après une saisie refusée, le While précédé d'une lecture le permet : la première lecture avant la boucle, le message et la relecture dans le corps. C'est la pression, et c'est aussi la forme qui passe telle quelle en Python. L'écart se constate à l'exécution : le While lancé avec 3.5 en première saisie n'exécute pas le corps une seule fois ; le Do lancé avec 0 en première commande affiche quand même le menu, puis s'arrête.
Les bornes d'un For sont comprises. For mois = 0 to 12 fait 13 tours, un de trop pour une année. La vérification tient en une soustraction : fin − début + 1. Une boucle dont les bornes sont 0 et n - 1 fait exactement n tours, toujours avec le pas de 1 : c'est l'écriture qui servira à parcourir un tableau, dont les indices commencent à 0.
En Python, le piège change de forme. For i = 1 to 10 s'écrit for i in range(1, 11), car la borne de fin de range est exclue, d'où le 11. Les dix tours sont les mêmes ; seule l'écriture de la borne change.
Combien de tours fait une boucle For dont les bornes sont 0 et n - 1 ?
Fil rouge : la cuve de traitement
Étape 4. La cuve cylindrique (rayon 1,5 m, hauteur 4 m, seuil haut 90 %) reçoit deux traitements répétitifs.
Simuler un remplissage. La pompe ajoute un volume constant chaque minute. Tant que le taux reste sous le seuil haut, le programme ajoute le débit et compte une minute. Le nombre de minutes est inconnu : c'est un While.
Volume actuel et débit en litres. Le taux est recalculé dans le corps, juste après le volume : c'est ce qui permet à la condition de devenir fausse. Exécuter avec 5000 litres et un débit de 1200, puis essayer un débit de 100 : la boucle tourne plus de onze fois plus longtemps, 205 minutes au lieu de 18.
Pour 5000 L au départ et 1200 L par minute, le programme affiche Seuil haut atteint après 18 minutes et Taux final : 94.1 %. Le taux final dépasse 90 % : la simulation avance par minutes entières, et la dernière fait franchir le seuil. Avec 26000 L au départ, le taux dépasse déjà le seuil : le corps ne s'exécute pas et le compteur reste à 0.
Relever le niveau heure par heure. Sur une durée connue, un technicien saisit le taux relevé à chaque heure. Le programme accumule les taux pour la moyenne et compte les heures au-dessus du seuil haut. La durée est lue avant la boucle : c'est un For.
Un accumulateur et un compteur, initialisés avant la boucle. La moyenne se calcule après, une seule fois. Exécuter avec les six taux proposés, puis porter le premier à 95 : la moyenne monte de près de quatre points, et les heures hautes passent de deux à trois.
Sur six heures, le programme affiche Taux moyen : 85.3 % et Heures au-dessus du seuil haut : 2. Au chapitre suivant, des relevés de ce genre seront rangés dans un tableau, pour retrouver aussi le pic et l'heure du pic.
Mettre en pratique
Un capteur de vibration fournit n mesures, n étant saisi d'abord. Adapter la recherche du maximum de la chambre froide pour afficher la vibration maximale et son rang, puis donner l'affichage pour les saisies 4, 2.1, 3.4, 3.4, 1.8.
Trois changements. La première lecture est celle de n. La première mesure est lue ensuite, avant la boucle : elle initialise maxi, et rangMaxi reçoit 1. La boucle va de 2 à n et fait donc n - 1 tours, un par mesure restante. Le minimum et sa condition disparaissent.
La correction. Saisir 4, puis 2.1, 3.4, 3.4 et 1.8. Prévoir ensuite l'effet de >= à la place de >, puis le vérifier dans Flowgorithm : le rang affiché passe de 2 à 3, sans que le maximum change.
Pour 4 mesures valant 2.1, 3.4, 3.4 et 1.8, le programme affiche Vibration maximale : 3.4 mm/s, mesure 2. La mesure 3 vaut aussi 3,4, mais la comparaison stricte ne la retient pas. Le cas des valeurs égales se décide avant de dessiner : premier rang avec >, dernier avec >=.
L'ouverture d'une vanne se saisit en pourcentage et doit rester entre 0 et 100. Choisir la boucle qui redemande la saisie tant qu'elle est hors limites, et dire combien de lectures ont lieu pour 120, -5 puis 45.
La même demande vaut pour le premier essai et pour les suivants, et la condition n'a de sens qu'après une lecture : c'est une boucle Do, dont le corps contient la demande et la lecture de ouverture, dessinées une seule fois. Sa condition décrit une saisie incorrecte, puisque la boucle recommence tant qu'elle est vraie : ouverture < 0 or ouverture > 100. Après la boucle, une sortie affiche la valeur retenue.
La correction. Exécuter avec 120, -5 puis 45 : la demande s'affiche trois fois, et la valeur retenue est 45. Relancer avec 45 seul : la demande s'affiche encore une fois, le corps s'exécutant avant tout test.
La lecture a lieu 3 fois et le programme retient 45 %. L'erreur fréquente consiste à écrire la condition d'une saisie correcte, ouverture >= 0 and ouverture <= 100, comme dans un Jusqu'à : la boucle recommencerait alors sur une bonne saisie et s'arrêterait sur une mauvaise.
La pesée des cinq sacs, avec une seule forme sortie du corps de la boucle. Les cinq masses saisies sont 12.4, 11.8, 12.9, 13.1 et 12.6.
Dans la pesée des cinq sacs, la forme somme = somme + mesure a été placée après la boucle au lieu d'être dans le corps. Qu'affiche le programme pour les saisies 12.4, 11.8, 12.9, 13.1 et 12.6 ?
Le corps ne contient plus que la lecture. Les cinq lectures s'enchaînent, chacune écrase la précédente, et l'addition n'a lieu qu'une fois, après la boucle, avec la dernière masse lue. Le programme affiche Masse totale : 12.6 kg.
Le symptôme est le même qu'avec une initialisation placée dans la boucle : le total vaut la dernière valeur. Deux causes possibles, une seule vérification : situer chaque forme avant, dans ou après la boucle selon son rôle.
Chapitre révisé en octobre 2026 · Une erreur dans ce chapitre ?
Dans la bibliothèque d'exercices
Compter des tours, accumuler, trouver ce qui arrête une boucle.
- Compter les tours d'une boucleNiveau 1
- Suivre un compteur et un accumulateurNiveau 1
- Le maximum et son rangNiveau 2
- Un accumulateur mal initialiséNiveau 2
- Simuler le refroidissement d'une pièce forgéeNiveau 3
- Construire la saisie de la consigne d'un fourNiveau 2
- Construire la température moyenne d'une chambre froideNiveau 3
- Corriger le contrôle de remplissage des bouteillesNiveau 3