Die Emulation der Do-While-Schleife in Python
Dieses Tutorial zeigt Ihnen, wie Sie das Verhalten einer Do-While-Schleife in Python nachbilden können.
Schleifen sind ein fundamentales Konzept in der Programmierung, um Codeblöcke wiederholt auszuführen. Python bietet die while– und for-Schleifen, jedoch keine direkte Implementierung der Do-While-Schleife.
Dennoch ist es möglich, eine Do-While-Schleife zu emulieren, indem man ihre Funktionsweise versteht und die vorhandenen Kontrollstrukturen von Python geschickt einsetzt.
In den folgenden Abschnitten werden wir uns genauer damit beschäftigen, wie dies umgesetzt werden kann. Beginnen wir!
Was ist eine Do-While-Schleife?
Wenn Sie Erfahrung mit Programmiersprachen wie C oder C++ haben, ist Ihnen das Konzept der Do-While-Schleife wahrscheinlich bereits bekannt.
Bei einer Do-While-Schleife wird der Codeblock im Schleifenkörper, der durch geschweifte Klammern begrenzt ist, zuerst ausgeführt. Erst dann wird die Schleifenbedingung überprüft.
Die folgenden C-Beispiele können Sie direkt in einem Online-C-Compiler wie dem von wdzwdz in Ihrem Browser testen.
Betrachten Sie den nachfolgenden 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;
}
Die zugehörige Ausgabe:
Output
Do-While loop:
Loop runs...
In diesem Beispiel:
- Die Variable
countist auf 1 gesetzt, während die Schleifenbedingungcount < 0lautet. Die Schleife wird einmal ausgeführt, obwohl die Bedingung zunächst falsch ist. - Dies unterscheidet sich von einer
while-Schleife, die nur dann ausgeführt wird, wenn die Bedingung zu Beginn wahr ist.
//while_example1
#include <stdio.h>
int main() {
int count = 1;
printf("While loop: n");
while(count<0){
printf("Loop runs...");
}
return 0;
}
Wie bereits erwähnt, ist die Bedingung count < 0 falsch. Die Variable count wird mit 1 initialisiert. Wenn wir diesen Code kompilieren und ausführen, wird die Anweisung im while-Schleifenkörper nicht ausgeführt.
Output
While loop:
//loop body does not run!
While vs. Do-While: Ein Vergleich
Lassen Sie uns die Unterschiede zwischen while– und do-while-Schleifen genauer betrachten.
Hier ein weiteres Beispiel:
//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;
}
In diesem Code:
- Die Variable
countwird mit 1 initialisiert. - Eine
do-while-Schleife wird verwendet. - Die Variable
countwird in jedem Durchlauf erhöht, und die Schleifenbedingung lautetcount < 5.
Die folgende Grafik veranschaulicht den Ablauf der Ausführung: Die do-while-Schleife führt den Code aus und prüft die Bedingung viermal.
Output
Do-while loop:
1
2
3
4
Die Verwendung einer while-Schleife würde zu folgendem Code führen:
//while_example2
#include <stdio.h>
int main() {
int count = 1;
printf("While loop: n");
while(count<5){
printf("%dn",count);
count++;
}
return 0;
}
Die folgende Abbildung zeigt den Ablauf der Ausführung der while-Schleife; in diesem Beispiel prüft die while-Schleife die Bedingung fünfmal.
Output
While loop:
1
2
3
4
Obwohl die Ausgaben der while– und do-while-Schleifen identisch sind, gibt es feine Unterschiede.
In einer while-Schleife wird die Bedingung zuerst geprüft, bevor der Schleifenkörper ausgeführt wird. Um die Schleife K-mal auszuführen, muss die Bedingung K-mal wahr sein. Beim K+1-ten Durchlauf wird die Bedingung falsch und die Schleife wird beendet.
Bei einer do-while-Schleife wird die Bedingung erst beim K-ten Mal geprüft, nachdem die Schleife K-mal durchlaufen wurde.
Warum ist diese Feinheit relevant? 🤔
Nehmen wir an, die Schleifenbedingung ist rechenintensiv, z.B. durch einen Aufruf einer rekursiven Funktion oder einer komplexen mathematischen Operation.
In solchen Fällen wäre es für K Wiederholungen des Schleifenkörpers vorteilhafter, eine do-while-Schleife zu verwenden.
Zusammenfassung: While vs. Do-While
Die wichtigsten Unterschiede sind hier zusammengefasst. 👩🏫
| While-Schleife | Do-While-Schleife |
| Überprüfung der Schleifenbedingung: Vor der Ausführung des Schleifenkörpers | Überprüfung der Schleifenbedingung: Nach der Ausführung des Schleifenkörpers |
| Wenn die Bedingung anfangs falsch ist, wird der Schleifenkörper nicht ausgeführt. | Wenn die Bedingung anfangs falsch ist, wird der Schleifenkörper genau einmal ausgeführt. |
| Die Schleifenbedingung wird K-mal überprüft, um die Schleife K-mal zu durchlaufen. | Die Schleifenbedingung wird K-1-mal überprüft, um die Schleife K-mal zu durchlaufen. |
Wann ist die Verwendung einer While-Schleife sinnvoll?
|
Wann ist die Verwendung einer Do-While-Schleife sinnvoll?
|
Emulieren des Do-While-Verhaltens in Python
Aus dem vorherigen Abschnitt lassen sich zwei Bedingungen für die Emulation einer do-while-Schleife ableiten:
- Die Anweisungen im Schleifenkörper müssen mindestens einmal ausgeführt werden, unabhängig davon, ob die Schleifenbedingung wahr oder falsch ist.
- Die Bedingung muss nach der Ausführung der Anweisungen im Schleifenkörper überprüft werden. Wenn die Bedingung falsch ist, muss die Schleife beendet werden.
Unendliche While-Schleife und Break-Anweisung in Python
Eine unendliche while-Schleife in Python kann wie folgt definiert werden:
while True:
pass
# Anstelle von True kann jede Bedingung verwendet werden, die immer True ist.
while immer-wahre-Bedingung:
pass
Die break-Anweisung kann verwendet werden, um den Schleifenkörper zu verlassen und die Kontrolle an die erste Anweisung außerhalb des Schleifenkörpers zu übergeben.
while <Bedingung>:
if <bestimmte-Bedingung>:
break
Im ersten C-Beispiel der do-while-Schleife ist die Bedingung zum Fortsetzen der Schleife count < 0. Die Abbruchbedingung ist also ein count-Wert von null oder größer (count >= 0).
Hier ist die Python-Emulation der do-while-Schleife:
count = 1
while True:
print("Loop runs...")
if(count >= 0):
break
Python-Beispiele für Do-While-Schleifen
Wir greifen die Beispiele aus dem vorherigen Abschnitt auf und schreiben sie in Python neu, indem wir die Do-While-Schleife emulieren.
#1. Betrachten wir nochmals das Beispiel: Ausgabe der Werte der Variablen count, solange count kleiner als fünf ist.
Wir wissen, wie man eine Endlosschleife so definiert, dass der Schleifenkörper mindestens einmal ausgeführt wird.
Die Schleife sollte fortgesetzt werden, solange count kleiner als fünf ist. Wenn count fünf erreicht, sollten wir aus der Schleife ausbrechen. count == 5 ist also die Abbruchbedingung.
Zusammenfassend ergibt sich:
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. Das Zahlenratespiel kann ebenfalls als Python-Do-While-Konstrukt umgeschrieben werden.
Bei diesem Spiel wird die Eingabe des Nutzers mit einer vorgegebenen Geheimzahl verglichen. Der Nutzer sollte die Geheimzahl innerhalb einer maximal zulässigen Anzahl von Versuchen, sagen wir max_guesses, erraten.
Der Code sollte den Nutzer zur Eingabe auffordern, egal ob seine Vermutung richtig oder falsch ist. Dies kann mit einer Endlosschleife erreicht werden.
Wann sollte die Schleife abgebrochen werden?
Die Schleife muss beendet werden, wenn:
- Der Nutzer die richtige Zahl erraten hat
- Der Nutzer hat die Zahl nicht erraten, aber die maximale Anzahl an Versuchen erreicht. Die Anzahl der falschen Vermutungen des Benutzers =
max_guesses.
Der nachfolgende Code zeigt die Umsetzung:
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
Anstelle des Schleifenabbruchs können auch informative print()-Anweisungen hinzugefügt werden, bevor die Schleife beendet wird.
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
Hier sind zwei Beispiele der Ausgaben.
In dieser Ausgabe bricht die break-Anweisung die Schleife ab, sobald der Benutzer die richtige Geheimzahl erraten hat.
# 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 ein weiteres Beispiel, wenn der Benutzer die maximale Anzahl an Versuchen erreicht, aber die Geheimzahl nicht erraten hat:
# 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, die Emulation der Do-While-Schleife in Python zu verstehen.
Die wichtigsten Punkte sind:
- Verwenden Sie eine Endlosschleife, um sicherzustellen, dass der Schleifenkörper mindestens einmal ausgeführt wird. Dies kann eine triviale Endlosschleife wie
while Truesein oder eine Schleifewhile <Bedingung>, bei der die Bedingung immer wahr ist. - Suchen Sie innerhalb der Schleife nach der Abbruchbedingung und verwenden Sie die
break-Anweisung, um die Schleife unter der entsprechenden Bedingung zu verlassen.
Als nächstes erfahren Sie, wie for-Schleifen und die enumerate()-Funktion in Python verwendet werden können.