Python Loops - För, medan, kapslade loopar med exempel

python loops while

Denna videohandledning förklarar Loops roll i Python, deras typer: For, While, Nested Loops med syntax och praktiska programmeringsexempel:

Vi lärde oss om de fyra olika Villkorliga uttalanden i Python i vår tidigare handledning.

Slingor är kraftfulla programmeringskoncept som stöds av nästan alla moderna programmeringsspråk. Det gör det möjligt för ett program att implementera iterationer, vilket i grund och botten innebär att exekvera samma kodblock två eller flera gånger.

Även om de stöds av alla moderna programmeringsspråk och ger liknande grundläggande funktionalitet, kan deras implementeringar och syntax skilja sig åt.

De Fullständig träningsserie om Python ger dig en kort uppfattning om vad Python handlar om.

Vad du kommer att lära dig:

• Python Loops Video Tutorial
• Vad är Python Loops
  • Allmän användning av Python Loops
• För Loop In Python
  • Exempel - Hitta ordantal i en text med hjälp av for for loop
• The While Loop
  • Exempel - Hitta en Fibonacci-sekvens upp till nionde termen med hjälp av While Loop
• Nestad slinga
  • # 1) Häckar för öglor
  • # 2) Nesting While Loops
  • Exempel - Numrer stavningsspel
• Python Infinite Loops
  • Python bryter och fortsätter uttalanden
  • Exempel - Samla in siffror tills en tröskel uppnås
  • Vanliga frågor
  • Mer om Python Loops
    • # 1) While loop:
    • # 2) För slinga:
• Slutsats
  • Rekommenderad läsning

Python Loops Video Tutorial

Vad är Python Loops

I Python körs uttalanden sekventiellt, dvs. om vår kod består av flera kodrader, kommer körningen att börja vid första raden, följt av den andra och så vidare.

Det kommer dock att finnas fall där vi kanske vill att ett kodblock ska köras flera gånger tills ett villkor är uppfyllt. Tack vare loop-uttalanden kan vi göra just det.

Nedan följer ett flödesschema som illustrerar hur ett loop-uttalande fungerar.

Baserat på ovanstående diagram börjar ett Python-program kl Start (cirkel), och körningen fortsätter till villkoret (Diamond), om villkoret är SANT, kommer programmet att köra kodblocket.

Körningen fortsätter igen till villkoret och samma process fortsätter varje gång när villkoret är SANT. Det bryter bara ut ur slingan eller slutar köra kodblocket om villkoret är FALSE, och i det här fallet fortsätter programmet körningen sekventiellt.

Python har två typer av loopar.

Dessa två typer av öglor kan användas inuti varandra för att generera kapslade öglor (mer om detta senare).

Allmän användning av Python Loops

I Python kan loopar användas för att lösa fantastiska och komplexa problem. Du kommer sannolikt att stöta på problem som kräver att du upprepar en åtgärd tills ett villkor är uppfyllt (medan loop fungerar bäst här) eller ett problem som kräver att du utför en åtgärd på en massa objekt (för loop fungerar bäst här).

För Loop In Python

De för loop fungerar bra med iterabla objekt som listor , tuplar , strängar osv. På så sätt kan vi gå igenom objektets objekt och manipulera deras värden baserat på vår länkning.

De för loop är nollindexerat och har följande syntax.

Villkoret i för loop förblir SANT endast om den inte har itererat genom alla objekt i det iterabla objektet (n). För att bättre förstå för loop kommer vi att ta itu med flera exempel och slutligen kommer vi att arbeta med ett praktiskt exempel.

Exempel 1:Skriv ut siffror från start till slut

För att uppnå detta kommer vi att använda Python räckvidd fungera.

Så här kommer flödesschemat att se ut:

Produktion

I exemplet ovan använde vi Python-intervallet, vilket är en funktion som returnerar en sekvens av siffror, med början från a Start nummer (0 som standard), steg med a steg (1 som standard) och stannar innan en slutet siffra.

För detta exempelhar vi följande:

Parametrar och värden för Python-intervallfunktionen

Så, vår för loop kommer att iterera genom en sekvens av siffror från 1 till 20, och för varje iteration kommer den att skriva ut numret. Iterationen slutar när alla siffror i sekvensen har besöks.

Exempel 2:Bestäm om ett tal är ett primtal.

I det här exemplet kommer vi att se varför för loop är så kraftfull och användbar. Här kommer vi att iterera genom en sekvens av siffror, och för varje nummer kommer vi att göra en viss beräkning för att avgöra om ett tillstånd är SANT eller FALSKT.

Det kan hjälpa att känna till villkoren för att ett nummer ska vara primärt.

• Antalet är alltid positivt, större än 1.
• Har inga positiva delare än 1 och sig själv.

Utgång när ingången är 13

Utgång när ingången är 10

Notera: De om annat används i exemplet ovan är ett villkorligt uttalande och inte en loop. Men precis som medan loop (som vi snart kommer att täcka) använder den jämförelseoperatörerna för sitt tillstånd.

Exempel - Hitta ordantal i en text med hjälp av for for loop

Detta exempel handlar om att räkna hur många gånger varje ord förekommer i en text. Det finns så många sätt som detta kan uppnås men för detta exempel ska vi använda för loop .

Vi kommer att räkna orden från texten nedan.

Hej, välkommen till Software Testing Help. I den här artikeln: ”Loops in Python” lär du dig om loopar med praktiska exempel. Bra, eller hur? Se till att följa med när vi lär oss tillsammans.

Lycklig kodning!

Det första vi ska göra är att ta bort interpunktioner, mellanslag och alla gemener. Vi tar bort skiljetecken på det traditionella sättet genom att identifiera vilka skiljetecken som finns i vår text och sedan använda för loop för att ersätta dem med en tom sträng.

Eftersom texten inte är mycket ser vi att skiljetecken är komma (,), period (.), frågetecken (?), kolon (:), dubbelt citattecken (“) Och apostrof (‘).

Nedan anges koden för att ersätta dem med en tom sträng. Observera att vi inte kommer att ersätta apostrof.

Produktion

Därefter delar vi upp texten i en lista över ord åtskilda av mellanslag.

Produktion

Slutligen kommer vi att räkna och se hur många gånger varje ord förekommer i den delade texten.

Produktion

Vi kan tydligt se att några ord visas två gånger och andra bara en gång. Låt oss ordna ordboken efter dess värde i fallande ordning så att vi tydligt kan skilja. Här har vi använt Python sorterad funktion , lambda-uttryck och ordbokförståelse .

var kan jag hitta nätverkssäkerhetsnyckeln

Slutligen har vi använt för loop för att rengöra, räkna och sortera orden i vår text.

Nedan följer den fullständiga koden.

Slutlig produktion

The While Loop

Python medan loop utför ett block av uttalanden upprepade gånger så länge villkoret är SANT. Vi märker att det är lite likt if uttalande . Men till skillnad från medan loop , if-uttalandet körs bara en gång om dess tillstånd är SANT.

While-slingan har följande syntax:

till skillnad från för loop , den medan loop itererar inte över en sekvens. Den använder jämförelseoperatörerna och booléerna för dess tillstånd.

Låt oss titta på några exempel för att bättre förstå hur den används.

Exempel 1:Skriv ut 'Hello World!' ett antal gånger

De medan loop kontrollerar tillståndet (räknaHej världen! ”Och ökar räkningen.

Så här kommer flödesschemat att se ut:

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

Produktion:

Exempel 2:Hitta ett faktum för ett nummer

Faktum av ett nummer representeras som n! och den har formeln

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

Programmet kontrollerar om numret är 0 och returnerar 1 (faktorn 0 är 1). Sedan medan loop kontrollerar villkoret (n> = 1) för att se om vårt n är lika med 1 eller större än 1. Varje gång när detta villkor är SANT, beräknar vårt program formeln i slingblocket

Låt oss använda stundslingan för att lösa det faktiska 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))

Produktion

Exempel - Hitta en Fibonacci-sekvens upp till nionde termen med hjälp av While Loop

En Fibonacci-sekvens har formeln.

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

De första två siffrorna är 0 och 1, sedan är nästa nummer summan av de två föregående siffrorna (n-1) th och (n-2) th.

Fibonacci-sekvensen på 8 blir 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

Vårt program definierar först det första n: te värdet (n1 = 0), sedan kontrollerar det om n_term skickas som ett argument är lika med 1. Om SANT returnerar det 0.

Annars definierar den två variabler:

• count = 0: Detta kommer att användas i medan loop för att kontrollera tillståndet om räkningen är mindre än n_term (räkna
• n2 = 1: Detta är vårt andra n: te värde.

Hittills har vi 0,1 i vår sekvens (n1, n2). Medan villkoret är SANT:

• Värdet på n2 tilldelas en tillfällig variabel (temp = n2).
• Summan av de två tidigare siffrorna beräknas och tilldelas n2 (n2 = n1 + n2).
• Vårt tillfälliga värde (n2 gammalt värde) tilldelas n1 (n1 = temp).
• Vårt antal ökas (räkna + = 1) och tillståndet kontrolleras igen.

I slutet av den första iterationen har vi 0,1,1 där:

• n1 = 1 (den första 1)
• n2 = 1 (den andra 1)

Denna åtgärd upprepas tills tillståndet räknas

Nestad slinga

Det häftiga med Python-slingor är att de kan kapslas, dvs. vi kan använda en eller flera slingor i en annan slinga. Detta gör att vi kan lösa ännu mer komplexa problem.

# 1) Häckar för öglor

för öglor kan vara kapslade i sig själva. Syntaxen nedan visar en 1-nivå kapslad för loop.

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

Exempel 1:Använd kapslad för loop för att skriva ut siffror i mönster

Låt oss använda den kapslade slingan för att skriva ut följande mönster:

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

Varje nummer skrivs ut ett antal gånger motsvarande numret i sig.

Så här kommer flödesschemat att 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()

Produktion

Vårt program fungerar enligt följande:

• Den yttre slingan går igenom intervallet från 1 till 6 och för varje objekt i den sekvensen.
• Den går in i den inre slingan där den itererar över ett intervall av det objektet.
• För varje iteration av det objektet skrivs det ut.
• Den lämnar bara den inre slingan när den har fullständigt itererat genom en rad objekt.
• När den lämnar den inre slingan går den tillbaka till den yttre slingan och processen fortsätter tills den har itererat helt över sin sekvens.

Exempel 2:Manipulera objekt i en kapslad lista med hjälp av en kapslad för loop

En situation som vi troligen kommer att stöta på i Python är att komma åt objekten i en kapslad lista.

Ta till exempel den kapslade listan nedan.

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

För detta exempel, låt oss skriva ett program som räknar antalet heltal och flottörer i den här kapslade listan.

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

Vårt program fungerar så här:

• Den yttre slingan öppnar de första inre listorna (3,4.0,2,8.4,6) i vår kapslade lista.
• Den inre slingan öppnar varje objekt i denna första inre lista. För varje artikel kontrolleras om det är ett flottör eller heltal. Om det är ett heltal, ökar det heltalet (int_count). Annars om det är en flottör, ökar den antalet float (float_count).
• När den har avslutat iterering genom denna första inre lista, flyttar den sedan tillbaka till den yttre slingan och kommer åt den andra listan (0,2,0.2,4,6) och samma process fortsätter tills den har åtkomst till alla inre listor.

# 2) Nesting While Loops

Medan öglor kan vara kapslade i sig själva.

Syntaxen nedan visar en 1-nivå kapslad medan loop.

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

Exempel 3:Använd kapslad medan slinga för att skriva ut stjärnor (*) i mönster

Låt oss använda kapslad medan loop för att konstruera följande mönster:

vad är nätverkssäkerhetsnyckel för wifi

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

Vårt program fungerar enligt följande:

• Variabler initialiseras (i = 0, j = 0, n = 5)
• Vår yttre slinga kontrollerar tillståndet (0<= 5) which is obviously TRUE.
• Vår inre slinga kontrollerar tillståndet (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
• jag ökas och den yttre slingan kontrollerar igen dess tillstånd (1<= 5) which is TRUE.
• Vår inre slinga kontrollerar tillståndet (0<1) which is TRUE. So a star( * ) skrivs ut och j ökas och tillståndet för den inre slingan kontrolleras med (1<1) which is FALSE, thus breaks out of the inner loop.

Processen ovan fortsätter tills det yttre slingans tillstånd blir FALSKT.

Exempel - Numrer stavningsspel

Att avrunda med en kapslad slinga , kommer vi att bygga ett spännande spel som hjälper till att utvärdera barnets förmåga att känna igen och stava nummer.

Programmet visar slumptal på skärmen och begär stavning av det numret. Den kontrollerar om ingången är korrekt och visar sedan ett annat nummer. Om ingången är fel skickar den ett felmeddelande och begär ett annat 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 viktigaste funktionerna i vår for-loop och while-loop är:

• De för loop det går igenom en lista med siffror som presenteras för användaren att stava.
• De medan loop kontrollerar om antalet försök har överskridits. På detta sätt ges en användare ett maximalt antal försök för att få det rätt.

Vi har sett två nya koncept medan-annat , ha sönder (mer om detta senare). De medan loop och för loop ursprungligen har en annat uttalande som bara körs en gång när villkoret är FALSE.

Python Infinite Loops

Om vi ​​inte är försiktiga med hur vi implementerar våra slingor kan det leda till en oändlig loop programmet kommer att köra ett kodblock för alltid tills vår dator tar slut på resurser som CPU-minne.

Exempel 1:Oändligt medan loop

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

Produktion

Notera : Använd Ctrl + z eller Ctrl + för att stoppa programmet c på terminalen som du använde för att köra koden.

Vår kod ovan implementerar en oändlig medan slinga . Detta är dock av misstag eftersom vår medan loop kontrollerar tillståndet bedövat<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å sättet att fixa detta är att tillhandahålla ett sätt att öka numbs värde.

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

En fråga kan uppstå som de är oändliga slingor verkligen nödvändigt? Spoilervarning: Ja, det är de. En server kan programmeras att köra kontinuerligt samtidigt som den tillgodoser klienternas behov. I spel kan en händelse köras tills användaren väljer en åtgärd för att avsluta eller bryta slingan.

Tro det eller inte, vi använde faktiskt en oändlig loop i det sista praktiska exemplet ovan. Så, hur hanterar vi det oändliga slingor ?

Python bryter och fortsätter uttalanden

Som vi förklarade ovan finns det fall där vi måste skriva avsiktligt oändliga slingor . I dessa fall kommer vi att se att ha sönder och Fortsätta nyckelord är ryggraden i oändliga slingor .

De ha sönder och Fortsätta nyckelord används ofta i en Python if uttalande där if-uttalandet kontrollerar ett villkor och om det är SANT, bryter vi antingen ut ur slingan där vårt if-uttalande anropades eller fortsätter genom att hoppa över all kod under det och återgå till början av slingan.

Exempel - Samla in siffror tills en tröskel uppnås

Låt oss överväga ett program som hämtar nummer från en slumpmässigt genererad källa och ackumulerar siffrorna tills en tröskel uppnås.

Anledningen till att detta exempel kräver en oändlig slinga är att vi inte vet exakt hur många iterationer vårt program kommer att behöva utföra för att de ackumulerade siffrorna ska nå tröskeln.

Vår enda frälsare är Python if uttalande tillsammans med bryta uttalande . Vårt if-uttalande kontrollerar om tröskeln nås, då bryter den ut ur slingan om SANT.

Vårt program kräver också att vissa begränsade nummer inte ska ackumuleras. Så om vårt program stöter på dessa siffror, bör det hoppa över alla koder och återgå till början av slingan. Detta kan uppnås med fortsätt uttalande .

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

Vanliga frågor

F # 1) Hur kontrollerar du en loop i Python?

Svar: I Python kan du styra en loop med följande kontrolluttalanden:

• De ha sönder nyckelord bryter ur en slinga.
• De Fortsätta nyckelordet hoppar över alla koder under det och återgår till början av slingan.

Dessa nyckelord används mest i en if uttalande som först kontrollerar om ett villkor är SANT eller FALSKT.

F # 2) Vad är skillnaden mellan för loop och while loop?

Svar: TILL för loop är en iteratorbaserad slinga , som går igenom objekten på iterabla objekt som listor , tuplar , etc. Medan a medan loop är en tillståndsbaserad slinga , som utför ett block av uttalanden upprepade gånger så länge dess tillstånd är SANT.

F # 3) Stöder Python till loop?

Svar: Tyvärr stöder Python inte gör-medan-slinga .

F # 4) Vilka är de två typerna av loopar i Python?

Svar: Python stöder vanligtvis två typer av slingor: för loop och medan loop . En tredje slinga ( kapslad slinga ) kan genereras genom att häcka två eller flera av dessa slingor.

Mer om Python Loops

Looping-uttalanden i python används för att köra ett block med uttalanden eller kod upprepade gånger flera gånger enligt vad som anges av användaren.

hur man öppnar en binär fil i Windows

Python ger oss två typer av slingor enligt nedan:

• While loop
• För loop

# 1) While loop:

While loop in python används för att köra flera uttalanden eller koder upprepade gånger tills det angivna villkoret är sant.

Vi använder en stundslinga när vi inte vet hur många gånger det ska upprepas.

Syntax:

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

I while-slingan kontrollerar vi uttrycket, om uttrycket blir sant, kommer bara det blocket med uttalanden som finns i while-slingan att köras. För varje iteration kommer den att kontrollera tillståndet och utföra blocket av uttalanden tills villkoret blir falskt.

Exempel:

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

Produktion:

10

Produktion:

# 2) För slinga:

För loop in python används för att köra ett block med uttalanden eller kod flera gånger tills det angivna villkoret blir falskt.

Vi använder for-loop när vi vet hur många gånger det ska göras.

Syntax:

for var in sequence: Block of code

Här tar var värdet från sekvensen och kör det tills alla värden i sekvensen är klara.

Exempel:

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

Produktion:

Aktuellt språk är: Python

Aktuellt språk är: Java

Aktuellt språk är: Ruby

Produktion:

För loop med hjälp av range () -funktionen:

Funktionen Range () används för att generera en sekvens av siffror.

Till exempel, intervall (5) genererar nummer från 0 till 4 (5 nummer).

Exempel:

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

Produktion:

Aktuellt språk är: Python

Aktuellt språk är: Java

Aktuellt språk är: Ruby

Produktion:

Slutsats

I denna handledning såg vi definitionen av loopar, typerna av Python-loopar, användning av för slinga, och medan loop med några exempel.

Vi lärde oss också hur kapslade öglor genereras och ändliga öglor också och vi lärde oss hur man använder ha sönder och Fortsätta nyckelord.

=> Kontrollera ALLA Python-handledning här

PREV-handledning | NÄSTA självstudie

Rekommenderad läsning

• Python Control Statements (Python Fortsätt, Break och Pass)
• Python-variabler
• Python-handledning för nybörjare (praktisk Python-träning)
• Python villkorliga uttalanden: if_else, elif, kapslade om uttalanden
• Python-operatörer
• Python-strängfunktioner
• Python DateTime-handledning med exempel
• Python-funktioner