Les boucles while en Python : un guide complet

Une boucle while exécute un bloc de code de manière répétée tant qu'une condition est True. Contrairement à une boucle for, qui itère sur une séquence connue d'éléments, la boucle while est le bon choix lorsque vous ne savez pas à l'avance combien d'itérations vous aurez besoin — par exemple, lors de la lecture d'une entrée utilisateur, du vidage d'une file d'attente, ou de la répétition d'une opération jusqu'à ce qu'elle réussisse.

Ce chapitre couvre :

• La syntaxe de base et la façon dont la condition est évaluée
• break — quitter la boucle prématurément
• continue — passer à l'itération suivante
• La clause else — code qui s'exécute lorsque la boucle se termine normalement
• Les boucles while imbriquées
• Le placeholder pass
• Les boucles infinies et comment les éviter
• Quand choisir while plutôt que for

Syntaxe de base

while condition:
    # block executed while condition is True

Python évalue condition avant chaque itération. Si elle est True, le bloc indenté s'exécute. Lorsque le bloc se termine, la condition est vérifiée à nouveau. La boucle se termine dès que la condition est évaluée à False.

Compter de 1 à 5

Résultat :

1
2
3
4
5

Ici i commence à 1. Après chaque print, i augmente de 1. Lorsque i atteint 6, la condition i <= 5 devient False et la boucle s'arrête.

La variable compteur doit être mise à jour à l'intérieur de la boucle. Oublier i += 1 (ou une mise à jour équivalente) signifie que la condition ne devient jamais False et vous obtenez une boucle infinie.

Exemple de compte à rebours

count = 5
while count > 0:
    print(count)
    count -= 1
print("Liftoff!")

Résultat :

5
4
3
2
1
Liftoff!

Le code après le bloc while s'exécute une fois que la boucle est terminée — dans ce cas, print("Liftoff!") n'est pas à l'intérieur de la boucle.

Boucler jusqu'à ce qu'une liste soit vide

Tout objet ayant une valeur booléenne peut servir de condition. Une liste vide est falsy, vous pouvez donc vider une liste naturellement :

stack = [1, 2, 3]
while stack:
    print(stack.pop())

Résultat :

3
2
1

while stack est un raccourci pour while len(stack) > 0. Une fois la liste vide, elle est falsy et la boucle se termine.

L'instruction break

break quitte la boucle immédiatement, quelle que soit la condition.

Résultat :

0
1
2
3
4

Lorsque num est égal à 5, break se déclenche et la boucle se termine — les valeurs 5 à 9 ne sont jamais atteintes.

Quand utiliser break : arrêter une recherche dès qu'une correspondance est trouvée ; interrompre une boucle lorsqu'une condition d'erreur survient ; quitter une boucle de menu lorsque l'utilisateur choisit "quitter".

L'instruction continue

continue ignore le reste de l'itération actuelle et retourne directement à la vérification de la condition.

i = 0
while i < 8:
    i += 1
    if i % 2 == 0:
        continue
    print(i)

Résultat :

1
3
5
7

Lorsque i est pair, continue ignore print(i) et la boucle revient évaluer la condition avec le i mis à jour.

Important : incrémentez le compteur avant la vérification continue, pas après. Si i += 1 était placé après continue, i resterait pair indéfiniment et la boucle s'exécuterait sans fin.

La clause else

La boucle while de Python prend en charge un bloc else optionnel. Il s'exécute uniquement si la boucle s'est terminée normalement — c'est-à-dire que la condition est devenue False — et est ignoré si la boucle a été quittée via break.

Fin normale

i = 1
while i <= 3:
    print(i)
    i += 1
else:
    print("Done!")

Résultat :

1
2
3
Done!

Boucle interrompue par break

i = 1
while i <= 5:
    if i == 3:
        break
    print(i)
    i += 1
else:
    print("No break")

Résultat :

1
2

"No break" n'est jamais affiché car break a mis fin à la boucle avant que la condition ne puisse devenir False.

Usage pratique : recherche linéaire

La clause else est particulièrement utile pour les motifs de recherche. Le bloc else ne s'exécute que lorsque la cible n'a pas été trouvée :

numbers = [4, 7, 2, 9, 1]
target = 9
i = 0
while i < len(numbers):
    if numbers[i] == target:
        print("Found", target, "at index", i)
        break
    i += 1
else:
    print(target, "not found")

Résultat :

Found 9 at index 3

Boucles while imbriquées

Une boucle while peut contenir une autre boucle while à l'intérieur. La boucle interne complète toutes ses itérations pour chaque itération de la boucle externe.

row = 1
while row <= 3:
    col = 1
    while col <= 3:
        print(row * col, end="  ")
        col += 1
    print()
    row += 1

Résultat :

1  2  3  
2  4  6  
3  6  9  

Attention : un break à l'intérieur de la boucle interne ne quitte que la boucle interne. Pour quitter les deux boucles à la fois, utilisez une variable flag ou restructurez le code dans une fonction et utilisez return.

L'instruction pass

pass est un placeholder sans opération. Utilisez-le lorsqu'une boucle while est syntaxiquement requise mais que le corps n'est pas encore implémenté :

i = 0
while i < 3:
    pass  # TODO: add logic later
    i += 1

Sans pass, Python lèverait une IndentationError car un bloc vide est une syntaxe invalide.

Boucles infinies

Une boucle infinie s'exécute indéfiniment car sa condition ne devient jamais False. Il s'agit presque toujours d'un bug — mais il existe aussi des utilisations intentionnelles.

Boucle infinie accidentelle

# WARNING: this loop never ends — do not run
i = 1
while i <= 5:
    print(i)
    # forgot to increment i

Sans i += 1, i reste à 1, la condition est toujours True, et la boucle s'exécute jusqu'à ce que vous arrêtiez le programme manuellement (Ctrl+C).

Boucle infinie intentionnelle avec break

# WARNING: intentional infinite loop — requires Ctrl+C to stop outside an app
while True:
    answer = input("Type 'quit' to exit: ")
    if answer == "quit":
        break
    print("You typed:", answer)

while True est un idiome délibéré pour "continuer jusqu'à être explicitement arrêté." Vous devez toujours avoir un break (ou un return) quelque part à l'intérieur, sinon le programme se bloquera.

Consultez le chapitre Python User Input pour plus de motifs impliquant des boucles interactives.

Boucles while vs boucles for

Utilisez for lorsque vous le pouvez ; passez à while lorsque la condition de fin est dynamique ou inconnue au début de la boucle.

Pratique