La boucle while et les instructions break et continue

L'instruction match / case La boucle for

Accès rapide :
La vidéo
Rappels sur l'instruction while
Utilisation de l'instruction break dans une boucle while
Utilisation de l'instruction continue dans une boucle while
Travaux pratiques
Les énoncés
Les corrections

La vidéo

Cette vidéo vous montre comment utiliser une boucle while Python et comment utiliser les instructions break et continue pour contrôler le comportement de cette boucle.

Rappels sur l'instruction while

Dans les faits, cela fait déjà quelques temps que je vous parle de l'instruction while : pour autant, je voulais quand même lui consacrer un chapitre et compléter nos connaissances sur certaines possibilités utilisables au sein d'une boucle. Donc, allons-y !

La boucle while en Python est une instruction fondamentale pour exécuter un bloc de code de manière répétée aussi longtemps qu'une condition donnée est vraie. La syntaxe de base de la boucle while commence par le mot-clé while, suivi de la condition à tester. Si cette condition est vraie (évaluée à True), le bloc de code indenté sous la déclaration while est exécuté. Après chaque exécution du bloc, la condition est à nouveau évaluée. Ce processus se répète jusqu'à ce que la condition devienne False, moment auquel la boucle se termine et l'exécution du programme continue avec les instructions suivant la boucle.

Typiquement, la boucle while est utilisée quand le nombre d'itérations (de tours de boucle) n'est pas connu à l'avance, par exemple, en lisant des données jusqu'à ce qu'une certaine condition soit remplie, ou en attendant qu'un certain événement se produise. Voici un exemple de code.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 

import os

print("Welcome to SuperShell V1.0")

is_running = True
while is_running:
    cmd = input("Veuillez saisir une commande : ")

    match cmd:
        case "exit":
            is_running = False
        case "ls" | "dir":
            files = os.listdir(".")
            for file in files:
                print(file)
        case cmd if cmd[0:3] == "cd ":
            os.chdir(cmd[3:])
        case _:
            print("Commande", cmd, " inconnue")

print("Bye bye")

Voici un exemple d'exécution de ce programme :

Welcome to SuperShell V1.0
Veuillez saisir une commande : ls
sample.py
Veuillez saisir une commande : toto
Commande toto  inconnue
Veuillez saisir une commande : exit
Bye bye

Avec cette forme de boucle while, il est crucial de s'assurer que la condition puisse devenir False à un moment donné, sans quoi cela peut entraîner une boucle infinie. Dans le cas présent, c'est la saisie de la chaîne exit qui permettra de sortir de la boucle.

Utilisation de l'instruction break dans une boucle while

Le mot-clé break joue un rôle important dans la gestion des boucles while (mais cela marche aussi avec la boucle for) en Python, en fournissant un moyen direct de terminer la boucle indépendamment de sa condition initiale. Lorsque Python rencontre un break à l'intérieur d'une boucle, il interrompt immédiatement la boucle et passe à la première ligne de code suivant cette dernière.

Cette fonctionnalité est particulièrement utile dans les situations où il est nécessaire d'arrêter la boucle en réponse à une condition spécifique qui peut survenir à tout moment pendant l'exécution de la boucle. Par exemple, dans une boucle qui lit des données d'une source externe, un break peut être utilisé pour sortir de la boucle si des données invalides ou un signal de fin de données sont détectés.

Il n'est pas rare non plus de voir l'instruction break être utilisée conjointement avec une boucle while True:. Comme la condition est toujours vraie, nous avons à faire à une boucle infinie. Pour autant le break permet de casser cette boucle quand une condition, difficile à réaliser directement au niveau du while, sera constatée. Voici un exemple de code pour cette situation.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 

import os

print("Welcome to SuperShell V1.0")

while True:
    # La saisie étant faite dans la boucle, on simplifie la condition
    cmd = input("Veuillez saisir une commande : ")

    match cmd:
        case "exit":
            break        # exit => On casse la boucle
        case "ls" | "dir":
            files = os.listdir(".")
            for file in files:
                print(file)
        case cmd if cmd[0:3] == "cd ":
            os.chdir(cmd[3:])
        case _:
            print("Commande", cmd, " inconnue")

print("Bye bye")

Voici un exemple de code qui permet d'analyser un tableau en deux dimensions et qui arrête sa recherche si un zéro est trouvé dans le tableau.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 

matrix = [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 0, 15],
    [16, 17, 18, 19, 20],
    [21, 22, 23, 24, 25]
]

line = 0
zero_is_found = False

while line < 5:
    column = 0
    while column < 5:
        if matrix[line][column] == 0:
            zero_is_found = True
            break         # On casse la boucle interne
        else:
            print(matrix[line][column])
            column += 1
    if zero_is_found:
        break             # On casse la boucle externe
    line += 1

if zero_is_found:
    # N'oubliez pas que les indices commencent à zéro
    print(f"Arrêt à ({line}, {column}) : un zéro a été trouvé.")

Utilisation de l'instruction continue dans une boucle while

Dans une certaine mesure, l'instruction continue ressemble à l'instruction break. La différence, c'est que continue ne stoppe pas complètement la boucle. Elle stoppe juste le tour de boucle courant et passe au prochain tour de boucle. Par exemple, si vous voulez analyser un fichier et passer toutes les lignes commençant par un caractère # : voici un exemple de code réalisant cette tâche.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 

# On ouvre un fichier texte en lecture
with open("file.txt", "r") as file:
    # Le fichier possède plusieurs lignes : on a besoin d'une boucle.
    while True:
        # On lit la ligne courant (avec le retour à la ligne compris).
        current_line = file.readline()
        # A-t-on finit de lire le fichier ? 
        if current_line == "":   # Une ligne vide au milieu vaut "\n" et pas chaine vide.
            break                # Si oui, on stoppe la boucle.
        # A-t-on à faire à une ligne de commentaire
        if current_line[0] == "#":
            continue             # Si oui ou la passe et on continue la lecture du fichier.
        # On traite la ligne courante (ici un affichage)
        print(current_line, end="")   # La ligne possède déjà un \n => end=""

Cet autre exemple permet de demander à l'utilisateur de saisir cinq entiers au travers d'une boucle. Si la saisie n'est pas validée comme étant un entier alors on redemande une saisie, mais sans incrémenter le compteur d'entiers correctement renseignés.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 

counter = 0
while counter < 5:
    str_value = input("Veuillez saisir un entier : ")
    if str_value.isdigit():
        value = int(str_value)
    else: 
        print("On t'a dit un entier, boulet !!!")
        # La saisie n'est pas bonne : on recommence la saisie !
        continue         

    print("On affiche ", value)
    counter += 1

print("Bye bye")

Travaux pratiques

Les énoncés

Exercice 1 : coder un programme qui affiche les tables de multiplications de 1 à 10 en utilisant deux boucles while.

Exercice 2 : vous devez coder un petit jeu dont l'objectif est de retrouver une valeur entière comprise entre 1 et 100 et tirée au hasard par le programme. Une fois la valeur trouvée, vous devez afficher le nombre de tentatives nécessaires pour trouver la bonne valeur et vous devez demander à l'utilisateur s'il veut recommencer une partie. Voici un exemple d'utilisation de notre jeu.

Veuillez saisir une valeur (1..100) : 50
La valeur à trouver est plus grande !
Veuillez saisir une valeur (1..100) : 75
La valeur à trouver est plus petite !
Veuillez saisir une valeur (1..100) : 62
La valeur à trouver est plus petite !
Veuillez saisir une valeur (1..100) : 56
La valeur à trouver est plus petite !
Veuillez saisir une valeur (1..100) : 53
La valeur à trouver est plus grande !
Veuillez saisir une valeur (1..100) : 54
La valeur à trouver est plus grande !
Veuillez saisir une valeur (1..100) : 55
Gagne en 7 coup(s) !
Voulez-vous recommencer (oui, non) : oui
Veuillez saisir une valeur (1..100) : 50
La valeur à trouver est plus petite !
Veuillez saisir une valeur (1..100) : 25
La valeur à trouver est plus grande !
Veuillez saisir une valeur (1..100) : 32
Gagne en 3 coup(s) !
Voulez-vous recommencer (oui, non) : non
Bye bye

Il vous est demandé d'écrire le programme en utilisant deux boucles infinies (while True:). Faites aussi en sorte de gérer le cas où le joueur ne renseigne pas une value numérique.

Comme toujours, essayez de faire ces exercices sans regarder directement la correction ci-dessous. ;-)

Les corrections

Exercice 1 : .

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 

i = 1
while i <= 10:
    print(f"Table de multiplication de {i}")

    value = 1
    while value <= 10:
        print(f"{i:2d} x {value:2d} = {i * value:2d}")
        value += 1

    i += 1
    print()     # Un retour à la ligne en chaque table

print("Bye bye")

Et voici les premières lignes affichées par cet exemple (mais bien entendu, toutes les tables sont bien produites).

Table de multiplication de 1
 1 x  1 =  1
 1 x  2 =  2
 1 x  3 =  3
 1 x  4 =  4
 1 x  5 =  5
 1 x  6 =  6
 1 x  7 =  7
 1 x  8 =  8
 1 x  9 =  9
 1 x 10 = 10

Table de multiplication de 2
 2 x  1 =  2
 2 x  2 =  4
 2 x  3 =  6
 2 x  4 =  8
 2 x  5 = 10
 2 x  6 = 12
 2 x  7 = 14
 2 x  8 = 16
 2 x  9 = 18
 2 x 10 = 20
 
 ...

Exercice 2 : voici ma proposition de correction.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 

# Cette ligne permet d'avoir accès à la fonction randint 
# située dans le module random.py
from random import randint

print("Bienvenue sur MegaGame V1.0 :-)")

while True: 
    # On demande un entier aléatoire entre 1 et 100 compris.
    random_value = randint(1, 100)
    # print("Valeur aléatoire choisie :", random_value)
    
    score = 0
    # Tant que l'entier aléatoire n'a pas été trouvé.
    while True:
        # On demande la saisie d'un entier à partir de la console.
        str_value = input("Veuillez saisir une valeur (1..100) : ")
        if str_value.isdigit():
            value = int(str_value)
            score += 1
        else:
            print("On t'a dit un entier, boulet !!!")
            continue

        # On compare l'entier saisi avec la valeur aléatoire.
        if value < random_value:
            print("La valeur à trouver est plus grande !")
        elif value > random_value:
            print("La valeur à trouver est plus petite !")
        else:
            print(f"Gagne en {score} coup(s) !")
            break

    # On demande si l'utilisateur veut une nouvelle partie.
    retry = input("Voulez-vous recommencer (oui, non) : ").lower()
    if  retry == "non":
        break
        
print("Bye bye")

L'instruction match / case La boucle for