Structures itératives
En manipulant les boucles for et while dans la console et dans Thonny, vous allez apprendre à répéter des instructions un nombre de fois connu ou inconnu à l’avance, et à choisir la structure itérative adaptée à chaque situation.
Combien de fois une instruction doit-elle être répétée ?
Un programme est souvent amené à répéter plusieurs fois les mêmes instructions : afficher les nombres de 1 à 1000, demander un mot de passe jusqu’à ce qu’il soit correct, ou additionner les notes d’une classe entière. Écrire autant de fois l’instruction à répéter serait absurde ; les langages de programmation proposent pour cela des structures itératives, plus couramment appelées boucles. Chaque passage dans une boucle est appelé une itération.
Pour chacune des situations suivantes, indiquer si le nombre de répétitions est connu avant de commencer à répéter, ou s’il n’est découvert qu’au fur et à mesure de l’exécution :
- afficher les nombres de 1 à 100 ;
- demander un mot de passe jusqu’à ce qu’il soit correct ;
- additionner les 12 notes d’un bulletin ;
- lancer un dé jusqu’à l’obtention d’un 6.
- Une boucle déterministe (ou boucle Pour) répète un nombre d’itérations connu à l’avance ; elle utilise une variable, le compteur de boucle, pour compter les itérations effectuées.
- Une boucle non déterministe (ou boucle conditionnelle) répète des itérations tant qu’une condition d’arrêt n’est pas vérifiée ; ce nombre n’est pas connu à l’avance.
Python ne fournit qu’une seule boucle non déterministe, la boucle while (Tant que). Une boucle non déterministe peut toujours remplacer une boucle déterministe ; l’inverse n’est pas vrai.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
On demande un mot de passe jusqu’à ce qu’il soit correct. Quel type de boucle convient ?
On ne sait pas combien d’essais seront nécessaires : on répète tant que la condition d’arrêt (mot de passe correct) n’est pas vérifiée.
Quelle est la seule boucle non déterministe disponible en Python ?
La boucle while répète son bloc tant qu’une condition est vraie, sans connaître à l’avance le nombre d’itérations.
La boucle “Tant que” : l’instruction while
Syntaxe et fonctionnement
La syntaxe d’une boucle while est :
La condition est une expression booléenne, évaluée au début de chaque itération. Tant qu’elle vaut True, le bloc indenté est exécuté, puis la condition est évaluée à nouveau. Dès qu’elle vaut False, la boucle s’arrête et l’exécution reprend après le bloc. Il est même possible que le bloc ne soit exécuté aucune fois, si la condition est déjà fausse dès la première évaluation.
Recopier la fonction suivante dans la partie principale de l’éditeur Thonny :
Remplacer chacun des numéros ci-dessus par une phrase qui décrit ce que l’instruction réalise.
Appeler ensuite, dans la console, la fonction : affiche_jusqua(5) puis affiche_jusqua(0).
Combien de fois le bloc indenté est-il exécuté dans le premier appel ? Dans le second appel ?
Quelle instruction fait progresser i vers la condition d’arrêt ?
Si aucune instruction du bloc ne fait progresser la condition vers sa fin (si, par exemple, i += 1 avait été oublié), la condition i <= n resterait indéfiniment vraie : la boucle s’exécuterait sans jamais s’arrêter. Ce défaut porte un nom : la boucle infinie.
Écrire une boucle while suppose de réunir trois éléments :
- une initialisation de la ou des variables testées par la condition ;
- une condition d’arrêt, expression booléenne évaluée avant chaque itération ;
- une instruction qui fait progresser cette condition à chaque itération, jusqu’à ce qu’elle devienne fausse.
Oublier ce troisième élément est la cause la plus fréquente de boucle infinie.
Faire tourner une boucle à la main
Vérifier qu’une boucle fait ce qu’on attend d’elle exige de savoir la « faire tourner à la main » : appliquer méthodiquement les instructions, itération après itération, en notant dans un tableau l’évolution du contenu de chaque variable.
On donne la fonction suivante, dont il faut déterminer l’action :
- Repérer les instructions répétées par la boucle et l’instruction qui teste la fin de la boucle.
- Quelle instruction modifie le résultat de l’évaluation de ce test ?
- Sans utiliser Python, compléter le tableau d’évolution ci-dessous pour l’appel
inconnue(30, 42), puis vérifier en exécutant le programme.
| Étape | a | b | r |
|---|---|---|---|
| avant la boucle | 30 | 42 | |
| itération 1 | |||
| itération 2 | |||
| itération 3 |
- Visualiser le fonctionnement de cette fonction à l’aide du débogueur intégré à Thonny.
- Reprendre la question précédente pour l’appel
inconnue(35, 6), sans reconstruire de tableau : donner uniquement la valeur retournée. - Quel calcul réalise cette fonction ?
Voici une autre fonction, dont il faut également déterminer l’action :
- Quelle est la valeur initiale de
i? Quelle est sa valeur lorsque la boucle s’arrête ? - Sans utiliser Python, compléter le tableau d’évolution ci-dessous pour l’appel
inconnue_deux(6), puis vérifier en exécutant le programme.
| Étape | i | b |
|---|---|---|
| avant la boucle | 2 | 1 |
| itération 1 | ||
| itération 2 | ||
| itération 3 | ||
| itération 4 | ||
| itération 5 |
- Quel calcul réalise cette fonction ?
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Dans affiche_jusqua(n) (i = 1, puis while i <= n: avec print(i) et i += 1), combien de fois le bloc est-il exécuté pour affiche_jusqua(0) ?
La condition est évaluée avant chaque itération. Dès le départ, 1 <= 0 vaut False : le bloc n’est jamais exécuté.
Dans cette même fonction, que se passe-t-il si on oublie l’instruction i += 1 ?
Rien ne fait progresser la condition vers sa fin : la boucle ne s’arrête jamais.
Quels sont les trois éléments d’une boucle while bien écrite ?
Oublier le troisième élément est la cause la plus fréquente de boucle infinie.
La boucle “Pour chaque” : l’instruction for et l’itérateur range
Syntaxe de la boucle “Pour chaque”
En Python, l’instruction for implémente en réalité une boucle Pour chaque : elle parcourt, un par un, les éléments d’un objet itérable, et non un simple compteur comme dans d’autres langages.
À chaque itération, la variable element prend la valeur de l’élément courant de l’itérable, pour être utilisée dans le bloc indenté. Cette variable ne doit jamais être modifiée dans le corps de la boucle : dans le cas contraire, le comportement de la boucle devient imprévisible.
Recopier la fonction suivante dans la partie principale de l’éditeur :
Appeler affiche_intervalle(10) dans la console. Quels entiers sont produits par range(1, 11) ? Combien y en a-t-il ?
Recopier la fonction suivante dans la partie principale de l’éditeur :
Cette fonction parcourt le même itérable que la précédente. Sans exécuter le programme, prévoir le résultat de table_de(4), puis vérifier dans la console.
Réécrire ensuite l’instruction reponse += str(calcul) + " " à l’aide d’une f-string (voir Doc. 2,2), et vérifier que table_de(4) retourne toujours le même résultat.
L’itérateur range
L’itérateur range génère, à la volée, des entiers compris entre une valeur de départ début et une valeur finale fin (exclue), par pas de pas. Trois écritures sont possibles :
range(fin) |
entiers de 0 à fin (exclu), par pas de 1 |
|---|---|
range(début, fin) |
entiers de début à fin (exclu), par pas de 1 |
range(début, fin, pas) |
entiers de début à fin (exclu), par pas de pas |
Comme pour les tranches, la valeur fin n’est jamais atteinte : Python considère systématiquement les intervalles sous la forme .
Recopier la fonction suivante dans la partie principale de l’éditeur :
Prévoir puis vérifier dans la console le résultat de chacun des appels suivants :
Le pas pas peut-il être négatif ? Que se passe-t-il alors ?
Écrire, dans la partie principale de l’éditeur, deux fonctions demo_range_1arg et demo_range_2arg, qui affichent respectivement, séparés par un espace, les entiers produits par range(fin) et par range(debut, fin).
Tester demo_range_1arg(10) et demo_range_2arg(1, 10) dans la console.
La boucle for element in itérable: parcourt un par un les éléments d’un itérable ; la variable element ne doit jamais être modifiée dans le corps de la boucle.
L’itérateur range(début, fin, pas) génère les entiers de début (inclus) à fin (exclu), par pas de pas. Avec un seul argument, range(fin) part de 0 avec un pas de 1 ; avec deux arguments, range(début, fin) utilise un pas de 1.
Une boucle for peut toujours être réécrite avec une boucle while, en gérant soi-même le compteur ; l’inverse n’est vrai que si le nombre d’itérations est connu à l’avance.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Quels entiers sont produits par range(1, 5) ?
range(début, fin) produit les entiers de début (inclus) à fin (exclu).
Quels entiers sont produits par range(4) ?
Avec un seul argument, range(fin) part de 0, avec un pas de 1, et fin est exclu.
Quels entiers sont produits par range(10, 1, -3) ?
Avec un pas négatif, on descend : 10, 7, 4. La valeur suivante, 1, est la fin : elle est exclue.
Dans une boucle for element in iterable:, peut-on modifier element dans le corps de la boucle ?
C’est la boucle for qui donne ses valeurs à element, une à une. Le modifier rend le programme difficile à comprendre.
Interrompre une boucle ou passer à l’itération suivante : break et continue
L’instruction break
break met fin immédiatement à la boucle en cours et poursuit l’exécution juste après elle. On l’utilise généralement lorsqu’une condition testée avec if doit provoquer une sortie immédiate de la boucle. break s’utilise aussi bien dans une boucle for que dans une boucle while ; elle est en particulier indispensable pour sortir d’une boucle délibérément infinie, écrite avec while True:.
Les deux fonctions suivantes déterminent, par une méthode peu efficace, le plus grand diviseur d’un entier nbre (différent de nbre lui-même) : on teste, en partant de nbre - 1, tous les diviseurs possibles, jusqu’à en trouver un qui convient.
Tester les deux fonctions avec nbre = 18. Pourquoi est-il inutile de continuer la boucle une fois un diviseur trouvé ? Dans la seconde fonction, à quel endroit du programme la variable diviseur reste-t-elle accessible, alors qu’elle est définie par la boucle for ?
L’instruction continue
continue interrompt seulement l’itération courante et reprend au début de l’itération suivante : nouvelle évaluation de la condition pour une boucle while, élément suivant pour une boucle for.
Les deux fonctions suivantes retournent une chaîne de caractères formée des entiers, inférieurs à nbre, qui ne le divisent pas :
Tester les deux fonctions avec nbre = 18. Dans non_diviseur, pourquoi l’instruction diviseur -= 1 apparaît-elle à deux endroits différents ?
Réécrire la fonction non_diviseur_2 sous la forme non_diviseur_3, sans utiliser continue, à l’aide d’un simple if, et en construisant reponse à l’aide d’une f-string plutôt que de str(diviseur) + " ". Cette nouvelle version est-elle plus lisible ?
breakarrête définitivement la boucle en cours ; l’exécution reprend juste après elle.continuearrête seulement l’itération en cours ; l’exécution reprend au début de l’itération suivante.
Ces deux instructions s’utilisent aussi bien dans une boucle for que dans une boucle while.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que fait l’instruction break ?
break sort de la boucle en cours. C’est continue qui passe à l’itération suivante.
Que fait l’instruction continue ?
Les instructions qui suivent continue dans le bloc sont sautées pour cette itération seulement.
break et continue s’utilisent :
Ces deux instructions fonctionnent aussi bien dans une boucle for que dans une boucle while.
Exercices de synthèse
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature + documentation), en utilisant des f-strings pour construire les chaînes de caractères (voir Doc. 2,2). Tester ensuite son appel dans la console.
Construire un résultat au fil des itérations
Écrire la fonction triple_du_precedent dont la spécification est :
Utiliser une boucle while.
Écrire la fonction multiplication_multiple_trois dont la spécification est :
Écrire la fonction multiplication_multiple_sept dont la spécification est :
En quoi cette fonction diffère-t-elle de multiplication_multiple_trois : marque-t-elle simplement des valeurs, ou en sélectionne-t-elle certaines ?
Écrire la fonction diviseurs dont la spécification est :
Écrire et exécuter la fonction loto_naif dont la spécification est :
Remarque. Normalement, un numéro déjà tiré ne peut pas réapparaître. On acceptera ici qu’un même numéro apparaisse plusieurs fois, faute de disposer encore d’une structure de données adaptée pour mémoriser les numéros déjà sortis.
Boucles imbriquées
Écrire la fonction table_multiplication dont la spécification est :
Indication. Utiliser deux boucles while imbriquées, et le caractère "\n" pour passer à la ligne. Tester avec print(table_multiplication()) dans la console, pour visualiser le résultat sous forme de tableau.
Demander une information à l’utilisateur
La fonction input retourne toujours une chaîne de caractères ; une conversion est donc nécessaire pour récupérer un nombre :
Écrire la fonction plus_grand_plus_petit dont la spécification est :
Écrire la fonction moyenne dont la spécification est :
Boucles pilotées par un événement imprévisible
Dans les deux fonctions précédentes, le nombre de saisies est un paramètre fixé à l’avance : une boucle while n’était donc pas indispensable. Il existe des situations où ce nombre ne peut au contraire pas être connu avant l’exécution.
On souhaite ne plus imposer le nombre de notes à saisir : l’utilisateur arrête la saisie en entrant une note négative. Écrire la fonction moyenne_ter dont la spécification est :
Indication. Écrire while True: et utiliser break pour sortir de la boucle. Pourquoi une boucle for ne convient-elle pas ici ?
Écrire et exécuter la fonction devine dont la spécification est :
Indication. Le module random et sa fonction randint ont été présentés dans le Doc. 2,1.
Manipuler le code ASCII
Écrire et exécuter la fonction alphabet dont la spécification est :
Indication. ord(car) retourne le code ASCII du caractère car ; chr(code) retourne le caractère correspondant à code. Le code de 'a' est 97, celui de 'z' est 122.
Suites définies par récurrence
On rappelle la suite de Fibonacci, définie par , et, pour , .
Écrire la fonction fibo dont la spécification est :
Indication. Traiter séparément les cas n == 1 et n == 2, puis utiliser deux variables u et v qui mémorisent les deux derniers termes calculés.
Choisir entre for et while
Reprendre les fonctions triple_du_precedent, multiplication_multiple_trois, multiplication_multiple_sept, diviseurs, table_multiplication, plus_grand_plus_petit, moyenne, loto_naif et alphabet, et les réécrire à l’aide de l’instruction for.
Pourquoi moyenne_ter et devine ne peuvent-elles pas, elles, être réécrites avec for ?
Le choix entre for et while dépend de la nature du problème, pas des préférences du programmeur :
- si le nombre d’itérations est connu avant l’exécution (un nombre de termes, une taille fixée),
forest le choix naturel et le plus lisible ; - si ce nombre dépend du déroulement de l’exécution (une saisie jusqu’à une valeur correcte, une recherche jusqu’à un résultat), seule une boucle
whileconvient.
Pour aller plus loin (difficile)
Code ISBN. Le code ISBN (« International Standard Book Number ») identifie un livre à l’aide de dix chiffres. Le dernier chiffre est une somme de contrôle, calculée à partir des neuf premiers : si désignent ces neuf chiffres et le dixième, la somme doit être un multiple de 11.
Écrire une fonction qui demande à l’utilisateur les neuf premiers chiffres d’un code ISBN et retourne le code complet sous forme d’une chaîne de caractères.
Calendrier. Écrire une fonction qui affiche un calendrier allant du 1ᵉʳ janvier 2001 au 31 décembre 3000, en indiquant pour chaque jour le nombre de jours écoulés depuis le 1ᵉʳ janvier 2001, le jour de la semaine, le quantième, le mois et l’année.
Indication. Une année est bissextile si son millésime est multiple de 4, sauf s’il est multiple de 100 sans être multiple de 400 (1900 n’était pas bissextile, 2000 l’a été).
Le taxi de Ramanujan. Trouver tous les entiers inférieurs ou égaux à un nombre choisi par l’utilisateur qui peuvent s’écrire comme somme de deux cubes, de deux façons différentes : trouver quatre entiers , , , , inférieurs à , tels que .
Indication. Quatre boucles imbriquées suffisent, même si le résultat n’est pas optimisé.
Bilan : où en suis-je ?
Pour chaque ligne, cochez la colonne qui correspond. Toute case Pas encore indique une partie à reprendre.
| Je sais… | Oui | Pas encore | À revoir |
|---|---|---|---|
distinguer une boucle déterministe (for) d’une boucle non déterministe (while) |
Partie 1 | ||
écrire une boucle while (initialisation, condition d’arrêt, mise à jour) et prévoir si elle peut ne jamais s’exécuter |
Partie 2 | ||
| « faire tourner une boucle à la main » à l’aide d’un tableau d’évolution | Partie 2 | ||
écrire une boucle for en utilisant range avec un, deux ou trois arguments |
Partie 3 | ||
utiliser break pour interrompre une boucle et continue pour passer à l’itération suivante |
Partie 4 | ||
| écrire une fonction qui accumule un résultat (chaîne, somme, maximum) au fil d’une boucle | Partie 5 | ||
choisir entre for et while selon que le nombre d’itérations est connu ou non à l’avance |
Partie 5 |