Boucles et contrôle de flux en Python : for, while, break et continue

Les ordinateurs existent pour répéter des tâches. Une personne qui devrait additionner un million de nombres abandonnerait ; une boucle le fait avant même que vous ayez fini de cligner des yeux. Cette leçon présente les deux boucles de Python et les instructions de contrôle qui les pilotent, et elle le fait avec soin, car c'est avec les boucles que les programmeurs débutants ressentent pour la première fois l'écart entre lire du code et l'écrire. À la fin, vous aurez écrit des tables de multiplication, additionné des séries, recherché des valeurs, validé des saisies et résolu le FizzBuzz, l'exercice d'échauffement d'entretien le plus célèbre au monde.

Les deux boucles se partagent le travail de manière nette. Utilisez for quand vous savez sur quelle collection d'éléments vous itérez : chaque nombre d'un intervalle, chaque caractère d'une chaîne, chaque ligne d'un fichier. Utilisez while quand vous connaissez seulement la condition d'arrêt : continuer à demander jusqu'à ce que la réponse soit valide, continuer à jouer jusqu'à ce que le joueur quitte. Apprendre quelle boucle un problème réclame constitue la moitié de cette leçon ; la syntaxe en est la moitié facile.

1. La boucle while : répéter jusqu'à nouvel ordre

Une boucle while est un if qui se répète. Python vérifie la condition ; si elle est évaluée comme vraie, le bloc s'exécute, puis la condition est vérifiée à nouveau, encore et encore jusqu'à ce que la vérification échoue. Cette structure vous impose un devoir sacré : quelque chose à l'intérieur du bloc doit finir par modifier la condition, sinon la boucle ne se termine jamais. Tous les programmeurs en vie ont écrit une boucle infinie par accident ; dans un terminal, Ctrl+C l'interrompt, et dans notre playground, l'exécuteur la coupe tout simplement.

countdown = 5
while countdown > 0:
    print(countdown)
    countdown -= 1      # the line that makes the loop finite
print("Liftoff!")

# 5  4  3  2  1  Liftoff!

Tracez-la une fois à la main, comme vous avez tracé l'échelle des notes dans la partie 2. countdown commence à 5, la condition 5 > 0 est vraie, on affiche et on décrémente. Le corps de la boucle s'exécute cinq fois au total, et quand countdown atteint 0, la condition échoue enfin et l'exécution passe à la ligne de décollage. Cette habitude de tracer une boucle à la main pour les deux premières et les deux dernières itérations vous évitera presque tous les bogues de décalage d'indice cette année.

Le cas d'usage honnête de while est celui où le nombre de répétitions est impossible à connaître à l'avance. L'exemple classique est la validation de saisie : demander, vérifier et redemander jusqu'à ce que la réponse soit acceptable. Vous écrirez cette forme exacte dans de vrais programmes constamment, et elle ne peut pas être écrite naturellement avec for, car personne ne sait combien de tentatives l'utilisateur aura besoin.

# Keep asking until we get a valid choice (terminal version)
choice = ""
while choice not in ("rock", "paper", "scissors"):
    choice = input("rock, paper or scissors? ").lower().strip()
print(f"You chose {choice}")

2. La boucle for et range

Une boucle for parcourt les éléments d'une séquence, un par itération, et remet chaque élément à un nom que vous choisissez. La séquence la plus courante dans les premiers codes est range, qui génère à la demande des entiers régulièrement espacés. range(5) produit 0 à 4, range(1, 6) produit 1 à 5, et range(0, 50, 10) compte de dix en dix. Notez l'asymétrie qui piège tout le monde exactement une fois : le début est inclus, la fin est exclue. Cette convention est délibérée, car elle fait que range(len(items)) s'aligne parfaitement avec les indices valides, et les longueurs s'additionnent proprement quand on divise des intervalles.

for i in range(5):
    print(i, end=" ")        # 0 1 2 3 4
print()

for year in range(2024, 2027):
    print(f"Report for {year}")

total = 0
for n in range(1, 101):
    total += n
print(f"1 + 2 + ... + 100 = {total}")   # 5050

Ce dernier exemple est le motif de l'accumulateur, et c'est peut-être la forme la plus réutilisée de toute la programmation : créez une variable avant la boucle, incorporez-y un élément à chaque itération, et utilisez le résultat après. Les sommes, les produits, les comptages, les chaînes concaténées et (à partir de la partie 5) les listes construites sont tous des accumulateurs. Quand un problème dit « total », « compte » ou « combine », vos doigts devraient commencer à taper un accumulateur avant que votre cerveau ait fini de lire.

for ne se limite pas à range. Toute séquence fonctionne, et les chaînes sont des séquences de caractères, ce qui rend le traitement de texte presque sans effort. Compter les voyelles, l'un des exemples pratiques de l'application Learn Python, tient en quatre lignes : un accumulateur, une boucle sur la chaîne, un test d'appartenance et un print.

sentence = "Learn Python by doing"
vowels = 0
for ch in sentence.lower():
    if ch in "aeiou":
        vowels += 1
print(f"{vowels} vowels in: {sentence}")    # 7 vowels

3. break, continue et le else de boucle

Deux instructions pilotent une boucle en cours d'exécution. break quitte la boucle immédiatement, en sautant à la première ligne après celle-ci ; continue abandonne l'itération en cours et passe directement à la vérification suivante. break transforme while True, une boucle intentionnellement infinie, en la manière la plus propre d'exprimer des flux de type demander puis décider. continue brille comme un filtre précoce qui garde le code intéressant sans indentation superflue : quand un élément n'est pas pertinent, sautez-le en haut du corps et laissez le vrai travail respirer.

# break: search for the first number divisible by 7 and 5
for n in range(1, 200):
    if n % 7 == 0 and n % 5 == 0:
        print(f"Found it: {n}")    # 35
        break

# continue: process only the valid readings
readings = [21.5, -999, 22.1, -999, 23.8]
for r in readings:
    if r == -999:                  # sensor error code
        continue
    print(f"Temperature: {r}")

Python propose une construction que la plupart des langages n'ont pas : une clause else sur les boucles. Le bloc else s'exécute uniquement quand la boucle se termine sans avoir rencontré de break. La première fois, la lecture surprend, mais cela résout parfaitement le problème de la recherche : si la boucle a été interrompue, on a trouvé l'élément ; si le else s'exécute, on a épuisé les possibilités. Sans cela, il faudrait gérer un drapeau found à la main, ce que le else remplace justement.

target = 17
for n in (4, 9, 12, 21):
    if n == target:
        print("Found the target")
        break
else:
    print(f"{target} is not in the data")   # this runs

4. Boucles imbriquées et table de multiplication

Les boucles s'imbriquent : placez-en une à l'intérieur d'une autre et la boucle interne s'exécute entièrement à chaque passage de la boucle externe. L'exemple canonique, et l'une des leçons les plus populaires de l'application Learn Python, est la table de multiplication. La boucle externe choisit la ligne, la boucle interne parcourt les colonnes, et une f-string maintient l'alignement des nombres. Les boucles imbriquées multiplient rapidement le travail : dix par dix font cent itérations, ce qui constitue aussi une première occasion de réfléchir à la quantité de travail qu'un programme effectue, un fil que nous reprendrons en détail dans la leçon sur les générateurs, Partie 9.

for row in range(1, 6):
    for col in range(1, 6):
        print(f"{row * col:4}", end="")
    print()   # end the row

#    1   2   3   4   5
#    2   4   6   8  10
#    3   6   9  12  15
#    4   8  12  16  20
#    5  10  15  20  25

5. Mise en pratique : FizzBuzz et compagnie

FizzBuzz est le test classique pour vérifier si quelqu'un sait combiner une boucle avec des conditions : afficher les nombres de 1 à N, mais afficher Fizz pour les multiples de 3, Buzz pour les multiples de 5, et FizzBuzz pour les multiples des deux. Le piège est l'ordre, comme vu dans la Partie 2 : il faut tester la condition la plus spécifique, divisible par les deux, en premier. Le playground ci-dessous contient une version fonctionnelle ainsi que trois exercices qui transforment cette leçon en réflexes. Exécutez-le, cassez-le, corrigez-le.

L'exercice 1 cache une vraie leçon : le cas combiné pour 4 et 6 est leur plus petit commun multiple, 12, et non leur produit 24, et le test modulo doit l'utiliser. De petits puzzles comme celui-ci montrent pourquoi la pratique des boucles est importante ; la syntaxe s'apprend en une heure, mais l'habitude de prédire ce que le code va faire avant de l'exécuter demande des répétitions délibérées. Cinq exercices supplémentaires sur les boucles, avec retour instantané, se trouvent dans le quiz Contrôle de flux de l'application à la fin de cette page.

6. Choisir entre for et while

En cas de doute, utilisez for. Il est plus difficile d'écrire une boucle infinie avec for, la variable de boucle est gérée pour vous, et la plupart des répétitions du monde réel se font de toute façon sur une collection. Réservez while aux répétitions véritablement ouvertes, et lorsque vous l'utilisez, écrivez la ligne qui modifie la condition en premier, avant le corps, pour ne jamais l'oublier.

Il y a aussi une compétence de traduction qui se cache derrière la syntaxe, et il vaut la peine de la pratiquer délibérément : les problèmes réels n'arrivent pas étiquetés avec la boucle qu'ils nécessitent. Une exigence comme « envoyer un rappel à chaque étudiant qui n'a pas payé » doit devenir « parcourir les étudiants, tester une condition, agir sur les correspondances » dans votre tête avant que le moindre code n'apparaisse. Entraînez cette traduction en formulant les problèmes à voix haute dans le langage des boucles : pour chaque élément, faire quoi, sauf si quoi, jusqu'à ce que quoi. Cela semble idiot pendant une semaine, puis cela devient votre façon de lire chaque tâche, et les recruteurs testent exactement cette traduction bien plus souvent qu'ils ne testent la syntaxe.

Une règle de lisibilité vous servira pendant des décennies : quand le corps d'une boucle dépasse quelques lignes, ce corps mérite de devenir une fonction. Une boucle qui lit for commande in commandes: traiter(commande) raconte toute l'histoire en une ligne, alors que quarante lignes en ligne l'enterrent. Vous pourrez le faire correctement après la Partie 4, et une fois que vous le pourrez, la combinaison de petites boucles appelant des fonctions nommées est ce qui donne l'impression que les grands programmes sont petits.

7. Récapitulatif et prochaines étapes

Vous maîtrisez maintenant la seconde moitié du moteur de la programmation : while pour les répétitions ouvertes, for et range pour les collections, break et continue pour le pilotage, le else de boucle pour les recherches, les boucles imbriquées pour les grilles, et le motif d'accumulation qui sous-tend presque tous les calculs. Combiné avec les décisions de la partie 2, vous pouvez déjà exprimer n'importe quel algorithme ; tout ce qui suit dans ce cours vise à mieux les exprimer.

La prochaine étape est la plus grande amélioration de la qualité de vie de tout le programme. Dans la partie 4, les fonctions Python expliquées, vous cessez d'écrire des scripts et commencez à construire des outils réutilisables avec des noms, des entrées et des sorties. Avant de partir, refaites les exercices FizzBuzz ci-dessus une fois sans regarder la solution, et essayez la leçon Contrôle de flux dans l'application Learn Python ci-dessous ; la répétition espacée sur les boucles est payante pour le reste du parcours, que vous pouvez toujours consulter sur le hub de la série.

Pratiquez en déplacement

Learn Python, l'application Android gratuite

Chaque sujet de cette série est aussi dans l'application : leçons concises, exemples exécutables, quiz, mini-projets et un environnement Python hors ligne qui fonctionne sur votre téléphone.

Disponible sur Google Play Voir la page de l'application