Boucles while et éviter les boucles infinies

Le chapitre for précédent se concentrait sur les boucles où le compteur ou la cible sont connus à l'avance.

L'instruction while couverte ici est une boucle qui se répète « tant qu'une condition tient », et elle s'utilise quand le nombre d'itérations n'est pas connu à l'avance. Gestion de réessais, vidage de file d'attente, boucles de jeu — elle apparaît partout dans le code réel.

Bases de while — répéter tant que la condition est True

while condition: exécute le bloc en boucle tant que la condition est True. À chaque tour de boucle, la condition est ré-évaluée, et dès qu'elle devient False, la boucle se termine.

C'est similaire à for dans la forme, mais au lieu d'extraire d'une cible, elle boucle sur la condition elle-même.

# La forme de base — afficher 0 à 4
count = 0
while count < 5:
    print(count)
    count += 1
# 0 / 1 / 2 / 3 / 4

# Vider les tâches restantes d'une file d'attente
tasks = ["envoyer mail", "sauvegarde", "déploiement"]
while tasks:
    task = tasks.pop(0)       # prendre depuis l'avant
    print(f"traitement : {task}")
# traitement : envoyer mail / traitement : sauvegarde / traitement : déploiement

Le second exemple repose sur le fait que while tasks: bascule à False dès que la liste est vide, en utilisant les règles de truthiness vues plus tôt (une liste vide vaut False).

Boucle jusqu'à ce qu'il reste 0 demande.

① Définis remaining = 3 (le nombre d'éléments restants).

② Avec while, affiche « X éléments restants à traiter » tant que remaining > 0, en décrémentant remaining de 1 à chaque fois.

③ Après la sortie de la boucle, affiche « Tout est traité ».

(L'explication apparaît une fois que tu auras exécuté le code correctement.)

Éviter les boucles infinies — toujours fournir une condition de terminaison

Le plus gros piège avec while est la boucle infinie. Si tu oublies la mise à jour qui fait basculer la condition à False, le programme ne s'arrête jamais. Même dans cette console intégrée au navigateur, cela fige la page jusqu'à un timeout au bout de quelques secondes (ou dizaines de secondes).

# Mauvais : n ne change jamais dans le corps, donc ça ne se termine jamais
# n = 10
# while n > 0:
#     print(n)
# (Ne lance pas ce code — il fige le navigateur / fait un timeout)

# Bon : décrémenter n à chaque fois pour que la condition finisse par devenir False
n = 10
while n > 0:
    print(n)
    n -= 1

Quand tu écris un while, vérifie que tu peux répondre « comment la condition devient-elle False ? »

Avant de l'exécuter, pointe le code et confirme que chaque variable de la condition est mise à jour quelque part dans le corps de la boucle.

Implémente un compte à rebours à partir de 5.

① Définis count = 5.

② À l'intérieur de while count > 0:, affiche count et décrémente avec count -= 1.

③ Après la sortie de la boucle, affiche « DÉCOLLAGE ! ».

Utiliser break et continue dans while

Les break / continue que tu as vus avec for fonctionnent pareil dans while.

Même quand la condition est True, break quitte la boucle de façon décisive et continue recommence le tour actuel — ce sont les motifs typiques.

# Simulation de réessais : jusqu'à 5 tentatives, break dès qu'on trouve
responses = [None, None, "OK", "OK", "OK"]   # réponses simulées d'API externe
attempt = 0
found = False
while attempt < 5:
    attempt += 1
    response = responses[attempt - 1]
    if response is None:
        print(f"tentative {attempt} : pas de réponse, nouvelle tentative")
        continue   # saute le reste de cette itération
    print(f"tentative {attempt} : réponse reçue {response}, terminé")
    found = True
    break          # succès, sortir de la boucle

if not found:
    print("nombre maximum de tentatives atteint")

Mettre attempt += 1 en haut de la boucle est la clé. Avec ce placement, même si continue ou break sortent tôt, le compteur n'est jamais sauté, donc la garantie « jusqu'à 5 tentatives » tient.

Écris une boucle de réessai de mot de passe en utilisant une liste de résultats prédéterminée (sans aléatoire).

① Prépare attempts = ["wrong", "wrong", "right", "wrong"] (les résultats des tentatives).

② Démarre avec i = 0 et boucle avec while i < len(attempts):.

③ À l'intérieur, incrémente i de 1 (en haut), lis un résultat, et :

　- Si "right", affiche « Authentifié à la tentative X » et break.

　- Sinon, affiche « tentative X échouée ».

④ Garde un booléen dans un drapeau found, et après la boucle affiche « Verrouillé » uniquement si aucune bonne réponse n'a été trouvée.

Choisir entre for et while

for et while sont tous deux des boucles, mais ils conviennent à des situations différentes. Quand tu hésites, rappelle-toi de ce tableau.

Dans cet article, on a couvert les bases de while, les conditions de terminaison qui empêchent les boucles infinies, le contrôle du flux avec break / continue, et comment choisir entre for et while.

Avec if / for / while couverts, tu as appris le contrôle de flux fondamental.