Inleiding tot Python Nested Loops

Welkom bij een ander hoofdstuk in de Python-leercursus - Nested Loops. Een uitstekende manier om een ​​lus te herhalen, heeft geneste lussen hun waarde bewezen in elke programmeertaal. Vandaag zullen we ons specifiek richten op Python - de typen, de syntaxis en de voorbeelden. Dus laten we beginnen.

Geneste lussen

Het zou goed zijn om kort in te gaan op Nested Loops in het algemeen, voordat u specifiek verdergaat met Python. Als er een lus bestaat in het lichaam van een andere lus, wordt deze aangeduid als geneste lus. Dit betekent dat we de binnenluscode meerdere keren willen uitvoeren. De buitenste lus bepaalt hoeveel iteraties de binnenste lus zal ondergaan. Een basisvoorbeeld van een geneste lus is:

for (i=0; i<10; i++)
(
for (j=0; j<10; j++)
(
//This code will execute 100 times.
)
//This code will execute 10 times.
)

Een ding om op te merken is dat elk type lus in een andere lus kan worden genest. Een while-lus kan bijvoorbeeld worden genest in een for-lus of omgekeerd.

Python geneste loops

1) Genest voor lus-syntaxis

De basissyntaxis van een geneste for-lus in Python is:

for (iterating_variable_1) in (sequence_1): #Outer Loop
for (iterating_variable_2) in (iterating_variable_1/sequence_2): #Inner Loop
(code to execute)

Voorbeeld

for i in range(11): #line 1
for j in range(i): #line 2
print('*', end='') #line 3
print('') #line 4

Output:

Uitvoeringsstroom

Laten we proberen de uitvoeringsstroom van het bovenstaande programma te begrijpen. In het programma hebben we twee iteratievariabelen i en j gebruikt om een ​​patroon van sterren af ​​te drukken.

De compiler begint met regel 1. Het komt een for-lus en een bereikfunctie tegen. De bereikfunctie in Python voert een itereerbare array van gehele getallen uit van 0 tot het getal dat in het argument is opgegeven. Het argumentnummer is uitgesloten van de array. In ons geval zal het een array genereren (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10). Nu weet de compiler dat hij de volgende reeks instructies 10 keer moet uitvoeren.

Wanneer het naar regel 2 gaat, ontmoet het een andere voor lus- en bereikfunctie. Merk op dat het argument voor deze bereikfunctie een berekende waarde is van onze iteratievariabele i. Het genereert dus dynamisch een array, afhankelijk van de waarde van i. Wanneer i = 0, is de array leeg. Wanneer i = 1, is de array (0). Wanneer i = 2, is de array (0, 1) enzovoort.

Het aantal keren dat regel 3 direct wordt uitgevoerd, is dus afhankelijk van de waarde van i. Let op het onderdeeleinde = '' inline 3. Dit is om te voorkomen dat Python na elke ster een lijninvoer afdrukt. We willen alleen een linefeed aan het einde van elke iteratie van de buitenlus. Daarom hebben we expliciet een linefeed afgedrukt in regel 4 van onze code.

Laten we nu dus elke iteratie van onze geneste for-lus nauwkeurig onderzoeken.

Buitenste lusherhaling 1

I = 0, j = (), output is a blank line.

Outer Loop Iteration 2

I = 1, j = (0), output = *

Outer Loop Iteration 3

I = 2, j = (0, 1), output = **

Outer Loop Iteration 4

I = 3, j = (0, 1, 2), output = ***

.
.
.

Buitenste lusherhaling 10

I = 9, j = (0, 1, 2, 3, 4, 5, 6, 7, 8), output = *********

Buitenste lusherhaling 11

I = 10, j = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9), output = **********

2) Genestelde lus

Syntaxis

De syntaxis voor het nestelen terwijl lus in Python is:

while (expression_1): #Outer loop
(code to execute) #Optional
while (expression_2): #Inner loop
(code to execute)

In tegenstelling tot de for-lus heeft de while-lus geen vooraf gecompileerde iterabele reeks. While loop blijft de code uitvoeren totdat de expressie de waarde true geeft. Een ontwikkelaar moet dus altijd rekening houden met het bijwerken van de itererende variabele / uitdrukking, anders gaat de lus naar de oneindige uitvoeringsmodus.

Voorbeeld

i=1 #line 1
while(i<=5): #line 2
j=5 #line 3
while(j>=i): #line 4
print(j, end=' ') #line 5
j-=1 #line 6
i+=1 #line 7
print() #line 8

Output:

Uitvoeringsstroom

Regel 1 van de code stelt de itererende variabele van de buitenste lus in op de beginwaarde. De volgende regel is het begin van de buitenste lus. Het heeft een uitdrukking i <= 5. Deze uitdrukking wordt na elke iteratie geëvalueerd op ware waarde. De uitvoering komt alleen in de lus als de voorwaarde waar is. Zodra de voorwaarde onwaar wordt, wordt de lus beëindigd.

Omdat de beginwaarde van I 1 is, is de voorwaarde in regel 2 waar. De compiler gaat dus naar regel 3 en stelt de itererende variabele j van onze binnenlus in op 5. Regel 4 heeft weer een while-lus met een expressie die evalueert naar true. De compiler voert dus regel 5 en 6 uit. Vervolgens gaat hij terug naar regel 4 en evalueert de voorwaarde. Als de voorwaarde waar is, gaat deze opnieuw regel 5 en 6 binnen. Als de voorwaarde vals wordt, wordt de lus beëindigd en worden de volgende uit te voeren regels regel 7 en 8. Hetzelfde wordt gevolgd voor de buitenste lus.

Regel 6 en 7 zijn erg belangrijk omdat ze onze iteratievariabele bijwerken. Zonder hen zou de programmastroom de oneindige uitvoeringsmodus ingaan, omdat de while-lusuitdrukkingen altijd in waarheid zouden resulteren.

Moet ik breken, doorgaan of slagen

Zoals met bijna alle andere programmeertalen, heeft Python ook het concept van breken en doorgaan. Deze trefwoorden helpen elke lus te beëindigen of een bepaalde iteratie van de lus over te slaan. Python heeft ook nog een ander sleutelwoord - pass. Laten we deze eens bekijken.

1) Pauze

Het sleutelwoord break geeft de compiler aan om uit een lus te springen en de uitvoering te beëindigen.

Voorbeeld

for i in range(5):
for j in range(5):
if i == j:
break
print(j, end='')
print('')

Output:

Het bovenstaande programma verbreekt de binnenste lus als de waarde van I en j gelijk is. Het voert geen verdere iteraties van de lus uit. Dit kan verder worden begrepen met de continue verklaring.

2) Doorgaan

Het sleutelwoord continue geeft de compiler aan om de huidige iteratie van de lus over te slaan en door te gaan met de volgende iteratie.

Voorbeeld

for i in range(5):
for j in range(5):
if i == j:
continue
print(j, end='')
print('')

Output:

Merk op dat hetzelfde programma, maar met de instructie continue in plaats van break, de uitvoering van de lus niet beëindigt. Het slaat alleen de huidige iteratie over.

3) Pass

Het sleutelwoord pass is interessant in Python. Het betekent gewoon niets doen. Het wordt gebruikt wanneer het codeblok syntactisch nodig is, maar u wilt niet dat een opdracht wordt uitgevoerd. Het fungeert gewoon als een tijdelijke aanduiding.

Voorbeeld

for i in range(5):
for j in range(5):
if i == j:
#I am not sure what to do when i equals j, so for now I will pass.
pass
print(j, end='')
print('')

Output:

Conclusie

Lussen zijn strategisch erg belangrijk om een ​​taak te leren uitvoeren met minimale coderegels. Dit is slechts een basisintroductie van lussen. Het wordt aanbevolen om meer te spelen, creatief te worden en het potentieel van lussen verder te verkennen.

Aanbevolen artikelen

Dit is een gids voor Python Nested Loops. Hier bespreken we de Python Nested Loops met de syntaxis, voorbeelden, uitvoer en uitvoeringsstroom. U kunt ook het volgende artikel bekijken voor meer informatie -

  1. Python Frameworks
  2. Hoe Python te installeren
  3. Gids voor Loops in Python
  4. Wat is Java-interface?
  5. Verschillende soorten loops met zijn voordelen
  6. Lussen in VBScript met voorbeelden

Categorie:

Software ontwikkeling