Python-løkker - Til, mens, indlejrede løkker med eksempler

python loops while

Denne videovejledning forklarer Loops rolle i Python, deres typer: For, While, Nested Loops med syntaks og praktiske programmeringseksempler:

Vi lærte om de fire forskellige Betingede udsagn i Python i vores tidligere tutorial.

Sløjfer er kraftfulde programmeringskoncepter understøttet af næsten alle moderne programmeringssprog. Det giver et program mulighed for at implementere iterationer, hvilket grundlæggende betyder at udføre den samme blok af kode to eller flere gange.

Selvom de understøttes af alle moderne programmeringssprog og giver lignende grundlæggende funktionalitet, kan deres implementeringer og syntaks variere.

Det Fuld træningsserie om Python vil give dig en kort idé om, hvad Python handler om.

Hvad du vil lære:

• Python Loops-videovejledning
• Hvad er Python Loops
  • Generel brug af Python-løkker
• For Loop In Python
  • Eksempel - Find antal ord i en tekst ved hjælp af for-loop
• Mens løkken
  • Eksempel - Find en Fibonacci-sekvens til den sidste periode ved hjælp af While Loop
• Indlejret løkke
  • # 1) Indlejring af sløjfer
  • # 2) Nestende mens sløjfer
  • Eksempel - Tal stave spil
• Python Infinite Loops
  • Udtalelser fra Python Break og Continue
  • Eksempel - Samle tal, indtil en tærskel er nået
  • Ofte stillede spørgsmål
  • Mere om Python Loops
    • # 1) Mens sløjfe:
    • # 2) Til løkke:
• Konklusion
  • Anbefalet læsning

Python Loops-videovejledning

Hvad er Python Loops

I Python udføres udsagn sekventielt, dvs. hvis vores kode består af flere kodelinjer, vil udførelsen starte ved den første linje efterfulgt af den anden osv.

Der vil dog være tilfælde, hvor vi måske ønsker, at en blok kode skal udføres flere gange, indtil en betingelse er opfyldt. Takket være loop-udsagn kan vi gøre netop det.

Nedenfor er et rutediagram, der illustrerer, hvordan en loop-sætning fungerer.

Baseret på ovenstående diagram starter et Python-program kl Start (cirkel), og udførelsen fortsætter til betingelseserklæringen (Diamant), hvis betingelsen er SAND, udfører programmet kodeblokken.

Udførelsen fortsætter igen til betingelseserklæringen, og den samme proces fortsætter, hver gang tilstanden er SAND. Det bryder kun ud af sløjfen eller stopper med at udføre kodeblokken, hvis betingelsen er FALSK, og i dette tilfælde vil programmet fortsætte udførelsen sekventielt.

Python har to typer sløjfer.

Disse to typer sløjfer kan bruges inden i hinanden til at generere indlejrede løkker (mere om dette senere).

Generel brug af Python-løkker

I Python kan sløjfer bruges til at løse fantastiske og komplekse problemer. Du vil sandsynligvis støde på problemer, der kræver, at du gentager en handling, indtil en betingelse er opfyldt (mens loop fungerer bedst her) eller et problem, der kræver, at du udfører en handling på en masse ting (for loop fungerer bedst her).

For Loop In Python

Det til løkke fungerer godt med gentagelige genstande som lister , tupler , strenge osv. På denne måde kan vi gå igennem disse objekts poster og manipulere deres værdier baseret på vores sammenkædning.

Det til løkke er nulindekseret og har følgende syntaks.

Tilstanden i til løkke forbliver SAND, hvis den ikke har gentaget alle elementerne i det iterable objekt (n). For bedre at forstå til løkke , vi vil behandle flere eksempler, og til sidst skal vi arbejde på et praktisk eksempel.

Eksempel 1:Udskriv numre fra start til slut

For at opnå dette bruger vi Python rækkevidde fungere.

Sådan ser flowchartet ud:

Produktion

I ovenstående eksempel brugte vi Python-området, som er en funktion, der returnerer en sekvens af tal startende fra a Start nummer (0 som standard), trin med a trin (1 som standard) og stopper før en ende nummer.

Til dette eksempel, har vi følgende:

Parametre og værdier for Python-rækkefunktionen

Så vores til løkke vil gentage sig gennem en række af tal fra 1 til 20, og for hver iteration vil den udskrive nummeret. Iterationen stopper, når alle numrene i sekvensen er blevet besøgt.

Eksempel 2:Bestem, om et tal er et primtal.

I dette eksempel vil vi se, hvorfor til løkke er så stærk og nyttig. Her vil vi gentage gennem en række af tal, og for hvert nummer udfører vi en beregning for at bestemme, om en tilstand er SAND eller FALSK.

Det kan hjælpe at kende betingelserne for, at et tal er prime.

• Antallet er altid positivt, større end 1.
• Har ingen andre positive skillevægge end 1 og sig selv.

Output når input er 13

Output når input er 10

Bemærk: Det hvis ellers anvendt i ovenstående eksempel er en betinget erklæring og ikke en sløjfe. Men ligesom mens sløjfe (som vi snart vil dække) bruger den sammenligningsoperatørerne til dens tilstand.

Eksempel - Find antal ord i en tekst ved hjælp af for-loop

Dette eksempel handler om at tælle, hvor mange gange hvert ord forekommer i en tekst. Der er så mange måder, hvorpå dette kan opnås, men i dette eksempel skal vi bruge til løkke .

Vi tæller ordene fra nedenstående tekst.

Hej, velkommen til Software Testing Help. I denne artikel: ”Sløjfer i Python” lærer du om sløjfer med praktiske eksempler. Godt ikke? Sørg for at følge med, når vi lærer sammen.

God kodning!

Den første ting, vi skal gøre, er at fjerne tegnsætninger, mellemrum og alle små bogstaver. Vi fjerner tegnsætning på traditionel måde ved at identificere, hvilke tegnsætninger der findes i vores tekst, og derefter bruge til løkke at erstatte dem med en tom streng.

Da teksten ikke er meget, ser vi, at tegnsætningen er kommaer (,), periode (.), spørgsmålstegn (?), kolon (:), dobbelt anførselstegn (“) Og apostrof (‘).

Nedenfor er koden, der erstatter dem med en tom streng. Bemærk, at vi ikke vil erstatte apostrof.

Produktion

Derefter deler vi teksten i en liste over ord adskilt af mellemrum.

Produktion

Endelig tæller vi og ser, hvor mange gange hvert ord forekommer i den opdelte tekst.

Produktion

Vi kan tydeligt se, at nogle ord vises to gange, og nogle kun én gang. Lad os sortere denne ordbog efter dens værdi i faldende rækkefølge, så vi tydeligt kan differentiere. Her har vi brugt Python sorteret funktion , lambda udtryk og ordbog forståelse .

hvor mange anvendelige værter er tilgængelige givet en klasse c ip-adresse med standard undernetmaske?

Endelig har vi brugt til løkke for at rense, tælle og sortere ordene i vores tekst.

Nedenfor er den komplette kode.

Endelig output

Mens løkken

Python mens sløjfe udfører en række udsagn gentagne gange, så længe betingelsen er SAND. Vi bemærker, at det ligner lidt på hvis erklæring . Men i modsætning til mens sløjfe , hvis sætningen kun udføres en gang, hvis dens tilstand er SAND.

While-sløjfen har følgende syntaks:

I modsætning til til løkke , det mens sløjfe gentages ikke over en sekvens. Det bruger sammenligningsoperatører og booleans til dens tilstand.

Lad os se på nogle eksempler for bedre at forstå, hvordan det bruges.

Eksempel 1:Udskriv 'Hello World!' et antal gange

Det mens sløjfe kontrollerer tilstanden (tælHej Verden! ”Og øger optællingen.

Sådan ser flowchartet ud:

def print_count_times(n): # set count to 0 count = 0 while count

Produktion:

Eksempel 2:Find faktura af et nummer

Faktoriet for et tal er repræsenteret som n! og den har formlen

1*2*...*(n-1)

Programmet kontrollerer, om antallet er 0 og returnerer 1 (faktor 0 er 1). Derefter mens sløjfe kontrollerer tilstanden (n> = 1) for at se, om vores n er lig med 1 eller større end 1. Hver gang når denne tilstand er SAND, beregner vores program formlen i loopblokken

Lad os bruge while-løkken til at løse det faktuelle problem

def factorial(n): if n == 0: # The factorial of 0 is 1. return 1 else: fac = 1 while n >= 1: # while this condition is TRUE # 1*2*3*...*(n-1) fac *= n # same as 'fac = fac * n' n -= 1 # same as 'n = n - 1' return fac if __name__ =='__main__': n = int(input('Find factorial of: ')) fac = factorial(n) print('Factorial of {} is {} '.format(n,fac))

Produktion

Eksempel - Find en Fibonacci-sekvens til den sidste periode ved hjælp af While Loop

En Fibonacci-sekvens har formlen.

0,1,1,...((n-1)th + (n-2)th)

De to første tal er 0 og 1, derefter er de næste tal summen af ​​de to foregående tal (n-1) th og (n-2) th.

Fibonacci-sekvensen på 8 vil være 0,1,1,2,3,5,8,13

def fibonacci(n_term): n1 = 0 # (n-1)th if n_term == 1: # if n_term term is 1, print 0 print(n1) else: count = 0 n2 = 1 # (n-2)th # Loop while 'count

Produktion

Vores program definerer først den første n-værdi (n1 = 0), og derefter kontrolleres det, om n_term, der er sendt som et argument, er lig med 1. Hvis SAND, returneres 0.

privat server til World of Warcraft

Ellers definerer det to variabler:

• count = 0: Dette vil blive brugt i mens sløjfe for at kontrollere tilstanden, hvis optællingen er mindre end n_term (count
• n2 = 1: Dette er vores anden n-værdi.

Indtil videre har vi 0,1 i vores rækkefølge (n1, n2). Mens tilstanden er SAND:

• Værdien af ​​n2 tildeles en midlertidig variabel (temp = n2).
• Summen af ​​de to foregående tal beregnes og tildeles n2 (n2 = n1 + n2).
• Vores midlertidige værdi (n2 gammel værdi) tildeles n1 (n1 = temp).
• Vores antal er steget (count + = 1), og tilstanden kontrolleres igen.

I slutningen af ​​den første iteration har vi 0,1,1 hvor:

• n1 = 1 (den første 1)
• n2 = 1 (den anden 1)

Denne handling gentages, indtil tilstanden tæller

Indlejret løkke

Det seje ved Python-løkker er, at de kan indlejres, dvs. vi kan bruge en eller flere løkker inde i en anden løkke. Dette gør det muligt for os at løse endnu mere komplekse problemer.

# 1) Indlejring af sløjfer

for sløjfer kan være indlejret i sig selv. Syntaksen nedenfor viser et 1-niveau indlejret til loop.

for in n: # piece of code goes here for in n: # piece of code goes here

Eksempel 1:Brug nestet til loop til at udskrive numre i mønstre

Lad os bruge den indlejrede til løkke til at udskrive følgende mønster:

1 2 2 3 3 3 4 4 4 4 5 5 5 5 5

Hvert nummer udskrives et antal gange svarende til selve nummeret.

Sådan ser flowchartet ud:

def print_numbers(): for i in range(1, 6): # outer loop for j in range(i): # 1st level inner loop print(i, end=' ') print(' ') if __name__ == '__main__': print_numbers()

Produktion

Vores program fungerer som følger:

• Den ydre sløjfe gentager området fra 1 til 6 og for hvert element i den rækkefølge.
• Den kommer ind i den indre sløjfe, hvor den gentager sig over en række af den vare.
• For hver iteration af det emne udskrives det.
• Den forlader kun den indre sløjfe, når den er fuldstændig itereret gennem en række af den vare.
• Når den forlader den indre sløjfe, går den tilbage til den ydre sløjfe, og processen fortsætter, indtil den er fuldstændig itereret over dens sekvens.

Eksempel 2:Manipuler elementer på en indlejret liste ved hjælp af en indlejret for loop

En situation, som vi sandsynligvis vil støde på i Python, er at få adgang til elementerne på en indlejret liste.

Tag f.eks. Den indlejrede liste nedenfor.

>>> ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4))

I dette eksempel lad os skrive et program, der tæller antallet af heltal og flyder i denne indlejrede liste.

def float_and_int_count(nested_list): float_count = 0 # set our float count to zero int_count = 0 # set our integer count to zero for l in nested_list: # outer loop accesses each list in the nested list for item in l: # inter loop accesses each item in the list if isinstance(item, int): # if item is an instance of int int_count += 1 # increment integer count elif isinstance(item, float): # if item is an instance of float float_count += 1 # increment float count # return a tuple return float_count, int_count if __name__ == '__main__': nested_list = ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4)) float_n, int_n = float_and_int_count(nested_list) print('Float count: {} Integer count: {}'.format(float_n, int_n))

Produktion

Vores program fungerer på denne måde:

• Den ydre sløjfe har adgang til de første indre lister (3,4.0,2,8.4,6) i vores indlejrede liste.
• Den indre sløjfe har adgang til hvert element i denne første indre liste. For hvert element kontrollerer det, om det er en float eller et heltal. Hvis det er et heltal, øges det heltalsantal (int_count). Ellers hvis det er en float, øges det float count (float_count).
• Når den er færdig med at gentage denne første indre liste, bevæger den sig derefter tilbage til den ydre sløjfe og får adgang til den anden liste (0,2,0.2,4,6), og den samme proces fortsætter, indtil den har fået adgang til alle de indre lister.

# 2) Nestende mens sløjfer

Mens sløjfer kan indlejres i sig selv.

Syntaksen nedenfor viser et 1-niveau indlejret mens løkke.

while condition: # piece of code goes here while condition: # piece of code goes here

Eksempel 3:Brug indlejret mens løkke til at udskrive stjerner (*) i mønstre

Lad os bruge nestet mens loop til at konstruere følgende mønster:

* * * * * * * * * * * * * * * def print_pattern(n): i = 0 # initialize to zero for outer loop j = 0 # initialize to zero for inner loop while i <= n: # outer loop runs n times while j < i: # inner loop runs i times print('*', end=' ') j += 1 # increment before checking inner loop condition j = 0 # re-initialize after leaving inner loop i += 1 # increment before checking outer loop condition print('') if __name__ == '__main__': n = 5 print_pattern(5)

Produktion

Vores program fungerer som følger:

• Variabler initialiseres (i = 0, j = 0, n = 5)
• Vores ydre løkke kontrollerer tilstanden (0<= 5) which is obviously TRUE.
• Vores indre sløjfe kontrollerer tilstanden (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
• jeg er inkrementeret, og den ydre sløjfe kontrollerer igen dens tilstand (1<= 5) which is TRUE.
• Vores indre sløjfe kontrollerer tilstanden (0<1) which is TRUE. So a star( * ) udskrives, og j øges, og tilstanden til den indre sløjfe kontrolleres med (1<1) which is FALSE, thus breaks out of the inner loop.

Ovenstående proces fortsætter, indtil den ydre sløjfeforhold bliver FALSK.

Eksempel - Tal stave spil

At afrunde med en indlejret løkke , vi bygger et spændende spil, der hjælper med at evaluere barnets evne til at genkende og stave tal.

Programmet viser tilfældige tal på skærmen og anmoder om stavning af dette nummer. Det kontrollerer, om input er korrekt, så viser det et andet nummer. Hvis input er forkert, vil det sende en fejlmeddelelse og bede om et andet svar.

import random # random contain 'shuffle' used to shuffle our list def word_spelling(): print('HELLO, WELCOME TO THE WORD SPELLING GAME. ') print('SPELL AS MUCH NUMBERS AS YOU CAN TO GET MARKS ') print('----------------------------------------------- ') correct_score = 0 # keep record of correct spellings wrong_score = 0 # keep record of wrong spellings exceeding number of trials max_trials = 3 # maximum number of trials # A dictionary of numbers as keys and spellings as values. This can be expanded to increase its level of difficulty. number_spell = {0:'zero',1:'one',2:'two',3:'three',4:'four',5:'five',6:'six', 7:'seven',8:'eight',9:'nine',10:'ten'} # get the list of keys from the dict and shuffle them so that random numbers are displayed on the screen. number_spell_keys = list(number_spell.keys()) random.shuffle(number_spell_keys) # Our game starts here for number in number_spell_keys: # outer loop is a for loop which iterate through the keys trial_count = 0 # keeps track of number of trials while trial_count

Produktion

De vigtigste funktioner i vores for-loop og while-loop er:

• Det til løkke itererer gennem en liste med tal, der præsenteres for brugeren at stave.
• Det mens sløjfe kontrollerer, om antallet af forsøg er overskredet. På denne måde får en bruger et maksimalt antal forsøg for at få det rigtigt.

Vi har set to nye koncepter mens-ellers , pause (mere om dette senere). Det mens sløjfe og til løkke oprindeligt har en andet udsagn som kun udføres en gang, når betingelsen er FALSK.

Python Infinite Loops

Hvis vi ikke er forsigtige med, hvordan vi implementerer vores sløjfer, kan det føre til en uendelig løkke dvs. programmet udfører en blok kode for evigt, indtil vores computer løber tør for ressourcer som CPU-hukommelse.

Eksempel 1:Uendelig mens sløjfe

def infinit_loop_1(): numb = 0 while numb <5: print(numb) if __name__ == '__main__': infinit_loop_1()

Produktion

Bemærk : Brug Ctrl + z eller Ctrl + for at stoppe dette program c på terminalen, du brugte til at køre koden.

Vores kode ovenfor implementerer en uendelig mens sløjfe . Dette er dog ved en fejltagelse, fordi vores mens sløjfe kontrollerer tilstanden følelsesløs<5, but there is nowhere in the code that actually increments the numb’s value. Hence the value of numb is always zero and the condition keeps returning TRUE.

Så måde at løse dette på er at give et middel til at øge følelsesværdien.

def infinit_loop_1(): numb = 0 while numb <5: print(numb) numb += 1 # fix by incrementing numb's value if __name__ == '__main__': infinit_loop_1()

Produktion

Et spørgsmål kan opstå som det er uendelige sløjfer virkelig nødvendigt? Spoiler alarm: Ja det er de. En server kan programmeres til at køre kontinuerligt, mens den tjener klienternes behov. I spil kan en begivenhed køre, indtil brugeren vælger en handling for at afslutte eller bryde løkken.

Tro det eller ej, vi brugte faktisk en uendelig løkke i det sidste praktiske eksempel ovenfor. Så hvordan håndterer vi det uendelige sløjfer ?

Udtalelser fra Python Break og Continue

Som vi forklarede ovenfor, er der tilfælde, hvor vi bliver nødt til at skrive forsætligt uendelige sløjfer . I disse tilfælde vil vi se, at pause og Blive ved nøgleord er rygraden i uendelige sløjfer .

Det pause og Blive ved nøgleord bruges ofte i en Python hvis erklæring hvor if-sætningen kontrollerer en betingelse, og hvis den er TRUE, bryder vi enten ud af sløjfen, hvor vores if-sætning blev kaldt, eller fortsætter ved at springe al kode under den over og vende tilbage til begyndelsen af ​​sløjfen.

Eksempel - Samle tal, indtil en tærskel er nået

Lad os overveje et program, der får tal fra en tilfældig genereret kilde og akkumulerer tallene, indtil en tærskel er nået.

Årsagen til, at dette eksempel kræver en uendelig løkke, er, at vi ikke ved nøjagtigt, hvor mange iterationer vores program skal udføre for at de akkumulerede tal skal nå tærsklen.

Vores eneste frelser er Python hvis erklæring sammen med pause erklæring . Vores if-sætning kontrollerer, om tærsklen er nået, så bryder den ud af sløjfen, hvis SAND.

Vores program kræver også, at nogle begrænsede numre ikke skal akkumuleres. Så hvis vores program støder på disse tal, skal det springe alle koder over og vende tilbage til begyndelsen af ​​sløjfen. Dette kan opnås med fortsæt erklæring .

import random def acc_numbers(): acc_numb = 0 # initialize our accumulator threshold = 45 # define our threshold value Rejected_numbers = (4,0,1) # define our rejected numbers while True: # This is an uncontrolled condition. # our infinite while loop # return random integer number within 0 and 10. numb = random.randint(0, 10) # check if the number is in the list of rejected numbers if numb in Rejected_numbers: print('Not accepting ', numb) continue # skip all code blow it and return to the beginning of the while loop # add random number to our store acc_numb += numb # check if the accumulated number has reached threshold if acc_numb >= threshold: print('Threshold attended') break # break out of the loop. if __name__ == '__main__': acc_numbers()

Produktion

Ofte stillede spørgsmål

Spørgsmål nr. 1) Hvordan styrer du en loop i Python?

Svar: I Python kan du styre en løkke med følgende kontroludtalelser:

• Det pause nøgleord bryder ud af en løkke.
• Det Blive ved nøgleord springer over alle koder under det og vender tilbage til begyndelsen af ​​sløjfen.

Disse nøgleord bruges mest i en hvis erklæring der først kontrollerer, om en betingelse er SAND eller FALSK.

Q # 2) Hvad er forskellen mellem for loop og while loop?

Svar: TIL til løkke er en iteratorbaseret sløjfe , som går igennem emnerne på iterable objekter som f.eks lister , tupler osv. Mens en mens sløjfe er en tilstandsbaseret sløjfe , der udfører en blok med udsagn gentagne gange, så længe dens tilstand er SAND.

Q # 3) Understøtter Python indtil loop?

Svar: Desværre understøtter Python ikke do-while-løkke .

Spørgsmål nr. 4) Hvad er de to typer sløjfer i Python?

Svar: Python understøtter generelt to typer sløjfer: til løkke og mens sløjfe . En tredje sløjfe ( indlejret løkke ) kan genereres ved at indlejre to eller flere af disse sløjfer.

Mere om Python Loops

Looping-sætninger i python bruges til at udføre en blok med udsagn eller kode gentagne gange flere gange som angivet af brugeren.

Python giver os 2 typer sløjfer som anført nedenfor:

• Mens løkke
• Til løkke

# 1) Mens sløjfe:

Mens loop i python bruges til at udføre flere udsagn eller koder gentagne gange, indtil den givne betingelse er sand.

Vi bruger en while-loop, når vi ikke ved, hvor mange gange der skal gentages.

Syntaks:

while (expression): block of statements Increment or decrement operator

I while-sløjfen kontrollerer vi udtrykket, hvis udtrykket bliver sandt, udføres kun den blok af udsagn, der er til stede inde i while-sløjfen. For hver iteration kontrollerer den tilstanden og udfører udsagnsblokken, indtil betingelsen bliver falsk.

Eksempel:

number = 5 sum = 0 i = 0 while (i

Produktion:

10

Produktion:

# 2) Til løkke:

For loop in python bruges til at udføre en blok med udsagn eller kode flere gange, indtil den givne tilstand bliver falsk.

Vi bruger for-løkken, når vi ved, hvor mange gange der skal gentages.

Syntaks:

for var in sequence: Block of code

Her tager var værdien fra sekvensen og udfører den, indtil alle værdierne i sekvensen er færdige.

Eksempel:

language = (‘Python’, ‘Java’, ‘Ruby’) for lang in language: print(“Current language is: “, lang)

Produktion:

Aktuelt sprog er: Python

Aktuelt sprog er: Java

Aktuelt sprog er: Ruby

Produktion:

Til loop ved hjælp af rækkevidde () -funktionen:

Funktionen Range () bruges til at generere en række af tal.

For eksempel, interval (5) genererer tal fra 0 til 4 (5 tal).

Eksempel:

language = (‘Python’, ‘Java’, ‘Ruby’) for lang in range(len(language)): print(“Current language is: “, language(lang))

Produktion:

Aktuelt sprog er: Python

Aktuelt sprog er: Java

Aktuelt sprog er: Ruby

Produktion:

Konklusion

I denne vejledning så vi definitionen af ​​sløjfer, typer af Python-sløjfer, brug af til løkke, og mens sløjfe med nogle eksempler.

Vi lærte også hvordan indlejrede løkker genereres og endelige sløjfer så godt, og vi lærte at bruge pause og Blive ved nøgleord.

Niveau 1 helpdesk interview spørgsmål

=> Tjek ALLE Python-selvstudier her

PREV-vejledning | NÆSTE vejledning

Anbefalet læsning

• Python-kontroludtalelser (Python fortsætter, bryder og passerer)
• Python-variabler
• Python-vejledning til begyndere (GRATIS GRATIS Python-træning)
• Python-betingede udsagn: if_else, elif, indlejret hvis udsagn
• Python-operatører
• Python-strengfunktioner
• Python DateTime-tutorial med eksempler
• Python-funktioner