How to Emulate Do-While Loops in Python


In this instructional, you’ll find out how to emulate a do-while loop in Python.

In any programming language, loops can help you carry out positive movements again and again, relying on a looping situation. Python helps the whereas and for loop constructs however does now not natively reinforce the do-while loop.

However, you’ll be able to emulate a do-while loop via figuring out the way it works— the usage of present loops and loop regulate statements in Python.

You’ll find out how to do that over the following couple of mins. Let’s start!

What is the Do-While Loop Construct?

What is the Do-While Loop Construct

If you’ve gotten programmed in languages equivalent to C or C++, you’d have most probably come around the do-while loop assemble.

In a do-while loop, the set of statements in the loop frame—inside the block delimited via curly braces—are completed first after which the looping situation is checked.

You can run the next C examples in Geekflare’s on-line C compiler—proper out of your browser.

Consider the next code snippet:

//do_while_example1

#come with <stdio.h>

int primary() 
    int depend = 1;
    printf("Do-While loop: n");
    
    do
        printf("Loop runs...");
        whereas(depend<0);

    go back 0;

Here’s the output.

Output

Do-While loop: 
Loop runs...

In the above instance:

  • The worth of depend is 1, and the looping situation is depend < 0. However, the loop runs as soon as even if the looping situation is first of all False.
  • This is in distinction to a whereas loop that most effective executes if the looping situation is True in the primary position.
//while_example1

#come with <stdio.h>

int primary() 
    int depend = 1;
    printf("While loop: n");
    
    whereas(depend<0)
        printf("Loop runs...");
        

    go back 0;

As discussed, the looping situation, depend < 0 is False first of all the depend variable is initialized to 1. So upon compiling and operating the above code, we see that the remark in the whereas loop frame isn’t completed.

Output

While loop: 
//loop frame does now not run!

While vs. Do-While: An Overview of the Differences

Let’s take a more in-depth take a look at the diversities between whereas and do-while loops.

While vs Do-While: An Overview of the Differences

Consider this case:

//do_while_example2

#come with <stdio.h>

int primary() 
    int depend = 1;
    printf("Do-while loop: n");
    
    do
       printf("%dn",depend);
       depend++;
    whereas(depend<5);

    go back 0;

In the above code mobile:

  • The depend variable is initialized to 1.
  • We use a do-while loop.
  • The depend variable is incremented via 1 all the way through each and every go throughout the loop, and the looping situation is ready to depend < 5.

Here’s a visible rationalization of ways the execution happens: how the do-while loop works and assessments for the looping situation 4 instances.

do-while-loop-example
Output

Do-while loop: 
1
2
3
4

If you utilize some time loop as an alternative, that is what we’d have.

//while_example2

#come with <stdio.h>

int primary() 
    int depend = 1;
    printf("While loop: n");
    
    whereas(depend<5)
       printf("%dn",depend);
       depend++;
    ;

    go back 0;

The determine underneath explains the whereas loop’s execution; in this case, the whereas loop assessments the looping situation 5 instances.

while-loop-example
Output

While loop: 
1
2
3
4

Although the outputs for the above whereas and do-while loops are similar, there are some delicate variations.

In some time loop, the test for situation comes first, adopted via the loop frame. So if you wish to have the loop to run Ok instances, there must be precisely Ok runs the place the looping situation is True. In iteration quantity Ok+1, the situation turns into False, and the regulate breaks out of the loop.

On the opposite hand, if you happen to use a do-while loop: the looping situation is checked for the Ok-th time most effective after Ok passes throughout the loop.

So why is that this marginal development useful?🤔

Suppose the looping situation is computationally dear: as an example, comes to a decision to a recursive serve as, a fancy mathematical operation, and so forth.

In such instances, for Ok repetitions of the loop frame, it might be advisable to use a do-while loop as an alternative.

While vs. Do-While Summary

Let’s tabulate the important thing variations we’ve realized. 👩‍🏫

While Loop Do-While Loop
Check for looping situation: Before the execution of the loop frame Check for looping situation: After the execution of the loop frame
If the situation is False first of all, the loop frame isn’t completed. If the situation is False first of all, the loop frame is completed precisely as soon as.
The looping situation is checked Ok instances for Ok passes throughout the loop. The looping situation is checked Ok-1 instances for Ok passes throughout the loop.
When to use whereas loop?
– Loop must run as long as the situation is True
– For entry-controlled loops
– When the looping situation isn’t computationally dear
When to use a do-while loop?
– Loop must run at least one time for an first of all False looping situation
– For exit-controlled loops
– When the looping situation is computationally dear

Emulating Do-While Loop Behavior in Python

From the former phase, we have now the next two stipulations to emulate the do-while loop:

  • The statements in the loop frame must execute at least one time—without reference to whether or not the looping situation is True or False
  • The situation must be checked after executing statements in the loop frame. If the situation is False, the regulate must escape of the loop: go out regulate.

Infinite While Loop and Break Statement in Python

do-while-python

You can outline an unlimited whereas loop in Python, as proven underneath.

whereas True:
    go

# Instead of True, you'll be able to have any situation this is continually True

whereas always-True-condition:
   go

The damage remark can be utilized to escape of a loop frame and switch regulate to the primary remark out of doors the loop frame.

whereas <situation>:
    if <some-condition>:
        damage

In the first actual do-while loop instance in C, the situation to proceed looping is depend < 0. So the situation to escape of the loop is a depend worth of 0 or more than 0, (depend >= 0).

Here’s the emulation of the do-while loop in Python:

depend = 1
whereas True:
    print("Loop runs...")
    if(depend >= 0):
        damage

Python Do-While Loop Examples

We’ll revisit the examples from the former phase and rewrite them in Python via emulating do whereas loop.

#1. Let’s revisit the instance: printing out values of the depend variable when depend is not up to 5.

We know the way to outline an unlimited loop in order that the loop frame executes at least one time.

The looping must proceed as long as the depend is not up to 5. Therefore, when the depend reaches 5, we must escape of the loop. So depend == 5 is the go out regulate situation.

Putting it in combination, we have now:

depend = 1
whereas True:
  print(f"Count is depend")
  depend += 1
  if depend==5:
    damage
Output

Count is 1
Count is two
Count is 3
Count is 4

#2. We too can rewrite the quantity guessing recreation as a Python do-while assemble.

In the quantity guessing recreation, we validate a consumer’s guesses in opposition to a predefined secret quantity. The consumer must bet the name of the game quantity inside a undeniable choice of most makes an attempt allowed, say, max_guesses.

The code must steered the consumer for enter, without reference to whether or not their bet is correct or improper. We can do that the usage of an unlimited whereas loop.

So when must we escape of the loop?

The regulate must escape of the loop when any one of the vital following happens:

  1. When the consumer has guessed the quantity
  2. When the consumer hasn’t guessed the quantity but, however has exhausted the choice of guesses to be had. The choice of improper guesses via the consumer = max_guesses.

The code mobile underneath displays how we will be able to do it.

import random

low, prime = 5,50

secret_number = random.selection(vary(low,prime))

max_guesses = 10

num_guesses = 0

whereas True:
    bet = int(enter("nGuess a host:"))
    num_guesses += 1
    
    stipulations = [num_guesses==max_guesses,guess==secret_number]
    
    if any(stipulations):
        damage

Instead of breaking out of the loop, we will be able to upload explanatory print() statements once we come across each and every of the above stipulations after which escape of the loop.

import random

low, prime = 5,50

secret_number = random.selection(vary(low,prime))

print(secret_number)

max_guesses = 10

num_guesses = 0

whereas True:
    bet = int(enter("nGuess a host:"))
    num_guesses += 1
    
    if bet==secret_number:
        print("Congrats, you guessed it proper!")
        damage
    if num_guesses==max_guesses:
        print("Sorry, you don't have any extra guesses left!")
        damage

Two pattern outputs are proven underneath.

In this pattern output, the damage remark breaks out of the loop when the consumer guesses the name of the game quantity as it should be.

# Sample output when secret_number = 43 and consumer will get it proper!

Guess a host:4

Guess a host:3

Guess a host:43
Congrats, you guessed it proper!

Here’s any other pattern output when the consumer reaches the utmost choice of guesses to be had however fails to bet the name of the game quantity as it should be.

# Sample output when secret_number = 33 and consumer fails to bet it proper!

Guess a host:3

Guess a host:15

Guess a host:21

Guess a host:50

Guess a host:17

Guess a host:6

Guess a host:18

Guess a host:5

Guess a host:12

Guess a host:43
Sorry, you don't have any extra guesses left!

Conclusion

I am hoping this instructional helped you know how to emulate a do-while loop in Python.

Here are the important thing takeaways:

  • Use an unlimited loop to be sure that the loop frame runs at least one time. It generally is a trivial endless loop equivalent to whereas True, or it might be whereas <situation>, such that the situation is continually True.
  • Check for the go out situation within the loop and use the damage remark to escape of the loop beneath a particular situation.

Next, find out how to use for loops and the enumerate() serve as in Python.

Related Articles

Leave a Reply

Your email address will not be published.

Back to top button