11. Répéter des actions avec les boucles while

Les programmes ont souvent besoin de répéter des actions plusieurs fois. Vous avez déjà vu comment prendre des décisions avec des instructions if au chapitre 8, mais que faire si vous devez effectuer une action de façon répétée jusqu’à ce qu’une certaine condition soit remplie ? C’est là qu’interviennent les boucles.

Python fournit deux principaux types de boucles : les boucles while et les boucles for. Dans ce chapitre, nous nous concentrerons sur les boucles while, qui répètent un bloc de code tant qu’une condition reste vraie. La boucle for, mieux adaptée pour itérer sur des séquences, sera abordée au chapitre 12.

Comprendre les boucles while est fondamental pour écrire des programmes capables de traiter des données de manière répétée, de valider des entrées utilisateur, d’implémenter des boucles de jeu, et de gérer de nombreux autres scénarios de programmation du monde réel.

11.1) La structure d’une boucle while

Une boucle while exécute de manière répétée un bloc de code tant qu’une condition spécifiée s’évalue à True. Une fois que la condition devient False, la boucle s’arrête, et le programme continue avec le code situé après la boucle.

Syntaxe de base d’une boucle while

La structure d’une boucle while ressemble à ceci :

while condition:
    # Bloc de code à répéter
    # Ce code s’exécute tant que condition est True

La condition est toute expression qui s’évalue à une valeur booléenne (ou peut être interprétée comme truthy ou falsy, comme nous l’avons appris au chapitre 7). Le bloc de code indenté sous l’instruction while est appelé le corps de la boucle, et il s’exécute de façon répétée tant que la condition reste True.

Voyons un exemple simple :

# Compter de 1 à 5
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count = count + 1  # Incrémenter count
print("Loop finished!")

Output:

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5
Loop finished!

Comment cela fonctionne étape par étape :

1. Nous initialisons count à 1
2. La condition count <= 5 est vérifiée. Comme 1 <= 5 vaut True, le corps de la boucle s’exécute
3. À l’intérieur de la boucle, nous affichons le compteur actuel puis nous l’incrémentons de 1
4. Une fois le corps de la boucle terminé, Python revient à l’instruction while et vérifie à nouveau la condition
5. Ce processus se répète jusqu’à ce que count devienne 6, moment où 6 <= 5 vaut False, et la boucle se termine
6. Le programme continue avec le code après la boucle

L’idée clé est que la condition est vérifiée avant chaque itération (chaque répétition du corps de la boucle). Si la condition est False au départ, le corps de la boucle ne s’exécute jamais :

count = 10
while count <= 5:
    print("This will never print")
print("Loop skipped entirely")

Output:

Loop skipped entirely

Comme 10 <= 5 vaut False dès le début, le corps de la boucle ne s’exécute jamais.

L’importance de modifier la variable de boucle

Pour qu’une boucle while finisse par s’arrêter, quelque chose dans la boucle doit faire passer la condition de True à False. Cela signifie généralement modifier la/les variable(s) utilisée(s) dans la condition. Si vous oubliez de le faire, vous créez une boucle infinie (que nous examinerons en détail dans la section suivante).

Voici un exemple qui montre pourquoi la mise à jour de la variable de boucle est importante :

# Calculer la somme des nombres de 1 à 10
total = 0
number = 1
 
while number <= 10:
    total = total + number  # Ajouter le nombre courant à total
    number = number + 1     # Passer au nombre suivant
 
print(f"The sum of numbers from 1 to 10 is: {total}")

Output:

The sum of numbers from 1 to 10 is: 55

Dans cet exemple, nous cumulons une somme tout en progressant à travers les nombres. total et number changent tous deux à chaque itération, mais c’est la modification de number qui garantit que la boucle se termine finalement lorsque number devient 11.

Boucles while avec saisie utilisateur

Une utilisation pratique des boucles while consiste à traiter une saisie utilisateur jusqu’à ce qu’une condition spécifique soit remplie. Créons un petit jeu de devinette :

# Petit jeu de devinette de nombres
secret_number = 7
guess = 0
 
while guess != secret_number:
    guess = int(input("Guess the number (1-10): "))
    
    if guess < secret_number:
        print("Too low! Try again.")
    elif guess > secret_number:
        print("Too high! Try again.")
    else:
        print("Correct! You guessed it!")

Cette boucle continue de demander des propositions jusqu’à ce que l’utilisateur saisisse le bon nombre. Chaque itération traite une proposition et fournit un retour. La boucle se termine naturellement lorsque guess est égal à secret_number, ce qui fait que la condition guess != secret_number devient False.

Boucles while avec conditions multiples

Vous pouvez utiliser des opérateurs booléens (and, or, not) pour créer des conditions de boucle plus complexes, comme nous l’avons appris au chapitre 9 :

# Traiter la saisie jusqu’à ce que l’utilisateur entre "quit" ou atteigne 5 tentatives
attempts = 0
user_input = ""
 
while user_input != "quit" and attempts < 5:
    user_input = input("Enter a command (or 'quit' to exit): ")
    attempts += 1
    
    if user_input == "quit":
        print("Goodbye!")
    else:
        print(f"You entered: {user_input}")
        print(f"Attempts remaining: {5 - attempts}")
 
if attempts >= 5 and user_input != "quit":
    print("Maximum attempts reached.")

Cette boucle continue tant que les deux conditions sont vraies : l’utilisateur n’a pas entré "quit" et il n’a pas dépassé 5 tentatives. La boucle se termine lorsque l’une des conditions devient fausse.

Visualiser l’exécution d’une boucle while

Voici un organigramme montrant comment une boucle while s’exécute :

La boucle crée un cycle où la condition est vérifiée, le corps s’exécute si la condition est vraie, les variables sont mises à jour, puis la condition est vérifiée à nouveau. Ce cycle continue jusqu’à ce que la condition devienne fausse.

11.2) Les boucles infinies et comment les éviter

Une boucle infinie est une boucle qui ne se termine jamais parce que sa condition ne devient jamais False. Les boucles infinies figurent parmi les erreurs les plus fréquentes que les débutants commettent avec les boucles while, et elles peuvent faire bloquer votre programme indéfiniment.

Qu’est-ce qui provoque des boucles infinies ?

La cause la plus courante des boucles infinies est d’oublier de modifier la/les variable(s) qui influencent la condition de boucle. Regardons un exemple problématique :

# AVERTISSEMENT : boucle infinie - pour démonstration uniquement
# PROBLÈME : count n’est jamais modifié
count = 1
while count <= 5:
    print(f"Count is: {count}")
    # Missing: count += 1

Si vous exécutiez ce code, il afficherait "Count is: 1" pour toujours parce que count reste à 1, et 1 <= 5 vaut toujours True. La condition ne change jamais.

Comment reconnaître qu’il s’agit d’une boucle infinie : Regardez la condition de boucle (count <= 5), puis vérifiez si quelque chose à l’intérieur du corps de la boucle modifie count. Si ce n’est pas le cas, et que la condition démarre à True, vous avez une boucle infinie.

Voici la version corrigée :

# Version correcte avec incrémentation appropriée
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count += 1  # Cela garantit que la boucle finit par se terminer

Output:

Count is: 1
Count is: 2
Count is: 3
Count is: 4
Count is: 5

Déboguer des boucles infinies avec des limites de sécurité

Lorsque vous développez du code avec des boucles, il est utile d’ajouter une limite de sécurité pour éviter des boucles infinies accidentelles pendant les tests :

# Limite de sécurité pendant le développement
count = 1
iterations = 0
max_iterations = 100  # Limite de sécurité
 
while count <= 5 and iterations < max_iterations:
    print(f"Count is: {count}")
    count += 1
    iterations += 1
 
if iterations >= max_iterations:
    print("WARNING: Maximum iterations reached. Check for infinite loop.")

Ce motif ajoute un compteur qui suit combien de fois la boucle s’est exécutée. S’il atteint la limite de sécurité, vous savez que quelque chose ne va pas dans la logique de votre boucle. Une fois que vous êtes sûr que votre boucle fonctionne correctement, vous pouvez supprimer la limite de sécurité.

Boucles infinies avec saisie utilisateur

Un autre scénario courant de boucles infinies implique la validation de saisie utilisateur :

# AVERTISSEMENT : boucle potentiellement infinie - pour démonstration uniquement
# PROBLÈME : si l’utilisateur ne saisit jamais une entrée valide, la boucle ne se termine jamais
age = -1
while age < 0:
    age = int(input("Enter your age: "))
    # Si l’utilisateur saisit un nombre négatif, la boucle continue

Cette boucle fonctionne correctement si l’utilisateur finit par entrer un nombre non négatif, mais elle devient une boucle infinie si l’utilisateur continue d’entrer des valeurs négatives. Même si cela peut être acceptable pour certains programmes (vous voulez continuer à demander jusqu’à recevoir une saisie valide), il est important de comprendre que la fin de la boucle dépend entièrement du comportement de l’utilisateur.

Une approche plus robuste peut inclure un moyen de quitter :

# Meilleure approche avec option de sortie
age = -1
while age < 0:
    user_input = input("Enter your age (or 'quit' to exit): ")
    
    if user_input.lower() == 'quit':
        print("Exiting program.")
        age = 0  # Définir une valeur valide pour sortir de la boucle
    else:
        age = int(user_input)
        if age < 0:
            print("Age must be non-negative. Please try again.")
 
if age > 0:
    print(f"Your age is: {age}")

Boucles infinies dues à des erreurs logiques

Parfois, les boucles infinies surviennent en raison d’erreurs logiques dans la façon dont vous mettez à jour les variables :

# AVERTISSEMENT : boucle infinie - pour démonstration uniquement
# PROBLÈME : count est décrémenté au lieu d’être incrémenté
count = 1
while count <= 5:
    print(f"Count is: {count}")
    count -= 1  # ERREUR : cela rend count plus petit, pas plus grand

Cela crée une boucle infinie parce que count commence à 1 et devient 0, -1, -2, etc. Comme les nombres négatifs sont toujours inférieurs ou égaux à 5, la condition count <= 5 reste True pour toujours.

La version corrigée :

count = 1
while count <= 5:
    print(f"Count is: {count}")
    count += 1  # Correct : incrémenter pour finir par dépasser 5

Déboguer des boucles infinies

Si vous créez accidentellement une boucle infinie en exécutant un script Python, vous pouvez l’arrêter en appuyant sur Ctrl+C (ou Cmd+C sur Mac) dans votre terminal. Cela envoie un signal d’interruption clavier à Python, ce qui arrête le programme.

Comment éviter les boucles infinies :

1. Assurez-vous toujours que la condition de boucle peut devenir False : vérifiez que les variables de la condition sont modifiées dans la boucle
2. Utilisez le bon opérateur de comparaison : assurez-vous que <=, <, !=, etc., correspondent à votre intention
3. Testez d’abord avec de petites valeurs : avant d’exécuter une boucle susceptible de tourner un grand nombre de fois, testez avec de petites limites
4. Ajoutez des instructions print de débogage : affichez temporairement la variable de boucle pour voir comment elle change :
5. Utilisez des limites de sécurité pendant le développement : comme montré plus haut, ajoutez un compteur d’itérations maximum lors des tests

11.3) Utiliser break et continue dans les boucles while

Python fournit deux instructions spéciales qui vous donnent davantage de contrôle sur l’exécution des boucles : break et continue. Ces instructions vous permettent de modifier le déroulement normal d’une boucle en fonction de conditions qui apparaissent pendant l’exécution.

11.3.1) L’instruction break

L’instruction break termine immédiatement la boucle, quelle que soit la condition de boucle. Lorsque Python rencontre break, il sort entièrement de la boucle et continue avec le code après la boucle.

Voici un exemple simple :

# Quitter la boucle lorsqu’une valeur spécifique est atteinte
count = 1
while count <= 10:
    if count == 5:
        print("Reached 5, stopping loop")
        break
    print(f"Count: {count}")
    count += 1
 
print("Loop exited")

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Reached 5, stopping loop
Loop exited

Notez qu’une fois que count est égal à 5, l’instruction break s’exécute, et la boucle se termine immédiatement. La boucle n’atteint jamais count = 6 même si la condition count <= 10 serait encore True.

Comment break change le flux d’une boucle

Comprendre comment break modifie l’exécution normale d’une boucle est crucial. Voici un organigramme montrant la différence :

Le point clé : break fournit un chemin de sortie immédiat de la boucle, en contournant à la fois le reste du code du corps de la boucle et la vérification de la condition.

Utilisation pratique de break : validation de saisie

L’une des utilisations les plus courantes de break est de sortir d’une boucle lorsqu’une saisie valide est reçue :

# Continuer à demander une saisie valide jusqu’à l’obtenir
while True:
    age_input = input("Enter your age (must be positive): ")
    
    # Essayer de convertir en entier
    try:
        age = int(age_input)
        
        # Vérifier si c’est valide
        if age > 0:
            print(f"Thank you! Your age is {age}")
            break  # Sortir de la boucle si la saisie est valide
        else:
            print("Age must be positive. Please try again.")
    except ValueError:
        print("That's not a valid number. Please try again.")
 
print("Input validation complete")

Ce motif utilise while True: pour créer une boucle infinie intentionnelle, puis utilise break pour sortir lorsque la saisie valide est reçue. C’est plus propre que d’essayer de gérer une condition de boucle complexe. (Remarque : nous utilisons try et except ici, que nous apprendrons en détail dans la partie VII. Pour l’instant, comprenez simplement que cela intercepte les erreurs lors de la conversion de la saisie en entier.)

break avec conditions multiples

Vous pouvez utiliser break avec des conditions complexes pour sortir d’une boucle lorsque l’un de plusieurs critères est rempli :

# Rechercher un élément spécifique dans la saisie utilisateur
search_term = "python"
attempts = 0
max_attempts = 5
 
while attempts < max_attempts:
    user_input = input("Enter a word (or 'quit' to exit): ").lower()
    attempts += 1
    
    if user_input == 'quit':
        print("User requested exit")
        break
    
    if user_input == search_term:
        print(f"Found '{search_term}'!")
        break
    
    print(f"'{user_input}' is not '{search_term}'. Try again.")
    print(f"Attempts remaining: {max_attempts - attempts}")
 
if attempts >= max_attempts:
    print("Maximum attempts reached")

Cette boucle peut se terminer de trois façons :

1. L’utilisateur saisit "quit" (premier break)
2. L’utilisateur saisit le terme recherché (deuxième break)
3. Le nombre maximum de tentatives est atteint (la condition de boucle devient False)

11.3.2) L’instruction continue

L’instruction continue saute le reste de l’itération en cours et revient à la vérification de la condition de boucle. Contrairement à break, qui sort entièrement de la boucle, continue ne fait que passer à l’itération suivante.

Voici un exemple de base :

# Afficher uniquement les nombres impairs de 1 à 10
count = 0
while count < 10:
    count += 1
    
    if count % 2 == 0:  # Si nombre pair
        continue  # Sauter le reste et passer à l’itération suivante
    
    print(f"Odd number: {count}")

Output:

Odd number: 1
Odd number: 3
Odd number: 5
Odd number: 7
Odd number: 9

Comment cela fonctionne :

1. count est incrémenté au début de chaque itération
2. Si count est pair (count % 2 == 0), continue s’exécute
3. L’instruction continue saute l’instruction print et revient à la condition while
4. Si count est impair, continue ne s’exécute pas, donc l’instruction print s’exécute

Comment continue change le flux d’une boucle

Voici un organigramme montrant comment continue affecte l’exécution de la boucle :

La différence cruciale entre break et continue :

• break : sort complètement de la boucle, en sautant au code après la boucle
• continue : saute le code restant dans l’itération en cours, revient à la vérification de la condition

Note importante sur le placement de continue

Remarquez que count += 1 vient avant le continue. Si nous le placions après, les nombres pairs feraient sauter l’incrément, créant une boucle infinie :

# AVERTISSEMENT : boucle infinie - pour démonstration uniquement
# PROBLÈME : continue saute l’incrément pour les nombres pairs
count = 0
while count < 10:
    if count % 2 == 0:
        continue  # Saute tout ce qui est en dessous, y compris count += 1
    count += 1  # ERREUR : ceci ne s’exécute jamais pour les nombres pairs
    print(f"Odd number: {count}")

Quand count vaut 0 (pair), continue s’exécute, sautant count += 1. La boucle vérifie à nouveau 0 < 10, et le cycle se répète pour toujours.

La règle : assurez-vous toujours que les variables de boucle qui influencent la condition sont mises à jour avant toute instruction continue susceptible de sauter le reste du corps de la boucle.

Utilisation pratique de continue : filtrer des données

L’instruction continue est utile lorsque vous traitez des données et que vous souhaitez ignorer certains éléments :

# Traiter uniquement les scores valides
score_count = 0
total_score = 0
attempts = 0
 
while attempts < 5:
    score_input = input(f"Enter score {attempts + 1} (or 'skip' to skip): ")
    attempts += 1
    
    if score_input.lower() == 'skip':
        print("Skipping this score")
        continue  # Passer à l’itération suivante
    
    try:
        score = int(score_input)
        
        if score < 0 or score > 100:
            print("Score must be between 0 and 100. Skipping.")
            continue  # Ignorer les scores invalides
        
        # Score valide - le traiter
        total_score += score
        score_count += 1
        print(f"Score recorded: {score}")
        
    except ValueError:
        print("Invalid input. Skipping.")
        continue
 
if score_count > 0:
    average = total_score / score_count
    print(f"\nAverage of {score_count} valid scores: {average:.1f}")
else:
    print("\nNo valid scores entered")

Cet exemple montre plusieurs usages de continue :

• Ignorer lorsque l’utilisateur saisit "skip"
• Ignorer lorsque le score est hors de la plage valide
• Ignorer lorsque la saisie n’est pas un nombre valide

Chaque continue empêche le score d’être ajouté au total, mais la boucle continue à la tentative suivante.

Combiner break et continue

Vous pouvez utiliser break et continue dans la même boucle pour un contrôle sophistiqué :

# Traiter des nombres jusqu’à ce que la somme dépasse 100, en ignorant les nombres négatifs
total = 0
count = 0
 
while True:
    number_input = input("Enter a number (or 'done' to finish): ")
    
    if number_input.lower() == 'done':
        print("User finished entering numbers")
        break  # Sortir de la boucle
    
    try:
        number = int(number_input)
        
        if number < 0:
            print("Negative numbers not allowed. Skipping.")
            continue  # Passer à l’itération suivante
        
        total += number
        count += 1
        print(f"Added {number}. Current total: {total}")
        
        if total > 100:
            print("Total exceeded 100. Stopping.")
            break  # Sortir de la boucle quand la limite est atteinte
            
    except ValueError:
        print("Invalid input. Skipping.")
        continue
 
print(f"\nFinal total: {total} (from {count} numbers)")

Cette boucle démontre :

• break pour sortir lorsque l’utilisateur tape "done"
• continue pour ignorer les nombres négatifs
• continue pour ignorer une saisie invalide
• break pour sortir lorsque le total dépasse 100

11.4) Utiliser else avec les boucles while

Python a une fonctionnalité unique que beaucoup d’autres langages de programmation n’ont pas : vous pouvez attacher une clause else à une boucle while. Ce bloc else s’exécute uniquement si la boucle se termine normalement (c’est-à-dire que la condition de boucle devient False sans rencontrer d’instruction break).

Syntaxe de base de else avec while

La syntaxe ressemble à ceci :

while condition:
    # Corps de la boucle
else:
    # Ceci s’exécute uniquement si la boucle se termine normalement
    # (non interrompue par break)

Voyons un exemple simple :

# Compter de 1 à 5 avec une clause else
count = 1
while count <= 5:
    print(f"Count: {count}")
    count += 1
else:
    print("Loop completed normally")
 
print("Program continues")

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Loop completed normally
Program continues

Le bloc else s’exécute parce que la boucle a tourné jusqu’à ce que sa condition (count <= 5) devienne False. La boucle s’est terminée « normalement » sans être interrompue.

Quand else ne s’exécute PAS : l’instruction break

Le comportement clé de la clause else est qu’elle ne s’exécute pas si la boucle est terminée par une instruction break :

# Rechercher un nombre avec break
count = 1
target = 3
 
while count <= 5:
    print(f"Checking: {count}")
    if count == target:
        print(f"Found {target}!")
        break
    count += 1
else:
    print("Target not found in range")
 
print("Search complete")

Output:

Checking: 1
Checking: 2
Checking: 3
Found 3!
Search complete

Remarquez que le bloc else ("Target not found in range") ne s’est pas exécuté parce que la boucle a été terminée par break. C’est la distinction cruciale : else s’exécute seulement lorsque la boucle se termine normalement (la condition devient False), pas lorsqu’elle se termine via break.

Voyons maintenant ce qui se passe lorsque la cible n’est pas trouvée :

# Rechercher un nombre qui n’existe pas
count = 1
target = 7  # Pas dans l’intervalle 1-5
 
while count <= 5:
    print(f"Checking: {count}")
    if count == target:
        print(f"Found {target}!")
        break
    count += 1
else:
    print("Target not found in range")
 
print("Search complete")

Output:

Checking: 1
Checking: 2
Checking: 3
Checking: 4
Checking: 5
Target not found in range
Search complete

Cette fois, la boucle a effectué toutes les itérations sans trouver la cible, donc la condition count <= 5 est finalement devenue False, et le bloc else s’est exécuté.

Comment else fonctionne avec la fin de boucle

Voici un organigramme montrant les chemins d’exécution avec la clause else :

Le bloc else n’est atteint que lorsque la condition de boucle devient naturellement False. Si break est rencontré, le flux saute directement le bloc else vers le code après la boucle.

Utilisation pratique : opérations de recherche

La clause else est particulièrement utile pour les opérations de recherche où vous voulez savoir si quelque chose a été trouvé :

# Rechercher un mot de passe valide dans une liste de tentatives
valid_password = "python123"
max_attempts = 3
attempts = 0
 
while attempts < max_attempts:
    password = input(f"Enter password (attempt {attempts + 1}/{max_attempts}): ")
    attempts += 1
    
    if password == valid_password:
        print("Access granted!")
        break
else:
    print("Access denied. Maximum attempts exceeded.")
    print("Account locked.")

Si l’utilisateur saisit le bon mot de passe, break s’exécute et le bloc else est ignoré. Si toutes les tentatives sont utilisées sans succès, la boucle se termine normalement et le bloc else s’exécute, indiquant l’échec.

else avec continue

L’instruction continue n’empêche pas l’exécution du bloc else. Seul break fait cela :

# continue n’affecte pas l’exécution de else
count = 0
while count < 5:
    count += 1
    if count == 3:
        print(f"Skipping {count}")
        continue  # Passer à l’itération suivante
    print(f"Processing {count}")
else:
    print("Loop completed normally (continue doesn't prevent this)")

Output:

Processing 1
Processing 2
Skipping 3
Processing 4
Processing 5
Loop completed normally (continue doesn't prevent this)

Le bloc else s’exécute parce que la boucle s’est terminée normalement. L’instruction continue n’affecte que des itérations individuelles, pas l’achèvement global de la boucle.

Comparer else avec et sans break

Voyons une comparaison côte à côte :

# Exemple 1 : trouver un nombre premier (avec break)
print("Finding first number divisible by 7:")
number = 1
while number <= 20:
    if number % 7 == 0:
        print(f"Found: {number}")
        break
    number += 1
else:
    print("No number divisible by 7 found in range")
print()
 
# Exemple 2 : vérifier tous les nombres (sans break)
print("Checking all numbers for divisibility by 7:")
number = 1
while number <= 20:
    if number % 7 == 0:
        print(f"Found: {number}")
    number += 1
else:
    print("Finished checking all numbers")

Output:

Finding first number divisible by 7:
Found: 7
 
Checking all numbers for divisibility by 7:
Found: 7
Found: 14
Finished checking all numbers

Dans le premier exemple, break arrête la boucle après avoir trouvé la première correspondance, donc else ne s’exécute pas. Dans le second exemple, la boucle vérifie tous les nombres et se termine normalement, donc else s’exécute.

Quand utiliser else avec les boucles while

La clause else est surtout utile lorsque :

1. Opérations de recherche : vous voulez savoir si quelque chose a été trouvé ou non
2. Validation avec un nombre de tentatives limité : vous devez gérer le cas où toutes les tentatives sont épuisées
3. Traitement avec sortie anticipée : vous voulez un comportement différent pour « tout a été traité » vs « arrêt anticipé »

Cependant, else avec les boucles peut être déroutant pour des programmeurs venant d’autres langages (où cette fonctionnalité n’existe pas). Parfois, il est plus clair d’utiliser une variable indicatrice :

# Utiliser la clause else
attempts = 0
while attempts < 3:
    password = input("Enter password: ")
    attempts += 1
    if password == "secret":
        print("Access granted")
        break
else:
    print("Access denied")
 
# Équivalent en utilisant une variable indicatrice (parfois plus clair)
attempts = 0
access_granted = False
while attempts < 3:
    password = input("Enter password: ")
    attempts += 1
    if password == "secret":
        print("Access granted")
        access_granted = True
        break
 
if not access_granted:
    print("Access denied")

Les deux approches fonctionnent. Choisissez celle qui rend votre code plus clair pour votre situation spécifique.

Comprendre else avec les boucles while vous donne un outil supplémentaire pour écrire du code clair et expressif, en particulier dans les scénarios de recherche et de validation où vous devez distinguer entre « trouvé » et « non trouvé » ou « réussite » et « échec après toutes les tentatives ».

Dans ce chapitre, nous avons exploré en profondeur les boucles while, en apprenant à :

• Structurer des boucles qui répètent du code en fonction de conditions
• Éviter les boucles infinies en mettant correctement à jour les variables de boucle
• Utiliser break pour sortir des boucles plus tôt quand c’est nécessaire
• Utiliser continue pour sauter des itérations en fonction de conditions
• Utiliser else pour gérer les cas où les boucles se terminent normalement sans break

Ces outils vous donnent un contrôle puissant sur la répétition dans vos programmes. Dans le prochain chapitre, nous apprendrons les boucles for, qui offrent une manière plus pratique d’itérer sur des séquences comme les chaînes, les listes, et les plages.