Comment émuler des boucles Do-While en Python

Dans ce didacticiel, vous apprendrez à émuler une boucle do-while en Python .

Dans n'importe quel langage de programmation, les boucles vous aident à effectuer certaines actions de manière répétée, en fonction d'une condition de boucle. Python prend en charge les constructions de boucle while et for mais ne prend pas en charge nativement la boucle do- while.

Cependant, vous pouvez émuler une boucle do-while en comprenant son fonctionnement, en utilisant des boucles et des instructions de contrôle de boucle existantes dans Python.

Vous apprendrez comment faire cela au cours des prochaines minutes. Commençons!

Qu'est-ce que la construction de boucle Do-While ?

Si vous avez programmé dans des langages tels que C ou C++, vous auriez probablement rencontré la construction de boucle do-while.

Dans une boucle do-while, l'ensemble d'instructions dans le corps de la boucle (dans le bloc délimité par des accolades) est exécuté en premier, puis la condition de bouclage est vérifiée.

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

Considérez l'extrait de code suivant :

 //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; }

Voici la sortie.

 Output Do-While loop: Loop runs...

Dans l'exemple ci-dessus :

• La valeur de count est 1 et la condition de bouclage est count < 0 . Cependant, la boucle s'exécute une fois même si la condition de bouclage est initialement False .
• Cela contraste avec une boucle while qui ne s'exécute que si la condition de bouclage est True en premier lieu.

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

Comme mentionné, la condition de bouclage, count < 0 est False initialement, la variable count est initialisée à 1. Ainsi, lors de la compilation et de l'exécution du code ci-dessus, nous voyons que 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 de plus près les différences entre les boucles while et do-while.

Considérez cet exemple :

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

Dans la cellule de 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 bouclage est définie sur count < 5 .

Voici une explication visuelle de la façon dont l'exécution se produit : comment la boucle do-while fonctionne et vérifie quatre fois la condition de bouclage.

 Output Do-while loop: 1 2 3 4

Si vous utilisez une boucle while à la place, c'est ce que nous aurions.

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

La figure ci-dessous explique l'exécution de la boucle while ; dans cet exemple, la boucle while vérifie cinq fois la condition de bouclage.

 Output While loop: 1 2 3 4

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

Dans une boucle while, la vérification de la condition vient en premier, suivie du corps de la boucle. Donc, si vous voulez que la boucle s'exécute K fois, il devrait y avoir exactement K exécutions où la condition de bouclage est True . Dans l'itération numéro K+1 , la condition devient False et le contrôle sort de la boucle.

D'autre part, si vous utilisez une boucle do-while : la condition de bouclage est vérifiée pour la K-ième fois seulement après que K a traversé la boucle.

Alors, pourquoi cette amélioration marginale est-elle utile ?

Supposons que la condition de bouclage est coûteuse en calcul : par exemple, implique 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 avantageux d'utiliser une boucle do-while à la place.

Résumé de While vs Do-While

Compilons les principales différences que nous avons apprises.

Émulation du comportement de boucle Do-While en Python

De la section précédente, nous avons les deux conditions suivantes pour émuler la boucle do-while :

• Les instructions du corps de la boucle doivent s'exécuter au moins une fois , que la condition de bouclage soit True ou False .
• La condition doit être vérifiée après l'exécution des instructions dans le corps de la boucle. Si la condition est False , le contrôle doit sortir de la boucle : exit control.

Boucle While infinie et instruction Break en Python

Vous pouvez définir une boucle while infinie en Python, comme indiqué ci-dessous.

 while True: pass # Instead of True, you can have any condition that is always True while always-True-condition: pass

L'instruction break peut être utilisée pour sortir d'un corps de boucle et transférer le contrôle à la première instruction en dehors du corps de la boucle.

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

Dans le tout premier exemple de boucle do-while en C, la condition pour continuer la boucle est count < 0 . Ainsi, la condition pour sortir de la boucle est une valeur de comptage de zéro ou supérieure à zéro, ( count >= 0 ).

Voici l'émulation de la boucle do-while en Python :

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

Exemples de boucle Do-While Python

Nous allons revoir les exemples de la section précédente et les réécrire en Python en émulant 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 compte atteint cinq, nous devrions sortir de la boucle. Ainsi count == 5 est la condition de contrôle de sortie.

En les rassemblant, nous avons :

 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 construction Python do-while.

Dans le jeu de devinettes de nombres, nous validons les suppositions d'un utilisateur par rapport à un nombre secret prédéfini. L'utilisateur doit deviner le numéro secret dans un certain nombre de tentatives maximales autorisées, par exemple, max_guesses .

Le code doit inviter l'utilisateur à entrer, que sa supposition soit bonne ou mauvaise. Nous pouvons le faire en utilisant une boucle while infinie.

Alors, quand devrions-nous sortir de la boucle ?

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

1. Lorsque l'utilisateur a deviné le nombre
2. Lorsque l'utilisateur n'a pas encore deviné le nombre, mais a épuisé le nombre de suppositions disponibles. Le nombre de suppositions incorrectes par l'utilisateur = max_guesses .

La cellule de code ci-dessous montre comment nous pouvons le faire.

 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 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 numéro secret.

 # Sample output when secret_number = 43 and user gets it right! 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 maximum de suppositions disponibles mais ne parvient pas à deviner correctement le nombre secret.

 # Sample output when secret_number = 33 and user fails to guess it right! 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 aidé à comprendre comment émuler une boucle do-while en Python.

Voici les principaux plats à emporter:

• Utilisez une boucle infinie pour vous assurer que le corps de la boucle s'exécute au moins une fois. Il peut s'agir d'une boucle infinie triviale telle que while True, ou de while <condition> , de sorte que la condition soit toujours True.
• 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.