So emulieren Sie Do-While-Schleifen in Python

In diesem Tutorial erfahren Sie, wie Sie a emulieren do-while-Schleife in Python.

In jeder Programmiersprache helfen Ihnen Schleifen, bestimmte Aktionen abhängig von einer Schleifenbedingung wiederholt auszuführen. Python unterstützt die während und aufgrund -Schleifenkonstrukte, unterstützt die jedoch nicht nativ tun-während Schleife.

Sie können jedoch eine do-while-Schleife emulieren, indem Sie verstehen, wie sie funktioniert – indem Sie „existing“ verwenden Schleifen und Schleife Steueranweisungen in Python.

Wie das geht, erfahren Sie in den nächsten Minuten. Lass uns anfangen!

What is the Do-While Loop Construct?

Wenn Sie in Sprachen wie C bzw C + +, wären Sie wahrscheinlich auf das do-while-Schleifenkonstrukt gestoßen.

In einer Do-While-Schleife wird zuerst der Satz von Anweisungen im Schleifenkörper – innerhalb des durch geschweifte Klammern begrenzten Blocks – ausgeführt, und dann wird die Schleifenbedingung überprüft.

Sie können die folgenden C-Beispiele in ausführen Der Online-C-Compiler von Geekflare– direkt von Ihrem Browser.

Betrachten Sie das folgende Code-Snippet:

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

Hier ist die Ausgabe.

Output

Do-While loop: 
Loop runs...

Im obigen Beispiel:

• Der Wert der count ist 1, und die Schleifenbedingung ist count < 0. Die Schleife wird jedoch einmal ausgeführt, obwohl die Schleifenbedingung initial ist False.
• Dies steht im Gegensatz zu a während Schleife, die nur ausgeführt wird, wenn die Schleifenbedingung ist True in den ersten Platz.

//while_example1

#include <stdio.h>

int main() {
    int count = 1;
    printf("While loop: \n");
    
    while(count<0){
        printf("Loop runs...");
        }

    return 0;
}

Wie erwähnt, die Schleifenbedingung, count < 0 is False zunächst die count Variable wird auf 1 initialisiert. Wenn wir also den obigen Code kompilieren und ausführen, sehen wir, dass die Anweisung im Körper der While-Schleife nicht ausgeführt wird.

Output

While loop: 
//loop body does not run!

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

Schauen wir uns die Unterschiede zwischen While- und Do-While-Schleifen genauer an.

Betrachten Sie dieses Beispiel:

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

In der obigen Codezelle:

• Dieses count Variable wird auf 1 initialisiert.
• Wir verwenden eine do-while-Schleife.
• Dieses count Variable wird bei jedem Schleifendurchlauf um 1 erhöht und die Schleifenbedingung auf gesetzt count < 5.

Hier ist eine visuelle Erklärung, wie die Ausführung erfolgt: wie die do-while-Schleife funktioniert und viermal auf die Schleifenbedingung prüft.

Output

Do-while loop: 
1
2
3
4

Wenn Sie stattdessen eine While-Schleife verwenden, hätten wir dies.

//while_example2

#include <stdio.h>

int main() {
    int count = 1;
    printf("While loop: \n");
    
    while(count<5){
       printf("%d\n",count);
       count++;
    };

    return 0;
}

Die folgende Abbildung erläutert die Ausführung der While-Schleife; In diesem Beispiel überprüft die While-Schleife die Schleifenbedingung fünfmal.

Output

While loop: 
1
2
3
4

Obwohl die Ausgaben für die obigen while- und do-while-Schleifen identisch sind, gibt es einige subtile Unterschiede.

In einer While-Schleife kommt zuerst die Prüfung auf Bedingung, gefolgt vom Schleifenkörper. Wenn Sie also möchten, dass die Schleife ausgeführt wird K Zeiten, sollte es geben genau k läuft dort, wo die Schleifenbedingung ist True. In Iterationsnummer K + 1, wird die Bedingung False, und die Steuerung bricht aus der Schleife aus.

Wenn Sie dagegen eine do-while-Schleife verwenden: Die Schleifenbedingung wird nur zum K-ten Mal überprüft nachdem K passiert ist durch die Schleife.

Warum ist diese geringfügige Verbesserung hilfreich?🤔

Angenommen, die Schleifenbedingung ist rechenintensiv: beinhaltet beispielsweise einen Aufruf einer rekursiven Funktion, eine komplexe mathematische Operation und so weiter.

In solchen Fällen wäre es für K Wiederholungen des Schleifenkörpers vorteilhaft, stattdessen eine do-while-Schleife zu verwenden.

While vs. Do-While-Zusammenfassung

Lassen Sie uns die wichtigsten Unterschiede tabellieren, die wir gelernt haben. 👩‍🏫

Emulating Do-While Loop Behavior in Python

Aus dem vorherigen Abschnitt haben wir die folgenden zwei Bedingungen, um die do-while-Schleife zu emulieren:

• Die Anweisungen im Schleifenkörper sollten ausgeführt werden mindestens einmal– unabhängig davon, ob die Schleifenbedingung ist True or False. 
• Die Bedingung sollte nach der Ausführung von Anweisungen im Schleifenkörper überprüft werden. Wenn die Bedingung ist False, sollte die Steuerung aus der Schleife ausbrechen: Steuerung beenden.

Unendliche While-Schleife und Break-Anweisung in Python

Sie können eine unendliche While-Schleife in Python definieren, wie unten gezeigt.

while True:
    pass

# Instead of True, you can have any condition that is always True

while always-True-condition:
   pass

Dieses break -Anweisung kann verwendet werden, um aus einem Schleifenkörper auszubrechen und die Kontrolle an die erste Anweisung außerhalb des Schleifenkörpers zu übertragen.

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

Im allerersten Beispiel für eine do-while-Schleife in C lautet die Bedingung, um die Schleife fortzusetzen count < 0. Die Bedingung zum Ausbrechen aus der Schleife ist also ein Zählwert von Null oder größer als Null, (count >= 0).

Hier ist die Emulation der do-while-Schleife in Python:

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

Python Do-While Loop Examples

Wir greifen die Beispiele aus dem vorherigen Abschnitt noch einmal auf und schreiben sie in Python neu, indem wir die do while-Schleife emulieren.

#1. Kommen wir noch einmal auf das Beispiel zurück: Ausdrucken von Werten der count variabel, wenn count ist kleiner als fünf.

Wir wissen, wie man eine Endlosschleife so definiert, dass der Schleifenkörper mindestens einmal ausgeführt wird.

Die Schleife sollte fortgesetzt werden, solange die Zählung kleiner als fünf ist. Wenn die Zählung fünf erreicht, sollten wir daher aus der Schleife ausbrechen. So count == 5 ist die Ausgangskontrollbedingung.

Zusammenfassend haben wir:

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. Wir können die auch umschreiben Zahl Ratespiel als Python-do-while-Konstrukt.

Beim Zahlenratespiel validieren wir die Vermutungen eines Benutzers anhand einer vordefinierten Geheimzahl. Der Benutzer sollte die Geheimzahl innerhalb einer bestimmten Anzahl von maximal zulässigen Versuchen erraten, sagen wir, max_guesses.

Der Code sollte den Benutzer zur Eingabe auffordern, unabhängig davon, ob seine Vermutung richtig oder falsch ist. Wir können dies mit einer unendlichen While-Schleife tun.

Wann sollten wir also aus der Schleife ausbrechen?

Die Steuerung sollte aus der Schleife ausbrechen, wenn einer der folgenden Fälle eintritt:

1. Wenn der Benutzer die Nummer erraten hat
2. Wenn der Benutzer die Zahl noch nicht erraten hat, aber die Anzahl der verfügbaren Vermutungen erschöpft hat. Die Anzahl der falschen Vermutungen durch den Benutzer = max_guesses.

Die Codezelle unten zeigt, wie wir es tun können.

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

Anstatt aus der Schleife auszubrechen, können wir eine Erklärung hinzufügen print() Aussagen, wenn wir auf jede der oben genannten Bedingungen stoßen und dann aus der Schleife ausbrechen.

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

Zwei Beispielausgaben sind unten gezeigt.

In dieser Beispielausgabe bricht die break-Anweisung aus der Schleife aus, wenn der Benutzer die Geheimnummer richtig errät.

# 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!

Hier ist eine weitere Beispielausgabe, wenn der Benutzer die maximale Anzahl an verfügbaren Vermutungen erreicht, aber die geheime Zahl nicht richtig erraten kann.

# 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!

Fazit

Ich hoffe, dieses Tutorial hat Ihnen geholfen zu verstehen, wie Sie eine Do-While-Schleife in Python emulieren.

Hier sind die wichtigsten Imbissbuden:

• Verwenden Sie eine Endlosschleife, um sicherzustellen, dass der Schleifenkörper mindestens einmal ausgeführt wird. Es könnte eine triviale Endlosschleife sein, wie etwa while True, oder es könnte sein während, sodass die Bedingung immer wahr ist.
• Überprüfen Sie für die verlassen Bedingung innerhalb der Schleife und verwenden Sie die brechen Anweisung, unter einer bestimmten Bedingung aus der Schleife auszubrechen.

Als nächstes lernen Sie, wie man es benutzt für Schleifen und enumerate()-Funktion bei Python.