Qu'est-ce que la boucle while en Python ?

La boucle while est l'une des structures de contrôle les plus fondamentales en Python. Elle permet de répéter un bloc d'instructions tant qu'une condition reste vraie. Que vous soyez débutant ou que vous cherchiez à approfondir vos connaissances, maîtriser la boucle while est indispensable pour écrire des programmes dynamiques et interactifs. Si vous souhaitez apprendre Python de manière structurée, nous vous recommandons de suivre notre formation complète sur Python qui couvre ce sujet en profondeur.

Définition de la boucle while

En Python, le mot-clé while introduit une boucle conditionnelle. Contrairement à la boucle for qui itère sur une séquence prédéfinie (comme une list ou un tuple), la boucle while continue à s'exécuter tant que la condition spécifiée est évaluée à True. Dès que cette condition devient False, la boucle s'arrête et l'exécution du programme se poursuit avec le code qui suit.

La syntaxe générale est la suivante :

while condition:
    # bloc d'instructions
    # exécuté tant que condition est True

Le fonctionnement se résume en trois étapes :

1. Évaluation de la condition : Python vérifie si l'expression est True ou False.
2. Exécution du bloc : si la condition est True, le bloc indenté est exécuté.
3. Retour à l'étape 1 : après l'exécution du bloc, Python revient à l'évaluation de la condition.

Exemples pratiques de la boucle while

Compteur simple

L'exemple le plus classique est un compteur qui s'incrémente jusqu'à atteindre une valeur donnée :

compteur = 0

while compteur < 5:
    print(f"Compteur : {compteur}")
    compteur += 1

print("Boucle terminée !")

Ce code affiche :

Compteur : 0
Compteur : 1
Compteur : 2
Compteur : 3
Compteur : 4
Boucle terminée !

Remarquez que nous utilisons ici une f-string pour formater l'affichage. La variable compteur est incrémentée à chaque itération grâce à l'opérateur +=. Sans cette incrémentation, la condition compteur < 5 resterait toujours vraie, créant une boucle infinie.

Saisie utilisateur avec validation

La boucle while est particulièrement utile pour demander une saisie à l'utilisateur et la valider :

mot_de_passe = ""

while mot_de_passe != "secret123":
    mot_de_passe = input("Entrez le mot de passe : ")

print("Accès autorisé !")

Ici, la boucle continue de demander le mot de passe tant que l'utilisateur n'entre pas la bonne valeur. C'est un schéma très courant dans les programmes interactifs.

Calcul itératif : la somme des entiers

Vous pouvez utiliser while pour effectuer des calculs itératifs :

n = 10
somme = 0
i = 1

while i <= n:
    somme += i
    i += 1

print(f"La somme des entiers de 1 à {n} est : {somme}")
# Affiche : La somme des entiers de 1 à 10 est : 55

Parcourir une liste avec while

Bien que la boucle for soit généralement préférée pour parcourir des séquences, vous pouvez aussi utiliser while avec un index :

fruits = ["pomme", "banane", "cerise", "mangue"]
index = 0

while index < len(fruits):
    print(f"Fruit {index + 1} : {fruits[index]}")
    index += 1

Nous utilisons ici la fonction len pour obtenir la taille de la liste et contrôler la condition de la boucle. Notez que la fonction enumerate avec une boucle for serait plus idiomatique en Python pour ce cas d'utilisation.

Les instructions break, continue et else

L'instruction break

L'instruction break permet de sortir immédiatement de la boucle while, même si la condition est encore vraie :

while True:
    reponse = input("Tapez 'quitter' pour sortir : ")
    if reponse == "quitter":
        print("Au revoir !")
        break
    print(f"Vous avez tapé : {reponse}")

Dans cet exemple, while True crée une boucle infinie volontaire. L'instruction break est la seule façon de sortir de cette boucle. Ce schéma est très utilisé pour les menus interactifs ou les boucles de jeu.

L'instruction continue

L'instruction continue permet de passer directement à l'itération suivante en ignorant le reste du bloc :

nombre = 0

while nombre < 10:
    nombre += 1
    if nombre % 2 == 0:
        continue
    print(f"{nombre} est impair")

Ce code affiche uniquement les nombres impairs de 1 à 9. Quand nombre est pair, continue saute l'appel à print et revient directement à l'évaluation de la condition.

La clause else

Peu de développeurs connaissent cette particularité de Python : la boucle while peut être suivie d'une clause else. Le bloc else est exécuté quand la condition de la boucle devient False, mais pas si la boucle est interrompue par un break :

# Exemple SANS break (else exécuté)
compteur = 0
while compteur < 3:
    print(f"Itération {compteur}")
    compteur += 1
else:
    print("La boucle s'est terminée normalement")

# Affiche :
# Itération 0
# Itération 1
# Itération 2
# La boucle s'est terminée normalement

# Exemple AVEC break (else NON exécuté)
compteur = 0
while compteur < 3:
    if compteur == 1:
        print("Interruption !")
        break
    print(f"Itération {compteur}")
    compteur += 1
else:
    print("Ce message ne s'affichera pas")

# Affiche :
# Itération 0
# Interruption !

Cette fonctionnalité est particulièrement utile pour les recherches : le bloc else s'exécute quand l'élément n'a pas été trouvé.

Les boucles infinies : dangers et utilisations

Une boucle infinie se produit quand la condition de la boucle while ne devient jamais False. Cela peut être involontaire (un bug) ou intentionnel (un choix de conception).

Boucle infinie involontaire (bug)

# ATTENTION : Ce code crée une boucle infinie !
x = 10
while x > 0:
    print(x)
    # Oubli de décrémenter x !
    # Il manque : x -= 1

Dans cet exemple, la variable x reste toujours à 10, donc la condition x > 0 est toujours vraie. Le programme ne s'arrêtera jamais naturellement. Vous devrez utiliser Ctrl+C dans le terminal pour l'interrompre.

Boucle infinie intentionnelle

Certaines situations justifient l'utilisation d'une boucle infinie contrôlée :

import time

def serveur_simplifie():
    """Simule un serveur qui tourne en continu."""
    while True:
        print("En attente de connexion...")
        time.sleep(2)  # Pause de 2 secondes
        # En production, ici on traiterait les requêtes
        # et on aurait un mécanisme d'arrêt propre

Les serveurs, les boucles de jeux vidéo et les systèmes embarqués utilisent souvent des boucles while True comme structure principale. Remarquez l'utilisation d'une docstring pour documenter la fonction définie avec def.

Comparaison entre while et for

Cas d'utilisation avancés

Algorithme de recherche dichotomique

La boucle while est idéale pour implémenter des algorithmes dont le nombre d'itérations n'est pas connu à l'avance :

def recherche_dichotomique(liste_triee, cible):
    """Recherche un élément dans une liste triée."""
    gauche = 0
    droite = len(liste_triee) - 1

    while gauche <= droite:
        milieu = (gauche + droite) // 2
        valeur = liste_triee[milieu]

        if valeur == cible:
            return milieu
        elif valeur < cible:
            gauche = milieu + 1
        else:
            droite = milieu - 1

    return -1  # Élément non trouvé

# Utilisation
nombres = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
resultat = recherche_dichotomique(nombres, 23)
print(f"Élément trouvé à l'index : {resultat}")  # Affiche : 5

Lecture de données avec sentinelle

Le schéma de la sentinelle utilise une valeur spéciale pour signaler la fin de la saisie :

notes = []
note = input("Entrez une note (ou 'fin' pour terminer) : ")

while note != "fin":
    try:
        notes.append(float(note))
    except ValueError:
        print("Valeur invalide, veuillez entrer un nombre.")
    note = input("Entrez une note (ou 'fin' pour terminer) : ")

if notes:
    moyenne = sum(notes) / len(notes)
    print(f"Moyenne des {len(notes)} notes : {moyenne:.2f}")
else:
    print("Aucune note saisie.")

Boucles imbriquées

Vous pouvez imbriquer des boucles while pour travailler avec des structures à plusieurs dimensions :

lignes = 5
i = 1

while i <= lignes:
    j = 1
    while j <= i:
        print("*", end=" ")
        j += 1
    print()  # Retour à la ligne
    i += 1

# Affiche :
# *
# * *
# * * *
# * * * *
# * * * * *

Bonnes pratiques

Voici les bonnes pratiques essentielles pour utiliser la boucle while efficacement en Python :

1. Assurez-vous que la condition évoluera : vérifiez que la variable testée dans la condition est modifiée à chaque itération pour éviter les boucles infinies.
2. Initialisez vos variables avant la boucle : déclarez et initialisez toute variable utilisée dans la condition avant la boucle while.
3. Préférez for quand c'est possible : si vous itérez sur une séquence connue, une boucle for est plus lisible et moins sujette aux erreurs.
4. Utilisez break avec parcimonie : un break par boucle est raisonnable, mais plusieurs break rendent le code difficile à suivre.
5. Ajoutez des commentaire explicatifs : commentez la logique de vos boucles complexes pour améliorer la maintenabilité.
6. Limitez la profondeur d'imbrication : si vous avez plus de deux niveaux d'imbrication, envisagez de refactoriser avec des fonctions dédiées.
7. Pensez aux performances : dans une boucle while, évitez les opérations coûteuses inutiles qui seraient répétées à chaque itération.

# ❌ Mauvaise pratique
x = 10
while x > 0:
    print(x)  # x ne change jamais → boucle infinie

# ✅ Bonne pratique
x = 10
while x > 0:
    print(x)
    x -= 1  # x est décrémenté → la boucle s'arrêtera

Questions fréquentes

La boucle for est conçue pour itérer sur des séquences (list, tuple, dict, chaînes de caractères, etc.) dont la taille est connue. La boucle while est utilisée quand le nombre d'itérations dépend d'une condition dynamique qui peut évoluer à chaque itération. En pratique, si vous connaissez à l'avance le nombre de répétitions ou si vous parcourez une collection, utilisez for. Si vous attendez un événement ou une condition particulière, utilisez while.

Pour éviter une boucle infinie, assurez-vous que la condition de la boucle while sera éventuellement évaluée à False. Cela implique que la ou les variables utilisées dans la condition soient modifiées à l'intérieur du bloc de la boucle. Vous pouvez aussi utiliser un compteur de sécurité (par exemple max_iterations) pour limiter le nombre de tours, ou utiliser l'instruction break pour sortir de la boucle sous certaines conditions.

Oui, c'est une fonctionnalité propre à Python. La clause else après un while est exécutée quand la condition de la boucle devient False naturellement. En revanche, si la boucle est interrompue par un break, le bloc else est ignoré. Cela est très utile pour les algorithmes de recherche où le else gère le cas « élément non trouvé ».

Pour maîtriser la boucle while et l'ensemble du langage Python, la pratique régulière est essentielle. Commencez par des exercices simples (compteurs, saisies utilisateur) puis progressez vers des algorithmes plus complexes. Nous vous recommandons de suivre notre formation dédiée à Python sur Believemy, qui propose des exercices progressifs et des projets concrets pour vous accompagner de débutant à avancé.