Instructions break et continue : contrôler le flux des boucles

L'instruction break : interrompre une boucle prématurément

L'instruction `break` permet d'interrompre l'exécution d'une boucle (`for` ou `while`) avant qu'elle n'ait parcouru tous les éléments (pour une boucle `for`) ou que la condition ne devienne fausse (pour une boucle `while`).

Lorsque l'instruction `break` est rencontrée, l'exécution sort immédiatement de la boucle et se poursuit avec l'instruction qui suit la boucle (s'il y en a une).

Exemple avec une boucle `for` :

nombres = [1, 3, 5, 6, 7, 9]

for n in nombres:
    if n % 2 == 0:
        print("Le premier nombre pair trouvé est :", n)
        break  # Interrompt la boucle dès qu'un nombre pair est trouvé
else:
    print("Aucun nombre pair trouvé dans la liste.")

Dans cet exemple, la boucle s'arrête dès que le nombre 6 est rencontré. Le message "Aucun nombre pair trouvé dans la liste." ne s'affichera pas, car la boucle ne s'est pas terminée "naturellement".

Exemple avec une boucle `while` :

compteur = 0
while compteur < 10:
    if compteur == 5:
        break  # Interrompt la boucle lorsque compteur vaut 5
    print(compteur)
    compteur += 1

L'instruction `break` est souvent utilisée pour sortir d'une boucle lorsqu'une condition particulière est remplie, ou pour éviter une boucle infinie.

L'instruction continue : passer à l'itération suivante

L'instruction `continue` permet de passer à l'itération suivante d'une boucle (`for` ou `while`) sans exécuter le reste du bloc de code de l'itération courante.

Lorsque l'instruction `continue` est rencontrée, l'exécution saute directement au début de la boucle pour l'itération suivante. Pour une boucle `for`, cela signifie passer à l'élément suivant de la séquence. Pour une boucle `while`, cela signifie réévaluer la condition.

Exemple avec une boucle `for` :

nombres = [1, 2, 3, 4, 5, 6]

for n in nombres:
    if n % 2 == 0:
        continue  # Passe à l'itération suivante si n est pair
    print("Nombre impair :", n)

Dans cet exemple, seuls les nombres impairs sont affichés. Lorsque `n` est pair, l'instruction `continue` est exécutée et l'instruction `print()` est ignorée.

Exemple avec une boucle `while` :

compteur = 0
while compteur < 10:
    compteur += 1
    if compteur % 3 == 0:
        continue  # Passe à l'itération suivante si compteur est un multiple de 3
    print(compteur)

Dans cet exemple, la boucle `while` incrémente `compteur` à chaque passage. Cependant, grâce à l'instruction `continue`, les multiples de 3 ne sont pas affichés.

L'instruction `continue` est souvent utilisée pour ignorer certains éléments d'une séquence ou pour éviter d'exécuter du code dans des cas particuliers.

Utilisations combinées de break et continue : exemples

Il est possible de combiner les instructions `break` et `continue` dans une même boucle pour un contrôle plus fin du flux d'exécution.

Exemple :

nombres = [1, 2, -3, 4, -5, 6, 7, 8, -9, 10]

somme_positifs = 0

for n in nombres:
    if n < 0:
        continue  # Ignore les nombres négatifs
    if somme_positifs > 20:
        break  # Interrompt la boucle si la somme dépasse 20
    somme_positifs += n

print("La somme des nombres positifs (jusqu'à 20) est :", somme_positifs)

Dans cet exemple, la boucle `for` parcourt une liste de nombres. Si un nombre est négatif, il est ignoré (`continue`). Sinon, il est ajouté à la somme. La boucle est interrompue (`break`) si la somme dépasse 20.

Un autre exemple, cette fois-ci avec une boucle `while` et une combinaison des instructions.

while True: # Boucle infinie (attention !)
    reponse = input("Entrez un nombre entre 1 et 10 (ou 'stop' pour quitter) : ")

    if reponse.lower() == 'stop':
        break  # Sort de la boucle si l'utilisateur entre 'stop'

    try:
        nombre = int(reponse)
    except ValueError:
        print("Entrée invalide. Veuillez entrer un nombre ou 'stop'.")
        continue  # Retourne au début de la boucle

    if nombre < 1 or nombre > 10:
        print("Le nombre doit être compris entre 1 et 10.")
        continue  # Retourne au début de la boucle

    print("Vous avez entré :", nombre)
    break # Sort de la boucle car on a un nombre valide

Bonnes pratiques et pièges à éviter

Voici quelques bonnes pratiques et pièges à éviter lors de l'utilisation de `break` et `continue` :

• Utilisez `break` et `continue` avec parcimonie : Un usage excessif de ces instructions peut rendre le code difficile à suivre et à comprendre. Dans de nombreux cas, il est possible d'obtenir le même résultat avec une structure de boucle plus claire.
• Evitez les boucles infinies involontaires : Assurez-vous que la condition de votre boucle `while` deviendra fausse à un moment donné, ou que vous avez une instruction `break` pour sortir de la boucle.
• Documentez l'utilisation de `break` et `continue` : Si vous utilisez ces instructions de manière non triviale, ajoutez des commentaires pour expliquer pourquoi vous les utilisez et comment elles affectent le flux d'exécution.
• Préférez des alternatives plus claires si possible : Parfois, l'utilisation de `break` ou `continue` peut être évitée en restructurant la boucle ou en utilisant des fonctions auxiliaires.
• Testez soigneusement votre code : Assurez-vous que votre boucle se comporte comme prévu, en particulier dans les cas où `break` et `continue` sont utilisés.

En suivant ces conseils, vous utiliserez `break` et `continue` de manière efficace et judicieuse, pour rendre votre code plus clair et plus facile à maintenir.