Alt om Python While Loop med eksempler

Introduktion

En while-løkke er en grundlæggende kontrolflow-sætning i Python, der giver dig mulighed for gentagne gange at udføre en kodeblok, så længe en bestemt betingelse er sand. Det giver en måde at automatisere gentagne opgaver og iterere over en række værdier. Denne artikel vil udforske syntaks, brug og forskellige applikationer af while-løkker i Python.

Syntaks og struktur af en while-løkke

Syntaksen for en while-løkke i Python er som følger:

while condition:
    # code to be executed

Betingelsen er et boolesk udtryk, der bestemmer, om løkken skal fortsætte eller afsluttes. Hvis betingelsen anses for at være sand, vil kodeblokken inde i løkken blive udført gentagne gange. Når betingelsen bliver False, afsluttes løkken, og programmet fortsætter med den næste sætning efter løkken.

Grundlæggende brug og eksempler

Lad os starte med et simpelt eksempel for at forstå den grundlæggende brug af en while-løkke. Antag, at vi vil udskrive tallene fra 1 til 5. Vi kan opnå dette ved at bruge en while-løkke, som vist nedenfor:

num = 1
while num <= 5:
    print(num)
    num += 1

Produktion

1

2

3

4

5

I dette eksempel initialiserer vi variablen 'num' til 1. While-løkken fortsætter, hvis 'num' er mindre end eller lig med 5. Inde i løkken udskriver vi værdien af ​​'num' og øger den derefter med 1 ved hjælp af `+=` operator. Denne proces gentages, indtil 'num' bliver 6, når betingelsen bliver False, og løkken afsluttes.

Styring af flowet med sløjfekontrolerklæringer

Python giver tre sløjfekontrolsætninger, 'break', 'fortsæt' og 'pass', ' for at give dig mulighed for at kontrollere flowet af en while-løkke.

"Pause"-erklæringen

"break"-sætningen bruges til at forlade løkken før tid, selvom løkkebetingelsen stadig er sand. Det bruges ofte, når en bestemt betingelse er opfyldt, og du ønsker at afslutte løkken med det samme. Her er et eksempel:

num = 1
while num <= 10:
    if num == 6:
        break
    print(num)
    num += 1

Produktion

1

2

3

4

5

I dette eksempel afsluttes løkken, når 'num' bliver 6, fordi vi har brugt 'break'-sætningen inde i if-betingelsen. Som følge heraf udskrives kun tallene fra 1 til 5.

"Fortsæt"-erklæringen

`continue`-sætningen bruges til at springe resten af ​​kodeblokken over i løkken og gå til næste iteration. Det er nyttigt, når du vil springe visse værdier eller betingelser over og fortsætte med den næste iteration. Her er et eksempel:

num = 1
while num <= 5:
    if num == 3:
        num += 1
        continue
    print(num)
    num += 1

Produktion

1

2

4

5

I dette eksempel springer løkken værdien 3 over, fordi vi har brugt "fortsæt"-sætningen inde i if-betingelsen. Som følge heraf udskrives tallet 3 ikke, og løkken fortsætter med næste iteration.

"Bestå"-erklæringen

`pass`-sætningen er en pladsholder, når du ikke ønsker at gøre noget inde i løkken. Det bruges ofte som en midlertidig pladsholder under udvikling, eller når du vil oprette en tom løkke. Her er et eksempel:

num = 1
while num <= 5:
    pass
    num += 1

I dette eksempel gør "pass"-sætningen ingenting, og løkken øger værdien af ​​"num", indtil den bliver 6.

Almindelige anvendelsestilfælde og applikationer

Mens loops har en bred vifte af applikationer i Python. Lad os udforske nogle almindelige anvendelsestilfælde:

Iteration, indtil en betingelse er opfyldt

Mens loops er almindeligt brugt, når du vil iterere, indtil en bestemt betingelse er opfyldt. For eksempel vil vi finde den første potens af 2 større end 1000. Vi kan bruge en while-løkke til at opnå dette:

num = 1
while num <= 1000:
    num *= 2
print(num)

Produktion

1024

I dette eksempel fortsætter løkken, indtil 'num' overstiger 1000. For hver iteration ganges 'num' med 2, og den endelige værdi udskrives.

Brugerinputvalidering

Mens loops er nyttige til at validere brugerinput og sikre, at input opfylder visse kriterier. For eksempel vil vi bede brugeren om at indtaste et positivt heltal. Vi kan bruge en while-løkke til at bede om input, indtil et gyldigt heltal indtastes gentagne gange:

while True:
    try:
        num = int(input("Enter a positive integer: "))
        if num > 0:
            break
        else:
            print("Invalid input. Please enter a positive integer.")
    except ValueError:
        print("Invalid input. Please enter a valid integer.")

I dette eksempel fortsætter sløjfen på ubestemt tid, indtil der indtastes et gyldigt positivt heltal. "Try-except"-blokken håndterer potentielle fejl ved konvertering af input til et heltal.

Oprettelse af uendelige sløjfer

Mens loops kan bruges til at skabe uendelige loops, som fortsætter i det uendelige, indtil en bestemt betingelse er opfyldt. Lad os for eksempel skabe en simpel uendelig løkke, der udskriver "Hej, verden!" gentagne gange:

while True:
    print("Hello, World!")

I dette eksempel er løkkebetingelsen altid Sand, så løkken fortsætter i det uendelige. For at afslutte løkken kan du bruge 'break'-sætningen eller afbryde programafviklingen.

En uendelig sløjfe kan være nyttig i forbindelse med et realtidsovervågnings- eller logningssystem. Forestil dig en situation, hvor du løbende skal overvåge et system eller et netværk for specifikke hændelser eller ændringer og logge oplysningerne. En uendelig sløjfe kunne bruges til at kontrollere disse forhold og tage passende handlinger konstant.

Implementering af Game Loops

Mens loops er almindeligt brugt i spiludvikling til at implementere spilloops, som styrer spillets flow og håndterer brugerinput. En spilløkke består typisk af tre hovedkomponenter: opdatering af spiltilstanden, gengivelse af spilgrafikken og håndtering af brugerinput. Her er et forenklet eksempel:

game_running = True
while game_running:
    # Update game state
    # Render game graphics
    # Handle user input

I dette eksempel fortsætter løkken, så længe variablen 'game_running' er True. Inde i løkken vil du opdatere spillets tilstand, gengive spillets grafik og håndtere brugerinput. Denne proces gentages, indtil spillet slutter, eller spilleren vælger at afslutte.

Læs også: En komplet Python-tutorial til at lære datavidenskab fra bunden

Indlejret Mens Loops og Loop Nesting

Python giver dig mulighed for at indlejre while-løkker, hvilket betyder, at du kan have en while-løkke inde i en anden while-løkke. Dette er nyttigt, når du skal udføre gentagne opgaver inden for gentagne opgaver. Her er et eksempel:

outer_num = 1
while outer_num <= 3:
    inner_num = 1
    while inner_num <= 3:
        print(outer_num, inner_num)
        inner_num += 1
    outer_num += 1

Produktion

1 1

1 2

1 3

2 1

2 2

2 3

3 1

3 2

3 3

I dette eksempel har vi en ydre while-løkke, der itererer fra 1 til 3, og en indre while-løkke, der itererer fra 1 til 3 for hver ydre loop-iteration. Udskriftserklæringen inde i den indre løkke viser værdierne for begge løkkevariabler.

Tips og bedste fremgangsmåder til at bruge While Loops

Selvom loops er kraftfulde konstruktioner, kan de også være tilbøjelige til fejl, hvis de ikke bruges korrekt. Her er nogle tips og bedste fremgangsmåder, du skal huske på, når du bruger while-løkker:

Initialisering af variabler korrekt

Inden du går ind i en while-løkke, skal du initialisere alle loop-variabler til deres begyndelsesværdier. Dette sikrer, at sløjfetilstanden evalueres korrekt og forhindrer uventet adfærd. For eksempel:

count = 0
while count < 10:
    print(count)
    count += 1

I dette eksempel initialiserer vi variablen 'count' til 0, før vi går ind i løkken.

Sikring af sløjfeterminering

For at undgå uendelige sløjfer skal du altid sikre dig, at sløjfebetingelsen til sidst bliver Falsk. Dette kan opnås ved at opdatere sløjfevariabler eller bruge sløjfekontrolsætninger som "break". For eksempel:

num = 1
while num <= 10:
    if num == 6:
        break
    print(num)
    num += 1

I dette eksempel afsluttes løkken, når 'num' bliver 6 på grund af 'break'-sætningen.

Undgå uendelige sløjfer

Vær forsigtig, når du bruger while-løkker for at undgå at skabe uendelige løkker, der aldrig ender. Uendelige sløjfer kan føre til programnedbrud og forbruge for store systemressourcer. Dobbelttjek altid dine loop-betingelser og sørg for, at de kan blive falske på et tidspunkt.

Skrivning af læsbar og vedligeholdelsesvenlig kode

Mens loops kan blive komplekse og svære at forstå, hvis de ikke er skrevet ordentligt. Brug betydningsfulde variabelnavne, tilføj kommentarer for at forklare formålet med løkken, og opdel komplekse opgaver i mindre underopgaver. Dette gør din kode mere læsbar og vedligeholdelsesvenlig.

Avancerede teknikker og tricks

Mens loops kan bruges på avancerede måder til at opnå specifikke opgaver. Her er nogle avancerede teknikker og tricks:

Looping med Else Statements

I Python kan du bruge en else-sætning med en while-løkke til at udføre en kodeblok, når loop-betingelsen bliver False. Den anden blok udføres kun, hvis løkken fuldføres normalt uden nogen break-sætninger. Her er et eksempel:

num = 1
while num <= 5:
    print(num)
    num += 1
else:
    print("Loop completed")

Produktion

1

2

3

4

5

Sløjfe afsluttet

I dette eksempel udføres else-blokken, efter at løkken er fuldført normalt.

Brug af While-løkker med lister og strenge

Mens loops kan bruges til at iterere over lister og strenge ved at bruge en indeksvariabel. Her er et eksempel:

fruits = ["apple", "banana", "cherry"]
index = 0
while index < len(fruits):
    print(fruits[index])
    index += 1

Produktion

æble

banan

kirsebær

I dette eksempel itererer while-løkken over elementerne på 'frugt'-listen ved hjælp af indeksvariablen.

Læs også: Alt hvad du bør vide om indbyggede datastrukturer i Python – en begyndervejledning!

Sammenligning med andre løkkekonstruktioner i Python

Mens loops kun er en af ​​flere looping-konstruktioner, der er tilgængelige i Python. Lad os sammenligne while-løkker med for loops og rekursion:

Mens Loops vs For Loops

Mens sløjfer og sløjfer begge bruges til iteration, har de forskellige anvendelsestilfælde. Mens loops er mere fleksible og kan håndtere komplekse forhold, mens loops er bedre egnede til iteration over en sekvens af værdier. Mens loops er nyttige, når du ikke kender det nøjagtige antal iterationer på forhånd eller skal udføre komplekse beregninger. Sløjfer er nyttige, når du vil iterere over en række værdier, såsom en liste eller en streng.

Mens løkker vs. rekursion

Rekursion er en teknik, hvor en funktion kalder sig selv for at løse et problem. Det kan bruges til at opnå gentagne opgaver svarende til while-løkker, men det har nogle forskelle. Mens loops er mere velegnede til iterative opgaver, hvor du har en klar termineringsbetingelse og skal udføre et fast antal iterationer. Rekursion er mere velegnet til at løse problemer opdelt i mindre delproblemer, såsom søgning, sortering og trægennemløbsalgoritmer.

Konklusion

I denne artikel undersøgte vi begrebet while-løkker i Python. Vi lærte om deres syntaks, grundlæggende brug og forskellige applikationer. Vi diskuterede også tips, bedste praksis, almindelige fejl og avancerede teknikker til brug af while-løkker. Til sidst sammenlignede vi while-løkker med andre looping-konstruktioner i Python. Med denne viden kan du nu effektivt bruge while-løkker til at automatisere gentagne opgaver og gentage sekvenser af værdier i dine Python-programmer.

Lås op for kraften ved AI & ML Excellence! Tilmeld dig nu i vores Certificeret AI & ML BlackBelt Plus-program og løfte dine færdigheder til nye højder. Gå ikke glip af muligheden for at mestre de nyeste teknologier – transformer din karriere i dag!

Hvis du leder efter et Python-kursus online, så udforsk vores – Introduktion til Python-programmet dag!

Relaterede

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
• PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
• PlatoESG. Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
• PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
• Kilde: https://www.analyticsvidhya.com/blog/2024/01/python-while-loop-with-examples/