Lær hvordan du simulerer en do-while løkke i Python
I denne veiledningen skal vi utforske hvordan du kan etterligne en do-while-løkke i Python. Løkker er fundamentale i programmering, og de tillater oss å gjenta visse handlinger basert på en gitt betingelse. Python tilbyr while og for løkker, men mangler en innebygd do-while løkke.
Likevel, ved å forstå prinsippene bak en do-while løkke, kan vi effektivt simulere den ved hjelp av Pythons eksisterende løkkekonstruksjoner og kontrollsetninger. I løpet av de neste minuttene skal vi se hvordan dette kan gjøres. La oss begynne!
Hva er en Do-While løkke?
Hvis du har erfaring med språk som C eller C++, kjenner du sannsynligvis til do-while løkken.
I en do-while løkke utføres koden i løkkekroppen først. Deretter evalueres løkkebetingelsen for å avgjøre om løkken skal fortsette. Dette er i motsetning til en vanlig while-løkke, hvor betingelsen sjekkes før løkkekroppen utføres.
Du kan prøve de følgende C-eksemplene ved hjelp av en online C-kompilator som tipsbilk.net.
La oss se på dette kodeeksemplet:
//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;
}
Her er resultatet:
Output Do-While loop: Loop runs...
I dette eksemplet har vi:
- Variabelen
counter satt til 1, mens løkkebetingelsen ercount < 0. Selv om betingelsen er usann fra starten, kjøres løkken likevel én gang. - Dette er forskjellig fra en
while-løkke som kun kjører hvis løkkebetingelsen er sann ved starten.
//while_example1
#include <stdio.h>
int main() {
int count = 1;
printf("While loop: \n");
while(count<0){
printf("Loop runs...");
}
return 0;
}
Som vi ser, er count < 0 usann, da count er initialisert til 1. Når vi kompilerer og kjører denne koden, vil ikke løkkekroppen bli utført.
Output While loop: //løkkekroppen kjøres ikke!
While vs Do-While: En oversikt over forskjellene
La oss undersøke forskjellene mellom while– og do-while-løkker nærmere.
Se på dette eksemplet:
//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;
}
I koden over har vi:
counter initialisert til 1.- Vi bruker en
do-whileløkke. countøkes med 1 for hver iterasjon, og løkkebetingelsen ercount < 5.
Her er en visuell forklaring på hvordan løkken kjører og kontrollerer løkkebetingelsen fire ganger.
Output Do-while loop: 1 2 3 4
Hvis vi bruker en while løkke i stedet, ser det slik ut:
//while_example2
#include <stdio.h>
int main() {
int count = 1;
printf("While loop: \n");
while(count<5){
printf("%d\n",count);
count++;
};
return 0;
}
Figuren under forklarer hvordan while-løkken fungerer. I dette eksemplet sjekkes løkkebetingelsen fem ganger.
Output While loop: 1 2 3 4
Selv om utskriften fra de ovennevnte while– og do-while-løkkene er identisk, er det noen viktige forskjeller.
I en while-løkke sjekkes betingelsen først, og deretter utføres løkkekroppen. For at løkken skal kjøre K ganger, må betingelsen være sann i nøyaktig K iterasjoner. I iterasjon nummer K+1 blir tilstanden usann, og løkken avsluttes.
Med en do-while-løkke derimot, kontrolleres betingelsen for K-te gang først etter at løkken har kjørt K ganger.
Hvorfor er denne lille forskjellen nyttig? 🤔
La oss anta at løkkebetingelsen er kostbar å beregne, for eksempel ved bruk av en rekursiv funksjon eller en kompleks matematisk operasjon.
I slike tilfeller kan det være mer effektivt å bruke en do-while-løkke for K repetisjoner av løkkekroppen.
While vs. Do-While Oppsummering
La oss oppsummere de viktigste forskjellene i en tabell. 👩🏫
| While Loop | Do-While Loop |
| Sjekker betingelsen før utførelsen av løkkekroppen | Sjekker betingelsen etter utførelsen av løkkekroppen |
| Hvis betingelsen er usann fra starten, utføres ikke løkkekroppen. | Hvis betingelsen er usann fra starten, utføres løkkekroppen én gang. |
| Løkkebetingelsen sjekkes K ganger for K iterasjoner av løkken. | Løkkebetingelsen sjekkes K-1 ganger for K iterasjoner av løkken. |
Når skal en while-løkke brukes?– Løkken skal kjøre så lenge betingelsen er sann. – For inngangskontrollerte løkker. – Når løkkebetingelsen ikke er beregningsmessig kostbar. |
Når skal en do-while-løkke brukes?– Løkken bør kjøre minst én gang, selv om betingelsen er usann fra starten. – For utgangskontrollerte løkker. – Når løkkebetingelsen er beregningsmessig kostbar. |
Simulere Do-While i Python
Fra forrige avsnitt har vi følgende to krav for å etterligne do-while-løkken:
- Koden i løkkekroppen skal utføres minst én gang, uavhengig av om betingelsen er sann eller usann.
- Betingelsen bør sjekkes etter utførelse av løkkekroppen. Hvis betingelsen er usann, skal løkken avsluttes: utgangskontroll.
Uendelig While-Løkke og Break i Python
Du kan lage en uendelig while-løkke i Python som vist nedenfor:
while True:
pass
# I stedet for True kan du ha en betingelse som alltid er sann
while always-True-condition:
pass
break-setningen brukes for å avbryte en løkke og overføre kontrollen til den første setningen utenfor løkken.
while <betingelse>:
if <en-betingelse>:
break
I det første do-while-løkkeeksemplet i C er betingelsen for å fortsette løkken count < 0. Betingelsen for å bryte ut av løkken er dermed count >= 0.
Her er hvordan vi simulerer dette i Python:
count = 1
while True:
print("Loop runs...")
if(count >= 0):
break
Python Do-While Eksempler
La oss se på eksemplene fra forrige avsnitt og skrive dem om i Python ved å simulere do-while.
#1. La oss se på eksemplet der vi skriver ut verdiene for count når count er mindre enn fem.
Vi vet hvordan vi lager en uendelig løkke, slik at løkkekroppen kjøres minst en gang.
Løkken skal fortsette så lenge count er mindre enn fem. Når count er fem, skal løkken avsluttes. Derfor er count == 5 betingelsen for å avslutte løkken.
Dette gir oss følgende:
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. Vi kan også skrive om tallgjettespillet som en Python do-while konstruksjon.
I tallgjettespillet validerer vi en brukers gjett mot et forhåndsdefinert hemmelig tall. Brukeren skal gjette det hemmelige tallet innen et visst antall forsøk, for eksempel max_guesses.
Koden skal be brukeren om å gjette uavhengig av om gjettet er riktig eller feil. Dette kan vi gjøre ved å bruke en uendelig while-løkke.
Når skal løkken avsluttes?
Løkken skal avsluttes i to tilfeller:
max_guesses).Koden nedenfor viser hvordan vi kan gjøre det.
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
I stedet for å bare avslutte løkken, kan vi legge til forklarende print()-setninger når vi møter hver av de ovennevnte tilfellene.
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
To eksempelutganger er vist nedenfor.
I denne utgangen avbryter break-setningen løkken når brukeren gjettet riktig.
# Eksempelutgang når secret_number = 43 og brukeren gjettet riktig! Guess a number:4 Guess a number:3 Guess a number:43 Congrats, you guessed it right!
Her er en annen eksempelutgang der brukeren når maksimalt antall forsøk, men ikke klarer å gjette riktig.
# Eksempelutgang når secret_number = 33 og brukeren ikke klarer å gjette riktig! 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!
Konklusjon
Jeg håper denne veiledningen har hjulpet deg med å forstå hvordan du etterligner en do-while-løkke i Python.
Her er de viktigste punktene:
- Bruk en uendelig løkke for å sikre at løkkekroppen kjører minst én gang. Dette kan være en triviell uendelig løkke, som
while True, eller en med en betingelse som alltid er sann. - Sjekk for avslutningstilstanden inne i løkken og bruk
break-setningen for å avslutte løkken under en spesifikk betingelse.
Neste steg er å lære mer om for løkker og enumerate()-funksjonen i Python.