Répéter une action
Ce que ce chapitre apporte
- 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.
- É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 boucles, For, While et Do. 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.
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. 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.
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.
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.
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.
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.
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.
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, ne fait que déplacer le problème. La seule 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.
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.
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 ». Exécuter à nouveau avec une première saisie correcte : 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.
La boucle Do : au moins une fois
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.
Le menu de commande d'une pompe. La condition est testée après le corps : commande a toujours reçu une valeur au moment du test.
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()) avant while commande != 0:, et de la même ligne à la fin du corps indenté.
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 |
| Une condition d'arrêt, et au moins un tour est nécessaire | Do | menu, saisie à redemander |
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 : 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.
Fil rouge : la cuve de traitement
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.
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.
Sur six heures, le programme affiche Taux moyen : 85.3 % et Heures au-dessus du seuil haut : 2. Au chapitre suivant, ces relevés seront rangés dans un tableau, pour retrouver aussi le pic et l'heure du pic.
Exercices type
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, et initialise maxi et rangMaxi à 1. La boucle va de 2 à n et fait donc n - 1 tours, un par mesure restante. Le minimum et sa condition disparaissent.
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 saisie doit avoir lieu au moins une fois avant tout contrôle : c'est une boucle Do, dont le corps contient la lecture de ouverture. 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 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 : la boucle recommencerait alors sur une bonne saisie et s'arrêterait sur une mauvaise.
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.
Vérification
1.Combien de tours fait la boucle For i = 1 to 5 ?
2.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 ?
3.Où placer somme ← 0 dans un programme qui additionne des mesures lues par une boucle ?
4.Quelle différence entre While et Do ?
5.Un accumulateur calcule un rendement global comme produit de rendements. Quelle valeur initiale lui donner ?
6.Combien de tours fait une boucle For dont les bornes sont 0 et n - 1 ?
La méthode
- Repérer la répétition : une même action sur plusieurs valeurs ou à plusieurs instants appelle une boucle, pas une recopie.
- Choisir la boucle : For si le nombre de tours est connu avant la boucle, Do si le corps doit s'exécuter au moins une fois, While sinon.
- Nommer ce qui arrête chaque While ou Do : une variable de la condition, modifiée dans le corps.
- Situer chaque forme : initialiser avant, mettre à jour dans le corps, exploiter après.
- Initialiser selon le motif : 0 pour une somme ou un compteur, 1 pour un produit, la première valeur lue pour un maximum ou un minimum.
- Compter les tours : fin − début + 1 pour un For, une exécution en pas à pas sur un petit jeu de saisies pour un While.
Synthèse
- Une boucle répète son corps ; un tour est une exécution du corps.
- For : variable
Integer, bornes comprises, fin − début + 1 tours. En Python,range(1, 11)pour 1 à 10. - While teste avant le corps (zéro tour possible) ; Do exécute le corps puis teste (au moins un tour). Les deux recommencent tant que la condition est vraie.
- Compteur et accumulateur : initialisés avant, mis à jour dedans, exploités après. Un produit commence à 1.
- Maximum et minimum : initialisés avec la première valeur lue, le rang retenu dans la même branche.
- Une condition de boucle porte sur une variable modifiée dans le corps, sinon la boucle ne s'arrête pas.
- Python n'a pas de Do : une lecture puis un While, la lecture répétée à la fin du corps.
Mettre en pratique
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