Comment émuler des boucles Do-While en Python

Dans ce guide, vous allez découvrir comment simuler une boucle « do-while » en Python.

Dans tout langage de programmation, les boucles sont essentielles pour exécuter des actions de manière répétée, en fonction d’une condition spécifique. Python prend en charge les boucles « while » et « for », mais n’inclut pas nativement la boucle « do-while ».

Néanmoins, il est tout à fait possible d’imiter une boucle « do-while » en comprenant son fonctionnement et en utilisant les boucles et les instructions de contrôle existantes dans Python.

Les prochaines minutes vous montreront comment procéder. Alors, commençons !

Qu’est-ce que la structure de boucle « Do-While » ?

Si vous avez déjà programmé dans des langages tels que C ou C++, vous avez probablement rencontré la boucle « do-while ».

Dans une boucle « do-while », l’ensemble des instructions contenues dans le corps de la boucle (le bloc délimité par des accolades) est exécuté en premier, puis la condition de boucle est évaluée.

Vous pouvez exécuter les exemples C suivants dans le compilateur C en ligne de toptips.fr, directement depuis votre navigateur.

Voici un exemple de code :

//do_while_example1
#include <stdio.h>
int main() {
    int count = 1;
    printf("Do-While loop: n");
    
    do{
        printf("Loop runs...");
        }while(count<0);
    return 0;
}

Et voici le résultat de l’exécution :

Output
Do-While loop: 
Loop runs...

Dans l’exemple ci-dessus :

• La variable « count » est initialisée à 1, et la condition de boucle est « count < 0 ». Cependant, la boucle s’exécute une fois, même si la condition est initialement fausse.
• Ceci contraste avec une boucle « while », qui ne s’exécute que si la condition de boucle est vraie au départ.

//while_example1
#include <stdio.h>
int main() {
    int count = 1;
    printf("While loop: n");
    
    while(count<0){
        printf("Loop runs...");
        }
    return 0;
}

Comme mentionné précédemment, la condition de boucle, « count < 0 », est initialement fausse, car « count » est initialisé à 1. Par conséquent, lors de la compilation et de l’exécution du code ci-dessus, l’instruction dans le corps de la boucle « while » n’est pas exécutée.

Output
While loop: 
//loop body does not run!

« While » vs « Do-While » : un aperçu des différences

Examinons plus en détail les différences entre les boucles « while » et « do-while ».

Prenons cet exemple :

//do_while_example2
#include <stdio.h>
int main() {
    int count = 1;
    printf("Do-while loop: n");
    
    do{
       printf("%dn",count);
       count++;
    }while(count<5);
    return 0;
}

Dans le code ci-dessus :

• La variable « count » est initialisée à 1.
• Nous utilisons une boucle « do-while ».
• La variable « count » est incrémentée de 1 à chaque passage dans la boucle, et la condition de boucle est définie sur « count < 5 ».

Voici une représentation visuelle de l’exécution : comment la boucle « do-while » fonctionne et vérifie la condition de boucle quatre fois.

Output
Do-while loop: 
1
2
3
4

Si nous utilisons une boucle « while » à la place, voici ce que nous obtiendrions :

//while_example2
#include <stdio.h>
int main() {
    int count = 1;
    printf("While loop: n");
    
    while(count<5){
       printf("%dn",count);
       count++;
    };
    return 0;
}

Le schéma ci-dessous illustre l’exécution de la boucle « while » ; dans cet exemple, la boucle « while » vérifie la condition de boucle cinq fois.

Output
While loop: 
1
2
3
4

Bien que les sorties des boucles « while » et « do-while » ci-dessus soient identiques, il existe des différences subtiles.

Dans une boucle « while », la vérification de la condition se fait en premier, suivie du corps de la boucle. Ainsi, si l’on souhaite que la boucle s’exécute K fois, il doit y avoir exactement K exécutions où la condition de boucle est vraie. Lors de l’itération numéro K+1, la condition devient fausse et le contrôle sort de la boucle.

D’un autre côté, si l’on utilise une boucle « do-while » : la condition de boucle n’est vérifiée pour la K-ième fois qu’après que la boucle a été exécutée K fois.

Alors, pourquoi cette légère amélioration est-elle utile ?🤔

Supposons que la condition de boucle nécessite beaucoup de calculs : par exemple, un appel à une fonction récursive, une opération mathématique complexe, etc.

Dans de tels cas, pour K répétitions du corps de la boucle, il serait plus avantageux d’utiliser une boucle « do-while » à la place.

Résumé de « While » vs « Do-While »

Récapitulons les principales différences que nous avons apprises. 👩‍🏫

Comment simuler une boucle « Do-While » en Python

De la section précédente, nous tirons deux conditions pour simuler la boucle « do-while » :

• Les instructions du corps de la boucle doivent être exécutées au moins une fois, que la condition de boucle soit vraie ou fausse.
• La condition doit être vérifiée après l’exécution des instructions du corps de la boucle. Si la condition est fausse, le contrôle doit sortir de la boucle : contrôle de sortie.

Boucle « While » infinie et instruction « Break » en Python

Il est possible de définir une boucle « while » infinie en Python, comme illustré ci-dessous.

while True:
    pass
# Au lieu de True, vous pouvez utiliser toute condition qui est toujours vraie
while always-True-condition:
   pass

L’instruction « break » permet de sortir d’un corps de boucle et de transférer le contrôle à la première instruction située en dehors du corps de la boucle.

while <condition>:
    if <some-condition>:
        break

Dans le premier exemple de boucle « do-while » en C, la condition pour que la boucle continue est « count < 0 ». Par conséquent, la condition pour sortir de la boucle est une valeur de « count » égale ou supérieure à zéro (« count >= 0 »).

Voici la simulation de la boucle « do-while » en Python :

count = 1
while True:
    print("Loop runs...")
    if(count >= 0):
        break

Exemples de boucle « Do-While » en Python

Reprenons les exemples de la section précédente et réécrivons-les en Python, en simulant la boucle « do-while ».

#1. Reprenons l’exemple : afficher les valeurs de la variable « count » lorsque « count » est inférieur à cinq.

Nous savons comment définir une boucle infinie pour que le corps de la boucle s’exécute au moins une fois.

La boucle doit continuer tant que le nombre est inférieur à cinq. Par conséquent, lorsque le nombre atteint cinq, nous devrions sortir de la boucle. Ainsi, « count == 5 » est la condition de contrôle de sortie.

En rassemblant ces éléments, nous obtenons :

count = 1
while True:
  print(f"Count is {count}")
  count += 1
  if count==5:
    break

Output
Count is 1
Count is 2
Count is 3
Count is 4

#2. Nous pouvons également réécrire le jeu de devinettes de nombres sous la forme d’une structure « do-while » en Python.

Dans le jeu de devinettes de nombres, nous comparons les propositions de l’utilisateur à un nombre secret prédéfini. L’utilisateur doit deviner le nombre secret dans un certain nombre maximal de tentatives autorisées, par exemple, « max_guesses ».

Le code doit demander à l’utilisateur d’entrer une valeur, que sa proposition soit bonne ou mauvaise. Nous pouvons le faire en utilisant une boucle « while » infinie.

Alors, quand devons-nous sortir de la boucle ?

Le contrôle doit sortir de la boucle lorsque l’un des événements suivants se produit :

• Lorsque l’utilisateur a deviné le nombre.
• Lorsque l’utilisateur n’a pas encore deviné le nombre, mais a épuisé le nombre de tentatives disponibles. Le nombre de suppositions incorrectes de l’utilisateur = max_guesses.

Le code ci-dessous montre comment nous pouvons procéder.

import random
low, high = 5,50
secret_number = random.choice(range(low,high))
max_guesses = 10
num_guesses = 0
while True:
    guess = int(input("nGuess a number:"))
    num_guesses += 1
    conditions = [num_guesses==max_guesses,guess==secret_number]
    if any(conditions):
        break

Au lieu de simplement sortir de la boucle, nous pouvons ajouter des instructions « print() » explicatives lorsque nous rencontrons chacune des conditions ci-dessus, puis sortir de la boucle.

import random
low, high = 5,50
secret_number = random.choice(range(low,high))
print(secret_number)
max_guesses = 10
num_guesses = 0
while True:
    guess = int(input("nGuess a number:"))
    num_guesses += 1
    if guess==secret_number:
        print("Congrats, you guessed it right!")
        break
    if num_guesses==max_guesses:
        print("Sorry, you have no more guesses left!")
        break

Deux exemples de sorties sont présentés ci-dessous.

Dans cet exemple de sortie, l’instruction « break » sort de la boucle lorsque l’utilisateur devine correctement le nombre secret.

# Exemple de sortie lorsque secret_number = 43 et que l'utilisateur trouve la bonne réponse !
Guess a number:4
Guess a number:3
Guess a number:43
Congrats, you guessed it right!

Voici un autre exemple de sortie lorsque l’utilisateur atteint le nombre maximal de tentatives disponibles, mais ne parvient pas à deviner correctement le nombre secret.

# Exemple de sortie lorsque secret_number = 33 et que l'utilisateur ne parvient pas à deviner la bonne réponse !
Guess a number:3
Guess a number:15
Guess a number:21
Guess a number:50
Guess a number:17
Guess a number:6
Guess a number:18
Guess a number:5
Guess a number:12
Guess a number:43
Sorry, you have no more guesses left!

Conclusion

J’espère que ce tutoriel vous a permis de comprendre comment simuler une boucle « do-while » en Python.

Voici les principaux points à retenir :

• Utilisez une boucle infinie pour vous assurer que le corps de la boucle est exécuté au moins une fois. Il peut s’agir d’une boucle infinie triviale telle que « while True », ou « while « , où la condition est toujours vraie.
• Vérifiez la condition de sortie à l’intérieur de la boucle et utilisez l’instruction « break » pour sortir de la boucle dans une condition spécifique.

Ensuite, apprenez à utiliser les boucles « for » et la fonction « enumerate() » en Python.