Comment émulerate Boucles Do-While en Python

Dans ce tutoriel, vous apprendrez à émulerate a boucle do-while in Python.
Dans n'importe quel langage de programmation, les boucles vous aident à effectuer certaines actions répétées.atequotidiennement, en fonction des conditions de boucle. Python prend en charge le tout en et le à boucle construit mais ne prend pas en charge nativement le faire pendant boucle.
Cependant, vous pouvez émulerate une boucle do-while par understanding comment cela fonctionne - en utilisant les boucles et boucle poste de contrôleateéléments en 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 de stateLes éléments du corps de la boucle (à l'intérieur du bloc délimité par des accolades) sont exécutés en premier, puis la condition de bouclage est vérifiée.
Vous pouvez exécuter les exemples C suivants dans Geekflarele compilateur C en ligne de— directement depuis votre browser.
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 estcount < 0
. Cependant, la boucle s'exécute une fois même si la condition de boucle est initiale.allyFalse
. - Ceci contraste avec un tout en boucle 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
is False
initierally le count
La variable est initialisée à 1. Ainsi, lors de la compilation et de l'exécution du code ci-dessus, nous voyons que le statement dans le corps de la boucle while n'est pas exécuté.
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
count
variable est initialisée à 1. - Nous utilisons une boucle do-while.
- La
count
variable est incrémentée de 1 à chaque passage dans la boucle et la condition de bouclage est définie surcount < 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 s'exécute là où la condition de bouclage est True
. Dans le numéro d'itération K + 1, la condition devient False
, et le contrôle sort de la boucle.
En revanche, si vous utilisez une boucle do-while : la condition de bouclage n'est vérifiée que la K-ième fois après le passage de K à travers la boucle.
Alors, pourquoi cette amélioration marginale est-elle utile ?🤔
Supposons que la condition de boucle soit un calculally coûteux : implique par exemple un appel à une fonction récursive, une ma complexethematical opération, et ainsi de suite.
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

Faisons un tabulate les principales différences que nous avons apprises. 👩🏫
Alors que la boucle | Boucle Do-Wide |
Vérifier la condition de bouclage : avant l'exécution du corps de la boucle | Vérifier la condition de bouclage : Après l'exécution du corps de la boucle |
Si la condition est False initierally, le corps de la boucle n'est pas exécuté. | Si la condition est False initierally, le corps de la boucle est exécuté exactement une fois. |
La condition de bouclage est vérifiée K fois pour K passages dans la boucle. | La condition de bouclage est vérifiée K-1 fois pour K passages dans la boucle. |
Quand utiliser la boucle while ? – La boucle doit fonctionner tant que la condition est vraie – Pour les boucles à entrée contrôlée – Lorsque la condition de bouclage n’est pas un calculally cher | Quand utiliser une boucle do-while ? – La boucle doit s’exécuter au moins une fois pour une initiationally Fausse condition de boucle – Pour les boucles contrôlées en sortie – Lorsque la condition de bouclage est le calculally cher |
Émulation du comportement de boucle Do-While en Python
Du prevsection ious, nous avons les deux conditions suivantes à émulerate la boucle do while :
- Le stateles éléments dans le corps de la boucle doivent s'exécuter au moins une fois— que la condition de bouclage soit ou non
True
orFalse
. - La condition doit être vérifiée après l'exécution de stateéléments 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 Break Statement 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
La break
statement peut être utilisé pour sortir d'un corps de boucle et transférer le contrôle au premier statement à l'extérieur 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
. La condition pour sortir de la boucle est donc une valeur de comptage de zero ou greater que zero, (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

Bien revConsultez les exemples du previous et réécrivez-les en Python en émulant la boucle do while.
#1. Faisons revVoir l'exemple : imprimer les valeurs du count
variables quand 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. Alors 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. On peut aussi réécrire le jeu de devinettes en tant que construction Python do-while.
Dans le jeu de devinettes, nous validonsate les suppositions d'un utilisateur par rapport à un numéro 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 :
- Lorsque l'utilisateur a deviné le nombre
- 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 explications print()
statements lorsque nous rencontrons chacune des conditions ci-dessus, puis sortons 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, le break statement 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 émulerate une boucle do while en Python.
Voici les principaux points à retenir:
- Utilisez une boucle infinie pour vous assurer que le corps de la boucle s'exécute au moins une fois. Cela pourrait être une boucle infinie triviale telle que while True, ou cela pourrait être tandis que, de sorte que la condition soit toujours Vraie.
- Vérifiez la sortie condition à l'intérieur de la boucle et utilisez le pause statement pour sortir de la boucle dans une condition spécifique.
Ensuite, apprenez à utiliser pour les boucles les nouveautés énumérateurate() une fonction en Python.