Python Loops - For, mens, nestede løkker med eksempler

python loops while

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

Vi lærte om de fire forskjellige Betingede uttalelser i Python i vår forrige opplæring.

Loops er kraftige programmeringskonsepter som støttes av nesten alle moderne programmeringsspråk. Det tillater et program å implementere iterasjoner, noe som i utgangspunktet betyr å utføre den samme kodeblokken to eller flere ganger.

Selv om de støttes av alle moderne programmeringsspråk og gir lignende grunnleggende funksjonalitet, kan implementeringene og syntaksen variere.

De Full opplæringsserie om Python vil gi deg en kort ide om hva Python handler om.

Hva du vil lære:

• Python Loops Video Tutorial
• Hva er Python Loops
  • Generell bruk av Python Loops
• For Loop In Python
  • Eksempel - Finn antall ord i en tekst ved hjelp av for loop
• Mens løkken
  • Eksempel - Finn en Fibonacci-sekvens opp til den første termin ved bruk av While Loop
• Nestet løkke
  • # 1) Nesting for Loops
  • # 2) Nesting While Loops
  • Eksempel - Tall stavekontroll
• Python Infinite Loops
  • Uttalelser om Python Break and Continue
  • Eksempel - Samle tall til en terskel er oppfylt
  • ofte stilte spørsmål
  • Mer om Python Loops
    • # 1) Mens løkke:
    • # 2) For løkke:
• Konklusjon
  • Anbefalt lesing

Python Loops Video Tutorial

Hva er Python Loops

I Python utføres utsagn på en sekvensiell måte, dvs. hvis koden vår består av flere kodelinjer, vil kjøringen starte på første linje, etterfulgt av den andre og så videre.

Imidlertid vil det være tilfeller der vi kanskje vil at en blokk med kode skal kjøres flere ganger til en betingelse er oppfylt. Takket være løkkeuttalelser kan vi gjøre nettopp det.

Nedenfor er et flytskjema som illustrerer hvordan en loop-setning fungerer.

Basert på diagrammet ovenfor, starter et Python-program kl Start (sirkel), og kjøringen fortsetter til tilstandserklæringen (Diamond), hvis tilstanden er SANT, vil programmet utføre kodeblokken.

Utførelsen fortsetter igjen til tilstandserklæringen, og den samme prosessen fortsetter hver gang tilstanden er SANT. Det bryter bare ut av sløyfen eller slutter å utføre kodeblokken hvis tilstanden er FALSE, og i dette tilfellet vil programmet fortsette kjøringen sekvensielt.

Python har to typer løkker.

Disse to typer løkker kan brukes inne i hverandre for å generere nestede løkker (mer om dette senere).

Generell bruk av Python Loops

I Python kan sløyfer brukes til å løse fantastiske og komplekse problemer. Du vil sannsynligvis støte på problemer som krever at du gjentar en handling til en betingelse er oppfylt (mens loop fungerer best her) eller et problem som krever at du utfører en handling på en rekke ting (for loop fungerer best her).

For Loop In Python

De for løkke fungerer bra med iterable objekter som lister , tupler , strenger osv. På denne måten kan vi gå gjennom elementene til disse objektene og manipulere deres verdier basert på koblingen vår.

De for løkke er nullindeksert og har følgende syntaks.

Tilstanden i for løkke forblir SANT bare hvis den ikke har iterert gjennom alle elementene i det iterable objektet (n). For bedre å forstå for løkke vil vi ta for oss flere eksempler, og til slutt skal vi jobbe med et praktisk eksempel.

Eksempel 1:Skriv ut tall fra start til slutt

For å oppnå dette vil vi bruke Python område funksjon.

Slik vil flytskjemaet se ut:

Produksjon

I eksemplet ovenfor brukte vi Python-området, som er en funksjon som returnerer en sekvens av tall, startende med a start nummer (0 som standard), trinn med a steg (1 som standard), og stopper før en slutt Nummer.

For dette eksemplet, har vi følgende:

Parametere og verdier for Python-rekkevidde-funksjonen

Så, vår for løkke vil gjentas gjennom en sekvens av tall fra 1 til 20, og for hver iterasjon vil den skrive ut nummeret. Gjentakelsen stopper når alle tallene i sekvensen har blitt besøkt.

Eksempel 2:Bestem om et tall er et primtall.

I dette eksemplet vil vi se hvorfor for løkke er så kraftig og nyttig. Her vil vi gjenta gjennom en sekvens av tall, og for hvert tall vil vi utføre noen beregninger for å avgjøre om en tilstand er SANT eller FALSK.

Det kan hjelpe å kjenne betingelsene for at et tall skal være primært.

• Tallet er alltid positivt, større enn 1.
• Har ingen andre positive skiller enn 1 og seg selv.

Utgang når inngang er 13

Utgang når inngang er 10

Merk: De hvis ikke brukt i eksemplet ovenfor er en betinget uttalelse og ikke en sløyfe. Men akkurat som mens løkke (som vi snart vil dekke), bruker den sammenligningsoperatørene for tilstanden.

Eksempel - Finn antall ord i en tekst ved hjelp av for loop

Dette eksemplet handler om å telle hvor mange ganger hvert ord forekommer i en tekst. Det er så mange måter dette kan oppnås på, men for dette eksemplet skal vi bruke for løkke .

Vi skal telle ordene fra teksten nedenfor.

Hei, velkommen til Software Testing Help. I denne artikkelen: ”Loops in Python”, lærer du om looper med praktiske eksempler. Flott ikke sant? Sørg for å følge med når vi lærer sammen.

God koding!

Det første vi skal gjøre er å fjerne tegnsetting, mellomrom og alle små bokstaver. Vi fjerner tegnsetting på tradisjonell måte ved å identifisere hvilke tegnsettinger som finnes i teksten vår, og deretter bruke for løkke for å erstatte dem med en tom streng.

Ettersom teksten ikke er mye, ser vi at tegnsettingene er komma (,), periode (.), spørsmålstegn (?), kolon (:), dobbelt anførselstegn (“) Og apostrof (‘).

Nedenfor er koden for å erstatte dem med en tom streng. Merk at vi ikke vil erstatte apostrof.

Produksjon

Deretter skal vi dele teksten i en liste over ord atskilt med mellomrom.

Produksjon

Til slutt vil vi telle og se hvor mange ganger hvert ord forekommer i den delte teksten.

Produksjon

Vi kan tydelig se at noen ord vises to ganger, og andre bare en gang. La oss sortere denne ordboken etter verdien i synkende rekkefølge, slik at vi tydelig kan skille. Her har vi brukt Python sortert funksjon , lambda-uttrykk , og ordbokforståelse .

gratis popup-blokkering for Google Chrome

Til slutt har vi brukt for løkke for å rense, telle og sortere ordene i teksten vår.

Nedenfor er den fullstendige koden.

Endelig utgang

Mens løkken

Python mens løkke utfører en setningsblokk gjentatte ganger så lenge tilstanden er SANT. Vi merker at det ligner litt på hvis uttalelse . Imidlertid, i motsetning til mens løkke , hvis if-setningen bare kjøres en gang hvis tilstanden er SANT.

Mens loop har følgende syntaks:

i motsetning til for løkke , den mens løkke itererer ikke over en sekvens. Den bruker sammenligningsoperatører og booleans for tilstanden.

La oss se på noen eksempler for bedre å forstå hvordan den brukes.

Eksempel 1:Skriv ut 'Hello World!' et antall ganger

De mens løkke sjekker tilstanden (tellHei Verden! ”Og øker tellingen.

Slik vil flytskjemaet se ut:

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

Produksjon:

Eksempel 2:Finn faktura av et tall

Faktoren til et tall er representert som n! og den har formelen

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

Programmet sjekker om tallet er 0 og returnerer 1 (faktor 0 er 1). Og så mens løkke sjekker tilstanden (n> = 1) for å se om n er lik 1 eller større enn 1. Hver gang når denne tilstanden er SANT, beregner vårt program formelen i sløyfeblokken

La oss bruke while-løkken for å løse det faktiske problemet

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))

Produksjon

Eksempel - Finn en Fibonacci-sekvens opp til den første termin ved bruk av While Loop

En Fibonacci-sekvens har formelen.

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

De to første tallene er 0 og 1, så er de neste tallene summen av de to foregående tallene (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

Produksjon

Programmet vårt definerer først den første nte verdien (n1 = 0), og deretter sjekker den om n_term som er sendt som et argument er lik 1. Hvis SANN, returnerer den 0.

Ellers definerer den to variabler:

• count = 0: Dette vil bli brukt i mens løkke for å sjekke tilstanden hvis tellingen er mindre enn n_term (count
• n2 = 1: Dette er vår andre nte verdi.

Så langt har vi 0,1 i sekvensen vår (n1, n2). Mens tilstanden er SANT:

• Verdien av n2 blir tildelt en midlertidig variabel (temp = n2).
• Summen av de to foregående tallene beregnes og tildeles n2 (n2 = n1 + n2).
• Den midlertidige verdien vår (n2 gammel verdi) er tildelt n1 (n1 = temp).
• Antallet vårt økes (count + = 1), og tilstanden blir sjekket på nytt.

På slutten av den første iterasjonen har vi 0,1,1 hvor:

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

Denne operasjonen vil gjenta til tilstanden teller

Nestet løkke

Det kule med Python-løkker er at de kan nestes, dvs. vi kan bruke en eller flere løkker i en annen sløyfe. Dette gjør at vi kan løse enda mer komplekse problemer.

# 1) Nesting for Loops

for løkker kan være nestet i seg selv. Syntaksen nedenfor viser et 1-nivå nestet for loop.

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

Eksempel 1:Bruk nestet for loop for å skrive ut tall i mønstre

La oss bruke den nestede løkken til å skrive ut følgende mønster:

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

Hvert tall skrives ut et antall ganger som tilsvarer selve nummeret.

Slik vil flytskjemaet se ut:

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()

Produksjon

Programmet vårt fungerer som følger:

• Den ytre sløyfen går gjennom området fra 1 til 6 og for hvert element i den sekvensen.
• Den går inn i den indre sløyfen der den gjentas over en rekke av det elementet.
• For hver iterasjon av det elementet skrives det ut.
• Den forlater bare den indre sløyfen når den har fullstendig iterert gjennom en rekke av det elementet.
• Når den forlater den indre sløyfen, går den tilbake til den ytre sløyfen og prosessen fortsetter til den har fullstendig iterert over sekvensen.

Eksempel 2:Manipulere elementer i en nestet liste ved hjelp av en nestet for loop

En situasjon vi sannsynligvis vil komme over i Python er å få tilgang til elementene i en nestet liste.

Ta for eksempel den nestede listen nedenfor.

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

For dette eksemplet, la oss skrive et program som vil telle antall heltall og flyter i denne nestede listen.

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))

Produksjon

hvilket av følgende er ikke teamets ansvar?

Programmet vårt fungerer på denne måten:

• Den ytre sløyfen får tilgang til de første indre listene (3,4.0,2,8.4,6) i vår nestede liste.
• Den indre sløyfen får tilgang til hvert element i denne første indre listen. For hvert element sjekker det om det er en flottør eller et helt tall. Hvis det er et heltall, øker det heltallstallet (int_count). Ellers hvis det er en flottør, øker den flytetellingen (float_count).
• Når den er ferdig med å gjenta gjennom denne første indre listen, beveger den seg tilbake til den ytre sløyfen og får tilgang til den andre listen (0,2,0.2,4,6), og den samme prosessen fortsetter til den har fått tilgang til alle de indre listene.

# 2) Nesting While Loops

Mens løkker kan være nestet i seg selv.

Syntaksen nedenfor viser et 1-nivå nestet mens loop.

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

Eksempel 3:Bruk nestet mens løkke for å skrive ut stjerner (*) i mønstre

La oss bruke nestet mens loop for å 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)

Produksjon

Programmet vårt fungerer som følger:

• Variabler initialiseres (i = 0, j = 0, n = 5)
• Den ytre sløyfen vår sjekker tilstanden (0<= 5) which is obviously TRUE.
• Den indre sløyfen vår kontrollerer tilstanden (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
• jeg er inkrementert og den ytre sløyfen sjekker igjen tilstanden (1<= 5) which is TRUE.
• Den indre sløyfen vår kontrollerer tilstanden (0<1) which is TRUE. So a star( * ) skrives ut og j inkrementeres og tilstanden til den indre sløyfen blir sjekket med (1<1) which is FALSE, thus breaks out of the inner loop.

Prosessen ovenfor fortsetter til den ytre sløyfetilstanden blir FALSE.

Eksempel - Tall stavekontroll

Å runde opp med en nestet løkke , vil vi bygge et spennende spill for å hjelpe til med å evaluere barnets evne til å gjenkjenne og stave tall.

Programmet viser tilfeldige tall på skjermen og ber om staving av nummeret. Den sjekker om inngangen er riktig, så viser den et annet nummer. Hvis inngangen er feil, vil den sende en feilmelding og be om et annet 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

Produksjon

Hovedfunksjonene til for-loop og while-loop er:

• De for løkke det går gjennom en liste med tall som blir presentert for brukeren å stave.
• De mens løkke sjekker om antall forsøk er overskredet. På denne måten får en bruker maksimalt antall forsøk for å få det riktig.

Vi har sett to nye konsepter mens-annet , gå i stykker (mer om dette senere). De mens løkke og for løkke opprinnelig har en annet uttalelse som bare kjøres en gang når tilstanden er FALSK.

Python Infinite Loops

Hvis vi ikke er forsiktige med hvordan vi implementerer løkkene våre, kan det føre til en uendelig løkke dvs. programmet vil utføre en blokk med kode for alltid til datamaskinen vår går tom for ressurser som CPU-minne.

Eksempel 1:Uendelig mens løkke

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

Produksjon

Merk : For å stoppe programmet fra å kjøre, bruk Ctrl + z eller Ctrl + c på terminalen du brukte til å kjøre koden.

Koden vår implementerer en uendelig mens løkke . Dette er imidlertid ved en feil fordi vår mens løkke sjekker tilstanden nummen<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åten å fikse dette på er å gi et middel til å øke nummenes verdi.

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()

Produksjon

Et spørsmål kan oppstå som det er uendelige løkker virkelig nødvendig? Spoilervarsel: Ja, det er de. En server kan være programmert til å kjøre kontinuerlig mens den betjener klientenes behov. I spill kan en hendelse løpe til brukeren velger en handling for å avslutte eller bryte løkken.

Tro det eller ei, vi brukte faktisk en uendelig løkke i det siste praktiske eksemplet ovenfor. Så hvordan takler vi det uendelige løkker ?

Uttalelser om Python Break and Continue

Som vi forklarte ovenfor, er det tilfeller der vi trenger å skrive forsettlig uendelige løkker . I disse tilfellene vil vi se at gå i stykker og Fortsette nøkkelord er ryggraden i uendelige løkker .

De gå i stykker og Fortsette nøkkelord brukes ofte i en Python hvis uttalelse hvor if-setningen sjekker en tilstand og hvis den er TRUE, bryter vi enten ut av sløyfen der if-setningen vår ble kalt, eller fortsetter ved å hoppe over all koden under den og gå tilbake til begynnelsen av loop.

Eksempel - Samle tall til en terskel er oppfylt

La oss vurdere et program som henter tall fra en tilfeldig generert kilde og samler tallene til en terskel er nådd.

Årsaken til at dette eksemplet krever en uendelig løkke, er at vi ikke vet nøyaktig hvor mange iterasjoner programmet vårt må utføre for at de akkumulerte tallene skal nå terskelen.

Vår eneste frelser er Python hvis uttalelse sammen med pause uttalelse . Vår if-setning sjekker om terskelen er nådd, så bryter den ut av sløyfen hvis SANT.

Programmet vårt krever også at noen begrensede tall ikke skal akkumuleres. Så hvis programmet vårt møter disse tallene, bør det hoppe over alle kodene og gå tilbake til begynnelsen av sløyfen. Dette er oppnåelig med fortsett uttalelse .

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()

Produksjon

ofte stilte spørsmål

Q # 1) Hvordan styrer du en Loop i Python?

Svar: I Python kan du kontrollere en loop med følgende kontrolluttalelser:

• De gå i stykker nøkkelord bryter ut av en løkke.
• De Fortsette nøkkelord hopper over alle kodene under det og går tilbake til begynnelsen av sløyfen.

Disse nøkkelordene brukes mest i en hvis uttalelse som først sjekker om en tilstand er SANN eller FALSK.

Q # 2) Hva er forskjellen mellom for loop og while loop?

fossemodell i livssyklus for programvareutvikling

Svar: TIL for løkke er en iteratorbasert sløyfe , som går gjennom elementene til iterable objekter som lister , tupler osv. Mens en mens løkke er en tilstandsbasert sløyfe , som utfører en blokk med utsagn gjentatte ganger så lenge tilstanden er SANT.

Q # 3) Støtter Python til loop?

Svar: Dessverre støtter Python ikke gjør-mens-løkke .

Q # 4) Hva er de to typene løkker i Python?

Svar: Python støtter generelt to typer løkker: for løkke og mens løkke . En tredje sløyfe ( nestet løkke ) kan genereres ved å hekke to eller flere av disse løkkene.

Mer om Python Loops

Looping-setninger i python brukes til å utføre en blokk med utsagn eller kode gjentatte ganger flere ganger som angitt av brukeren.

Python gir oss to typer løkker som nevnt nedenfor:

• Mens løkke
• For løkke

# 1) Mens løkke:

Mens loop in python brukes til å utføre flere utsagn eller koder gjentatte ganger til den gitte tilstanden er oppfylt.

Vi bruker en stund-løkke når vi ikke vet hvor mange ganger vi skal gjenta.

Syntaks:

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

I mens sløyfen, sjekker vi uttrykket, hvis uttrykket blir sant, vil bare blokken med utsagn som er tilstede i mens sløyfen blir utført. For hver iterasjon vil den kontrollere tilstanden og utføre uttalelsesblokken til tilstanden blir falsk.

Eksempel:

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

Produksjon:

10

Produksjon:

# 2) For løkke:

For loop in python brukes til å utføre en blokk med utsagn eller kode flere ganger til den gitte tilstanden blir falsk.

Vi bruker for loop når vi vet hvor mange ganger det skal gjentas.

Syntaks:

for var in sequence: Block of code

Her tar var verdien fra sekvensen og utfører den til alle verdiene i sekvensen er ferdig.

Eksempel:

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

Produksjon:

Nåværende språk er: Python

Nåværende språk er: Java

Nåværende språk er: Ruby

Produksjon:

For loop med rekkevidde () -funksjon:

Funksjonen Range () brukes til å generere en sekvens av tall.

For eksempel, område (5) vil generere tall fra 0 til 4 (5 tall).

Eksempel:

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

Produksjon:

Nåværende språk er: Python

Nåværende språk er: Java

Nåværende språk er: Ruby

Produksjon:

Konklusjon

I denne opplæringen så vi definisjonen av sløyfer, typer Python-sløyfer, bruk av for løkke, og mens løkke med noen eksempler.

Vi lærte også hvordan nestede løkker genereres og endelige løkker også, og vi ble kjent med hvordan vi bruker gå i stykker og Fortsette søkeord.

=> Sjekk ALLE Python-opplæringsprogrammer her

PREV Opplæring | NESTE veiledning

Anbefalt lesing

• Uttalelser om Python-kontroll (Python fortsetter, bryter og passerer)
• Python-variabler
• Python-opplæring for nybegynnere (praktisk GRATIS Python-trening)
• Python betingede uttalelser: if_else, elif, nestet if Statements
• Python-operatører
• Python-strengfunksjoner
• Python DateTime Tutorial med eksempler
• Python-funksjoner