Les boucles Tant que (avec `while`)

Ce type de boucle est adapté quand nous ne savons pas à l'avance combien de fois les instructions doivent être répétées.

Exemple 1
Demandons à un utilisateur d'entrer des prénoms et arrêtons-nous quand le prénom est "Bébert". Lisez puis testez ceci dans l'éditeur Python (bug : utilisez plutôt Thonny) :

prenom = "Hubert"           # ou n'importe quel texte autre que "Bébert"
while prenom != "Bébert":   # tant que le prenom n'est pas "Bébert"
    prenom = input()        # demander à l'utilisateur un autre prénom
    print("Bonjour", prenom)
print("Ah non, pas Bébert !")

La boucle se lit ici : tant que la variable prenom ne contient pas la valeur "Bébert", demander (input) une nouvelle valeur, l'affecter à prenom et afficher "Bonjour" suivi de la valeur entrée.

La boucle Tant que (while) exécute des instructions tant qu'une condition est vérifiée.

A propos de la condition

Une condition de while s'écrit comme une condition de if.

La condition doit comporter un élément variable (une variable ou résultat d'une fonction faisant appel au hasard ou...). En effet, observez que :

    while 1 < 2:
        ...

comme 1 < 2 est toujours vrai, cette boucle ne s'arrêtera jamais (boucle infinie).

    while 1 == 2:
        ...

comme 1 == 2 est toujours faux, cette boucle ne s'exécutera pas et donc ne sert à rien.

    while a > 2:
        ...

ici la boucle sera exécutée tant que a > 2.

Il faut bien sûr :

que la variable utilisée dans la condition (ici a) ait été définie avant la boucle...
que la condition finisse par être fausse pour sortir de la boucle (ici, il faut que a change de valeur et finisse par être inférieure ou égale à 2).

Exercice 1

Que se passe-t-il :

si vous supprimez la première ligne ?
si vous mettez prenom = "Bébert" à la place de prenom = "Hubert" ?

while est plus fort que for

Il est toujours possible de remplacer une boucle for par une boucle while.

Par exemple :

for n in range(100):
    print("Je ne me laisserai pas aller à la facilité")

peut s'écrire :

nb_copie = 0
while nb_copie < 100:
    print("Je ne me laisserai pas aller à la facilité")
    nb_copie = nb_copie + 1

L'inverse n'est pas vrai, il suffit de réfléchir à l'exemple 1 ci-dessus, non réalisable avec un for (nous ne savons pas combien de prénoms l'utilisateur va entrer avant d'entrer "Bébert"...). On dit que la boucle for est une boucle bornée et que la boucle while est une boucle non bornée.

Il est fréquent d'utiliser une variable qui va permettre à la boucle de s'interrompre mais d'autres variables peuvent apparaître comme accumulateurs, comme dans l'exemple suivant :

Exemple 2

Faisons une division entière avec des soustractions ; par exemple combien y a-t-il de 7 dans 61 ? L'idée est ici de retirer des 7 du nombre 61 tant que c'est possible (tant que le résultat dépasse 7).

nb_sept = 0
nombre = 61
reste = nombre
while reste >= 7:              # je peux encore retirer un 7
    nb_sept = nb_sept + 1       # ou nb_sept += 1
    reste = reste - 7         # je retire un 7 du reste
print("Il y a", nb_sept, "sept dans", nombre, "et il reste", reste)

Prenez le temps de regarder comment ce programme fonctionne :

À retenir

La syntaxe générale est :

début du programme
while condition:
    bloc d’instructions à exécuter tant que la condition est vérifiée
suite du programme

graph LR
A[début]-->B{while}
B-->|condition vérifiée| C[instructions dans le while]
B-->|condition non vérifiée| D[suite du programme]
C-->|retour au début du while|B

Remarquez les points communs avec def, if et for :

le : à la fin de la ligne du while ;
le bloc d’instructions à repéter est indenté.

Enfin, remarquez qu'il y a trois points essentiels pour créer une boucle while :

Initialisation(s) : avant la boucle la (ou les) variable(s) utilisée(s) dans la condition doivent être initialisée(s).
Condition : bien la définir. En particulier, il est préférable qu'elle devienne fausse à un certain moment !
Modification(s) : la (ou les) variable(s) utilisée(s) dans la condition doivent être modifiée(s) (sans quoi, la boucle sera infinie).

Les commandes break et continue

La commande break permet de sortir définitivement d'une boucle. En général, il est conseillé de se passer de cette commande mais elle peut servir dans de rares occasions.

Exemple d'utilisation (non pertinente):

n = 0
while True:     # boucle infinie
    if n == 10:
        break   # sortir de la boucle quand n vaut 10
    n = n + 1   # instruction non exécutée si n vaut 10
print("n vaut", n)

La commande continue permet de sortir de l'itération actuelle et de passer à l'itération suivante. Testez l'exemple suivant :

n = 0
while n < 10:
    n = n + 1
    if n == 5:
        continue   # passer à l'itération suivante si n vaut 5
    print("n vaut", n)  # instruction non exécutée si n vaut 5

Petite remarque au passage : vous avez vu que la dernière ligne dit que n vaut 10, c'est pourquoi il n'y a plus d'autre itération.

Exercices

Exercices 2 et 3 : lecture et compréhension d'un script.

Exercice 4 : température de l'eau.

Exercice 5 : population, variante de l'exercice 3.

Exercice 6 : jeu : trouver un nombre secret.

Exercice 7

Si vous avez fini les cinq exercices ci-dessus : multiplication "russe".

Les boucles Tant que (avec while)

Les boucles Tant que (avec `while`)