Les boucles while — répéter tant qu'une condition reste vraie

Le problème que nous résolvons

Au chapitre précédent, nous avons appris à détecter une mauvaise saisie : quand quelqu'un tape vingt, le programme peut répondre « ce n'est pas un nombre ».

Mais que fait-il ensuite ? Il s'arrête. La personne doit relancer tout le programme. Aucun logiciel sérieux ne se comporte ainsi : il redemande, et continue de demander jusqu'à obtenir une réponse valide.

C'est à cela que servent les boucles : répéter le même travail aussi longtemps que nécessaire. Aujourd'hui, nous apprenons while, qui s'exécute tant qu'une condition reste vraie.

Une nouveauté vous attend aussi aujourd'hui : un programme qui ne s'arrête pas, avec du texte qui défile à toute allure dans le terminal. Rien à craindre — vous apprendrez à l'arrêter dans ce même chapitre.

À la fin de ce chapitre, vous pourrez

• Écrire une boucle while et dire quand elle s'arrêtera
• Reconnaître les causes d'une boucle infinie, et en arrêter une avec Ctrl + C
• Accumuler une somme ou un compteur à l'intérieur d'une boucle
• Utiliser break et continue aux bons endroits
• Redemander jusqu'à ce que la saisie soit valide

Prérequis : Prendre des décisions — if, elif, else.

La boucle la plus simple

count = 3

while count > 0:
    print(count)
    count = count - 1

print("Go")

3
2
1
Go

La structure ressemble à celle d'un if : condition, deux-points, bloc indenté. Une seule différence, et elle change tout : un if vérifie la condition une seule fois ; un while la revérifie à chaque fois que le bloc se termine.

Voici ce qu'a fait le programme ci-dessus :

1. count vaut 3. La condition 3 > 0 est vraie → le bloc s'exécute, affiche 3, et count devient 2
2. Nouvelle vérification : 2 > 0 est vrai → affiche 2, count devient 1
3. Nouvelle vérification : 1 > 0 est vrai → affiche 1, count devient 0
4. Nouvelle vérification : 0 > 0 est faux → la boucle se termine et l'exécution reprend après elle

Toute boucle while qui fonctionne comporte trois éléments, et elle a besoin des trois :

• Une valeur de départ — avant la boucle (count = 3)
• Une condition — quand continuer (count > 0)
• Une modification — quelque chose à l'intérieur qui finira par rendre la condition fausse (count = count - 1)

Les boucles infinies

Il est utile de voir ce qui se passe quand le troisième élément manque :

count = 3

while count > 0:
    print(count)

Ce programme affiche 3 sans fin. count ne change jamais, donc count > 0 ne devient jamais faux.

Pour l'arrêter : appuyez sur Ctrl + C dans le terminal. Le programme s'interrompt immédiatement et affiche quelque chose comme ceci :

Traceback (most recent call last):
  File "D:\python-lab\lesson-10\loop.py", line 4, in <module>
    print(count)
KeyboardInterrupt

La ligne File affichera le chemin complet de votre fichier, et le numéro de ligne dépend du moment exact où vous avez appuyé sur les touches. KeyboardInterrupt signifie que c'est vous qui avez arrêté le programme. Ce n'est pas un bug de votre code, c'est votre décision.

Les boucles infinies font partie de l'apprentissage. Tous les programmeurs en ont écrit une, et continuent d'en écrire. Rien à craindre — savoir utiliser Ctrl + C réduit le problème à un simple désagrément. Quand vous écrivez une boucle, posez-vous simplement une question : « comment cette condition deviendra-t-elle fausse ? » Si vous ne savez pas répondre, la boucle ne s'arrêtera pas.

Accumuler

Le travail le plus courant d'une boucle consiste à construire quelque chose petit à petit : une somme, un compte, la plus grande valeur rencontrée :

total = 0
number = 1

while number <= 5:
    total = total + number
    number = number + 1

print("Sum of 1 to 5:", total)

Sum of 1 to 5: 15

total s'appelle un accumulateur — le récipient dans lequel on rassemble. Remarquez qu'il démarre en dehors de la boucle, à 0. Le placer à l'intérieur le réinitialiserait à chaque passage : il ne resterait alors que le dernier nombre à la fin.

break — sortir tout de suite

break met fin à la boucle immédiatement, quelle que soit la condition :

number = 1

while number <= 100:
    if number % 7 == 0:
        print("First multiple of 7:", number)
        break
    number = number + 1

First multiple of 7: 7

La condition disait de continuer jusqu'à 100, mais le travail était terminé dès que 7 est apparu — inutile donc de tourner 93 fois de plus.

break permet aussi un schéma très utile : écrire True comme condition et sortir au bon endroit à l'intérieur :

while True:
    answer = input("Type 'quit' to exit: ").strip().lower()
    if answer == "quit":
        print("Goodbye")
        break
    print(f"You typed: {answer}")

Type 'quit' to exit: hello
You typed: hello
Type 'quit' to exit: QUIT
Goodbye

while True signifie « tourner sans fin », donc un break à l'intérieur est indispensable — sinon, c'est une boucle infinie.

continue — passer ce tour

continue ne met pas fin à la boucle ; il saute le reste du bloc et passe directement au tour suivant :

number = 0

while number < 10:
    number = number + 1
    if number % 2 == 0:
        continue
    print(number)

1
3
5
7
9

Pour chaque nombre pair, continue s'est exécuté, donc le print a été sauté.

Attention au piège avec continue. Si la ligne qui fait avancer la condition (number = number + 1) se trouve après le continue, alors continue la saute — et la boucle reste bloquée là pour toujours. C'est pourquoi l'incrémentation vient en premier dans le code ci-dessus. Chaque fois que vous utilisez continue, vérifiez cet ordre.

Enfin : redemander jusqu'à obtenir une saisie valide

C'est ce que nous attendons depuis deux chapitres :

while True:
    raw = input("Your age: ").strip()
    if raw.isdigit():
        age = int(raw)
        break
    print("Please type a whole number, digits only.")

print(f"Thank you. Age recorded as {age}.")

Your age: twenty
Please type a whole number, digits only.
Your age: 22.5
Please type a whole number, digits only.
Your age: 22
Thank you. Age recorded as 22.

C'est le schéma que vous utiliserez tout au long de votre vie professionnelle : boucler sans fin, valider à l'intérieur, faire break quand la saisie est bonne, afficher un message et repartir quand elle ne l'est pas. Le programme ne plante plus à cause d'une mauvaise saisie, et la personne n'a pas à tout recommencer.

Un exemple complet

shopping.py :

# Keep taking item prices until the user is done, then summarise
total = 0.0
item_count = 0

print("Enter item prices. Type 'done' to finish.")

while True:
    entry = input("Price: ").strip().lower()

    if entry == "done":
        break

    if entry == "":
        print("  Nothing typed — try again.")
        continue

    # Accept only digits and at most one decimal point
    if entry.replace(".", "", 1).isdigit():
        price = float(entry)
        total = total + price
        item_count = item_count + 1
        print(f"  Added {price:.2f}. Running total {total:.2f}")
    else:
        print(f"  '{entry}' is not a price. Try again.")

print()
if item_count == 0:
    print("No items were entered.")
else:
    average = total / item_count
    print(f"Items   : {item_count}")
    print(f"Total   : {total:.2f}")
    print(f"Average : {average:.2f}")

Enter item prices. Type 'done' to finish.
Price: 120
  Added 120.00. Running total 120.00
Price: abc
  'abc' is not a price. Try again.
Price: 85.5
  Added 85.50. Running total 205.50
Price: done

Items   : 2
Total   : 205.50
Average : 102.75

Trois éléments travaillent ensemble ici, et tous les trois font partie du sujet du jour :

• break — quitter la boucle quand la personne tape done
• continue — sauter la suite et redemander quand la ligne est vide
• Accumulateurs — total et item_count démarrent tous deux en dehors de la boucle et grandissent à l'intérieur

Prenez le temps de réfléchir à la raison pour laquelle ce if item_count == 0 final est nécessaire. Si quelqu'un tape done tout de suite, sans rien saisir, item_count vaut 0, et total / item_count ferait planter le programme avec une ZeroDivisionError. Avant d'utiliser quoi que ce soit qu'une boucle a accumulé, posez-vous toujours la question : « y a-t-il eu quelque chose d'accumulé ? »

En cas de problème

Le programme ne s'arrête pas, le texte défile sans fin Appuyez sur Ctrl + C. Vérifiez ensuite que le corps de la boucle contient la ligne qui fait avancer la condition, et qu'elle ne se trouve pas après un continue.

La boucle ne s'est jamais exécutée La condition était déjà fausse. Comparez la valeur de départ avec la condition — while count > 0 partant de count = 0 n'entre jamais dans la boucle.

Elle tourne une fois de trop ou une fois de moins < et <= ont été confondus. Partant de n = 1, while n < 5 tourne quatre fois (avec n valant 1, 2, 3, 4), et while n <= 5 tourne cinq fois. Changer la valeur de départ change aussi le nombre de tours — partant de n = 0, while n < 5 tourne cinq fois. Vérifiez donc toujours ensemble la valeur de départ et la condition.

IndentationError: expected an indented block after 'while' statement La ligne qui suit le while n'est pas indentée.

NameError après la boucle — la variable est inconnue La variable n'a été créée qu'à l'intérieur de la boucle ; si la boucle ne s'est jamais exécutée, elle n'a jamais été créée. Donnez une valeur de départ à toute variable dont vous avez besoin après la boucle, avant celle-ci.

Le total est faux à la fin de la boucle Vérifiez si l'accumulateur est initialisé à l'intérieur de la boucle. La ligne total = 0 doit se trouver en dehors.

À vous de jouer

Écrivez un jeu de devinettes, guess.py :

1. Fixez un nombre secret dans le code, entre 1 et 100
2. Demandez à la personne de deviner, et indiquez « plus haut » ou « plus bas » à chaque fois
3. Si la réponse est correcte, félicitez-la et quittez la boucle
4. Affichez le nombre d'essais qu'il a fallu
5. Si la personne tape quelque chose qui n'est pas un nombre, le programme ne doit pas planter — affichez un message et redemandez
6. Après sept essais, la partie se termine en révélant le nombre secret

Le point 6 est celui qui va vous faire réfléchir : votre boucle peut maintenant se terminer pour deux raisons différentes — une bonne réponse, ou que les essais soient épuisés. La façon d'agencer ces deux sorties est la vraie question de cet exercice. Et une fois que tout fonctionne, relisez votre code une dernière fois et demandez-vous : existe-t-il un état que cette boucle pourrait atteindre, où elle tournerait éternellement ?