5. Les boucles while

08/24/2025 - By 

Retourner à : Python pour débutants

0

Dans ce nouveau chapitre nous allons nous attaquer aux boucles while en Python. Pour cela on va regarder:

  • ce que sont les boucles while
  • comment les utiliser les while en python
  • l’instruction break
  • l’instruction continue

Au cours de ce chapitre, on va implémenter un petit jeu du juste prix en ligne de commande. L’utilisateur devra trouver un nombre entre 1 et 1000, et à chaque fois qu’il entrera un nombre, le programme lui dira si le nombre recherché et plus ou moins grand que la valeur entrée

Définition

Alors une boucle while, qu’est ce que c’est ? Eh bien, une boucle while est une opération qui nous permet de répéter l’exécution d’un bloc de code, temps qu’une condition booléenne est vrai. Pour mieux vous expliquer tout ça, on va prendre pour exemple le jeu du juste prix.

Dans ce jeu on va:

  • générer un nombre au hasard entre 1 et 1000
  • nous allons demander à l’utilisateur de trouver le bon nombre
  • à chaque fois que l’utilisateur entra un nombre qui n’est pas celui recherché, on lui indiquera si le nombre entré est plus petit ou plus grand que le nombre recherché
  • on répète ces étapes jusqu’à ce que l’utilisateur trouve le bon nombre

Comme vous l’avez probablement déjà remarqué, avec les concepts que nous avons vu jusqu’à présent, on ne serait pas capable de créer un tel programme, car nous ne savons pas combien de fois nous devrons demander à l’utilisateur de deviner le nombre en question.

Nous avons donc besoin d’une manière d’indiquer à notre programme qu’il doit s’exécuter autant de fois que nécessaire. Dans notre exemple, on souhaite exécuter notre code, tant que le nombre entré par l’utilisateur ne correspond pas à celui recherché.

Avant de commencer à taper du code, je propose qu’on tape quelques commentaires, qui décrivent ce que notre programme devra faire :

main.py
# 1. Choisir un nombre au hazar
# 2. Tant que l'utilisateur n'as pas trouvé le bon nombre
# 2.1. Demander un nombre à l'utilisateur
# 2.2. Si le nombre est trop petit on va afficher le message "c"est plus"
# 2.3. Si le nombre est trop grand on va afficher le message "c'est moins"
# 3. Féliciter l'utilisateur

Utilisation de l’instruction while

Maintenant que nous savons ce que nous voulons implémenter, on va commencer par la première tâche qui consiste à choisir un nombre au hasard. Pour cela, il y a une librairie Python que nous allons pouvoir utiliser.

On n’a pas encore parlé de librairies et on n’a pas encore vu comment les importer, donc si ce concept vous est étranger, contentez-vous de copier l’import que je vais faire, et la ligne où je génère le nombre aléatoire, et on reviendra dessus en détail dans un autre chapitre.

Comme je le disais, la première chose qu’on doit faire pour pouvoir utiliser cette librairie qui va générer notre nombtre aléatoire, est de l’importer. Pour cela, tout en haut de notre fichier Python, on va ajouter un“import random”, et ensuite, on pourra générer des nombres aléatoires en utilisation la méthode random.randint :

main.py
import random

number_to_guess = random.randint(1, 1000)

La fonction randint prend deux paramètres: le premier est la limite inférieure des nombres qu’on souhaite générer, et le deuxième paramètre est la limite supérieure. Donc ici, on va générer un nombre aléatoire entre 1 et 1000. Si on imprime la variable “number_to_guess”,, et qu’on lance le programme plusieurs fois, on voit bien qu’à chaque exécution, on a un autre nombre entre 1 et 1000.

Maintenant qu’on a stocké le nombre que l’utilisateur doit trouver, il nous faut une variable qui va contenir la valeur que l’utilisateur va estimer; appelons-la “guess”,. Pour commencer, assignons lui la valeur -1, qui n’est pas inclue entre 1 et 1000:

main.py
import random

number_to_guess = random.randint(1, 1000)
guess = -1

Implémentons maintenant notre boucle. Dans notre commentaire, on a écrit la phrase “Tant que l’utilisateur n’as pas trouvé le bon nombre”,, ce qui est donc équivalent à dire “Tant que guess est différent de number_to_guess”,. En anglais, on pourrait traduire cette phrase par “While guess is different than number_to_guess”,. Et en Python, on aura quelque chose de très similaire: “while guess != number_to_guess:”, suivi du bloc de code qu’on va exécuter tant que cette condition est vraie.

Remplaçons maintenant nos commentaires par du code valide:

main.py
import random

number_to_guess = random.randint(1, 1000)
guess = -1

while guess != number_to_guess:
    guess = int(input("Entrez un nombre entre 1 et 1000: "))
    if guess < number_to_guess:
        print("C'est plus")
    elif guess > number_to_guess:
        print("C'est moins")

print(f"Bravo vous avez trouvé le nombre {number_to_guess} !")

Et voilà, nous pouvons maintenant tester notre programme :

L’instruction break

J’aimerais encore vous montrer une autre chose, il y a un moyen de demander à l’interpréteur Python de sortir d’une boucle même si la condition de la boucle est remplie. L’instruction en question est l’instruction break. Pour illustrer le fonctionnement de break, je propose qu’on donne la possibilité à notre utilisateur d’abandonner la partie à tout moment en tapant la lettre “q“, au lieu d’un nombre.

Pour implémenter cela, on va d’abord devoir modifier notre code afin de ne plus convertir directement notre input en nombre. Au lieu de cela, on va tout d’abord stocker l’input dans une variable qu’on va appeler “instruction”,. Et puis, on va vérifier si la variable en question est une valeur numérique ou non. Pour cela, le type string nous met la méthode isnumeric à disposition, qui retourne True si le string en question est un nombre.

Dans notre cas, si la méthode isnumeric de notre variable “guess”, retourne False, on on vérifie si le texte entré par l’utilisateur est la lettre “q”, et si c’est le cas on execute l’instruction break qui nous ferra sortir de notre boucle. Créons aussi une variable qu’on va appeler “abandon”, qu’on va mettre à False au début de notre programme. Si l’utilisateur entre la lettre “q”, on va la mettre à True. Et pour finir, en dehors de notre boucle on va encore vérifier si l’utilisateur à abandonné, ou si il a trouvé le bon nombre, et adapter le message affiché en conséquence :

main.py
import random

number_to_guess = random.randint(1, 1000)
guess = -1
abandon = False

while guess != number_to_guess:
    instruction = input("Entrez un nombre entre 1 et 1000 [q: Quitter]: ")
    if not instruction.isnumeric():
        if instruction.lower() == "q":
            abandon = True
            break

    guess = int(instruction)
    if guess < number_to_guess:
        print("C'est plus")
    elif guess > number_to_guess:
        print("C'est moins")

if abandon:
    print(f"Dommage, le nombre recherché était le nombre {number_to_guess}")
else:
    print(f"Bravo vous avez trouvé le nombre {number_to_guess} !")

Si on relance notre programme, on voit que nous pouvons tenter de deviner le nombre. Et si on tape la lettre Q, on a bien le programme qui se termine en nous affichant le nombre qui était recherché.

On pourrait pu se dire que tout est bon et s’arrêter là. Mais si on relance notre programme et qu’on tape texte autre que la lettre “q”,, on voit que le programme crash :

Ce résultat est normal, car on n’a pas traité le cas où l’utilisateur entre une chaîne de caractère qui n’est ni un nombre ni la lettre Q.

L’instruction break

Dans notre cas, si l’utilisateur n’entre pas une chaîne valide, on veut lui afficher un message d’erreur et redémarrer notre boucle à la première ligne, afin qu’il puisse entrer un nouveau chiffre. Pour cela, il nous faudrait une nouvelle instruction qui nous permette d’indiquer à Python qu’on souhaite immédiatement démarrer une nouvelle itération de notre boucle. Et ça tombe bien, car c’est exactement ce que fait l’instruction continue.

Regardons tout de suite comment utiliser cette instruction dans notre code:

main.py
import random

number_to_guess = random.randint(1, 1000)
guess = -1
abandon = False

while guess != number_to_guess:
    instruction = input("Entrez un nombre entre 1 et 1000 [q: Quitter]: ")
    if not instruction.isnumeric():
        if instruction.lower() == "q":
            abandon = True
            break
        else:
            print("Instruction invalide !")
            continue

    guess = int(instruction)
    if guess < number_to_guess:
        print("C'est plus")
    elif guess > number_to_guess:
        print("C'est moins")

if abandon:
    print(f"Dommage, le nombre recherché était le nombre {number_to_guess}")
else:
    print(f"Bravo vous avez trouvé le nombre {number_to_guess} !")

Maintenant si on relance notre programme, tout fonctionne comme prévu:

Et voilà, vous savez maintenant créer des boucles while. Dans le prochain chapitre, on va s’attaquer aux boucles for.

Ressources

Vous retrouvez ci-dessous un lien vers le code source utilisé dans ce chapitre. Ce lien est uniquement disponible pour les abonnés Standard et Premium.

Quiz

Répondez au quiz ci-dessous afin de vérifier que vous avez bien compris le contenu de cette leçon. Les quiz sont uniquement disponibles pour les abonnés Standard et Premium.

Laisser un commentaire