Python Loops-tutorial

For-lus

Je kunt de for-lus op dezelfde manier benaderen als de while-lus. Zoals je waarschijnlijk verwacht had, verwijst het "for"-deel in "for-lus" naar iets dat je doet voor een bepaald aantal keren.

Als je dit in gedachten houdt, kun je de for-lus eenvoudig als volgt definiëren:

Een for-lus is een programmeerconcept dat, wanneer geïmplementeerd, een stuk code steeds opnieuw uitvoert "voor" een bepaald aantal keren, gebaseerd op een sequentie.

In tegenstelling tot de while-lus is er geen actieve voorwaarde betrokken: je voert simpelweg een stuk code herhaaldelijk uit voor een aantal keren. Met andere woorden, terwijl de while-lus het codeblok alleen blijft uitvoeren zolang de voorwaarde True is, voert de for-lus de code alleen uit voor een specifiek aantal keren. Dit "aantal keren" wordt bepaald door een sequentie of een geordende lijst van dingen.

Je leert zo meer over het verschil tussen while- en for-lussen, maar concentreer je nu op de onderdelen die je nodig hebt om een for-lus te maken:

• Het for-keyword
• Een variabele
• Het in-keyword
• De functie range(), een ingebouwde functie in de Python-bibliotheek om een getallensequentie te maken
• De code die je herhaaldelijk wilt uitvoeren

For-lussen in Python

# Print "Thank you" 5 times
for number in range(5):
    print("Thank you")

# Thank you
# Thank you
# Thank you
# Thank you
# Thank you

Zoals je ziet, keren de onderdelen die je hierboven zag terug in dit kleine voorbeeld van een for-lus in Python: het for-keyword, de variabele number, het in-keyword, de functie range() en de code die je meerdere keren wilt uitvoeren, print("Thank you").

Niet zo moeilijk, toch?

Bekijk nog een voorbeeld van een for-lus, waarin je twee variabelen gebruikt om je control flow te bepalen:

languages = ['R', 'Python',  'Scala', 'Java', 'Julia']

for index in range(len(languages)):
   print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Julia

Je begint de lus met het for-keyword. Vervolgens gebruik je de variabelen index en languages, het in-keyword en de functie range() om een sequentie van getallen te maken. Daarnaast gebruik je hier ook de functie len(), omdat de lijst languages niet numeriek is. Het stuk code dat je herhaaldelijk wilt uitvoeren is een print-statement, namelijk print('Current language :', languages[index]).

In de bovenstaande lus wil je uitdrukken dat je voor elke index in het bereik len(languages) de programmeertaal voor data science wilt printen. Nu is len(languages) 5, dus de instructie zou ook herschreven kunnen worden als:

for index in range(5):
    print('Current language:', languages[index])

# Current language: R
# Current language: Python
# Current language: Scala
# Current language: Java
# Current language: Julia

En dit geeft je opnieuw hetzelfde resultaat!

While versus for-lussen in Python

Laten we nog eens teruggaan naar het allereerste voorbeeld van de while-lus om nu precies te bepalen wat de verschillen zijn tussen while- en for-lussen. Je las hierboven al dat het verschil ligt in de wel of niet betrokken voorwaarde, maar hoe zie je dat terug in de code en hoe kun je eventueel tussen beide wisselen?

# Take user input
number = 2  

while number < 5 :
    print("Thank you")
    # Increment `number` by 1
    number = number+1

# Thank you
# Thank you
# Thank you

Je kunt een for-lus gebruiken om de tekst "Thank you" op een meer gecontroleerde manier te printen:

# Print "Thank you" 3 times
for number in range(3) :  
    print("Thank you")

# Thank you
# Thank you
# Thank you

Zie je hoe makkelijk het was om de while-lus om te zetten naar een equivalente for-lus?

Hoe werkt dat, vraag je? Simpel.

In een for-lus is het geheel getal in de range-functie het bereik of het aantal keren dat de besturing moet loopen en de code in de clausule van de for-lus moet uitvoeren.

Let op dat de telling van de functie range() begint bij 0 en niet bij 1. Dat betekent dat in het bovenstaande voorbeeld de telling 0,1,2 is en niet 1,2,3. Zo werkt tellen in het geheugen van een computer. Houd dus bij het ontwerpen van een for-lus altijd in gedachten dat je de telling van range vanaf 0 moet nemen en niet vanaf 1.

Tip: dit geldt bijvoorbeeld ook voor lijsten in Python. Wil je meer weten over Python-lijsten, bekijk dan de tutorial van DataCamp: 18 Most Common Python List Questions.

Er is nog een interessant verschil tussen een for-lus en een while-lus. Een for-lus is sneller dan een while-lus. Om dit te begrijpen, bekijk je het onderstaande voorbeeld.

import timeit

# A for loop example
def for_loop():
    for number in range(10000) :  
        # Execute the below code 10000 times
        sum = 3+4
        #print(sum)

timeit.timeit(for_loop)

# 267.0804728891719

import timeit

# A while loop example
def while_loop():
    i =0
    while i<10000:
        sum = 3+4
        #print(sum)
        i+=1

timeit.timeit(while_loop)

# 884.9233417965908

In de bovenstaande codeblokken heb je twee lussen met ongeveer 10.000 iteraties. Beide lijken op het eerste gezicht hetzelfde, totdat je onder de motorkap kijkt en begrijpt hoe deze twee lussen werken. Hint: de functie timeit() geeft je een aanwijzing over wat het verschil zou kunnen zijn!

Onthoud: alle Python-code wordt gecompileerd met een C-compiler, wat betekent dat de code die je hierboven ziet eerst wordt omgezet in bytecode en vervolgens verwerkt door de onderliggende C-compiler.

Wanneer de uitvoering van de for-lus in het bovenstaande voorbeeld start, praat de Python-interpreter met de onderliggende C-compiler en maakt vervolgens een list-object van grootte 10.000. Daarna roept hij een iterator aan om de index van elk van de 10.000 items in de lijst te doorlopen.

De uitvoering van de while-lus daarentegen maakt geen list-object. De onderliggende C-compiler roept in feite 9.999 keer de booleaanse vergelijkingsoperator aan voor de voorwaarde i<10000.

Je kunt je al voorstellen dat itereren over een al aangemaakt list-object met 10.000 elementen voor de compiler eenvoudiger is dan herhaaldelijk 9.999 keer een booleaanse operatie uitvoeren; de tijdsprestaties van een for-lus zijn dus beter dan die van een while-lus. Dat zie je duidelijk terug in de uitvoeringstijd: de tijd die de for-lus nodig heeft om te voltooien is veel kleiner dan de tijd die de while-lus nodig heeft.

Probeer nu de for-lus! Let erop dat je het bereik van 0 tot en met 11 wilt specificeren, omdat je alleen de getallen in de reeks tot 55 wilt tonen, wat het 11e getal in de reeks is.

Geneste lussen

Zoals je in een voorbeeld hierboven ziet, staat er een if-else-voorwaarde binnen de while-lus, waarmee je extra voorwaarden in je code kunt introduceren.

Wacht even!

Dit is niet de enige manier waarop je je lus kunt aanpassen. Je kunt ook extra while-lussen opnemen in je bestaande code; dit heet een geneste lus. Je kunt het bovenstaande voorbeeld aanpassen om nog een while-lus toe te voegen, zoals hieronder:

# Take user input
number = 2 

# condition of the while loop
while number < 5 :  
    # condition of the nested while loop    
    while number % 2 == 0: 
        print("The number "+ str(number)+" is even")

In het bovenstaande voorbeeld staat nog een while-lus die is "genest" binnen de buitenste lus; deze binnenste lus voert nog een extra check uit om te zien of number % (mod) 2 gelijk is aan 0.

Met andere woorden: er wordt gecontroleerd of het getal even is, en vervolgens wordt de tekst "The number is even" geprint.

Maar er is een addertje onder het gras: als je goed kijkt, zie je dat, net als in de vorige code, de instructie number=number+1 dit keer ontbreekt. Omdat je de variabele number nergens verhoogt, blijft de waarde van de variabele steeds hetzelfde en gaat de code een oneindige lus in. Dat betekent dat, zodra hij de lus binnenkomt, hij die nooit meer verlaat en de tekst een oneindig aantal keren print, omdat de variabele number altijd 2 zal zijn. Dit getal is uiteraard kleiner dan 5 en even.

Bekijk nu hoe een geneste for-lus eruitziet:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    # Inner loop
    for another_number in range(5):  
        print("****************************")
        print("I am inner loop iteration "+str(another_number))

-------------------------------------------
I am outer loop iteration 0
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 1
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 2
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4

De bovenstaande code is een aangepaste versie van het eerste for-lus-voorbeeld. Let op hoe een tweede for-lus binnen de buitenste lus wordt gebruikt.

Voer de code vooral uit.

Je zult merken dat de besturing de eerste for-lus binnenkomt en de waarde van de variabele number wordt geïnitialiseerd als 0. De eerste print-instructie wordt uitgevoerd en vervolgens gaat de besturing de tweede for-lus in, waar de waarde van de variabele another_number wordt geïnitialiseerd op 0. De eerste print-instructie in de tweede for-lus wordt eenmaal uitgevoerd.

Daarna keert de besturing terug naar de binnenste for-lus en wordt de waarde van another_number opnieuw ingesteld op het volgende geheel getal, waarna de instructie in de functie print() wordt geprint.

Dit proces gaat door totdat de besturing het einde van de functie range() heeft bereikt, wat in dit geval 5 is, en dan keert de besturing terug naar de buitenste lus, initialiseert de variabele number met het volgende geheel getal, print de instructie in de functie print(), bezoekt de binnenste lus en herhaalt al deze stappen totdat de functie range() is doorlopen.

Deze reis van de besturing van de buitenste lus, via de binnenste lus en weer terug naar de buitenste for-lus gaat door totdat de besturing het volledige bereik heeft afgelegd, wat in jouw geval 3 keer is.

Nu je wat uitleg over geneste lussen hebt gelezen, is het tijd om zelf aan de slag te gaan! Schrijf een Python-programma om het volgende patroon te maken met een geneste for-lus:

break en continue-keywords: oneindige lussen maken

Je kunt break en continue gebruiken in elke lus die je maakt. Deze keywords zijn niet beperkt tot het onderbreken van opzettelijke oneindige lussen, maar je moet ze wel zorgvuldig gebruiken. Beide keywords maken het voor anderen —en voor jezelf over een paar maanden als je je code terugziet— lastiger om de control flow in de lus en waar de voorwaarde eindigt te begrijpen. Bovendien hoef je de break- en continue-keywords niet te gebruiken: zoals je tot nu toe hebt gezien, ging het prima zonder!

Toch kan het in sommige gevallen duidelijker zijn om opzettelijke oneindige lussen te schrijven in plaats van de traditionele for- en while-lussen die je tot nu toe hebt gezien. In die gevallen is het gebruik van deze keywords natuurlijk aan te raden!

While-lussen onderbreken en overslaan in Python

Gelukkig is er een manier om uit de bovenstaande situatie van een oneindige lus te breken, en dat is met het break-keyword.

# Take user input
number = 2 

# Condition of the while loop
while number < 5 :  
    # condition of the nested while loop
    while number % 2 == 0:  
        print("The number "+str(number)+" is even")
        break

    number+=1

Als je de bovenstaande code uitvoert, gaat deze niet meer een oneindige lus in.

"Wat is dit voor tovenarij!" roep je. - Rustig maar, geen tovenarij.

Wat er gebeurt, is dat wanneer de besturing het break-keyword tegenkomt, hij begrijpt dat hij de lus moet verlaten (in dit geval de binnenste lus) en de volgende regel code moet uitvoeren. Hij breekt dus uit de binnenste while-lus en gaat verder met de buitenste lus en doet zijn gebruikelijke werk zolang de voorwaarde in de buitenste while-lus waar is.

Houd er rekening mee dat er een coderegel moet bestaan na het break-keyword, anders heeft het geen effect. Probeer de coderegel na het break-keyword in het bovenstaande voorbeeld te verwijderen en voer dan de code uit.

Wat als je stiekem het continue-keyword na de break-instructie zet? Volg de onderstaande code:

number = 2 

while number < 5 :
    while number % 2 == 0: 
        print("The number "+str(number)+" is even")
        break

    continue

    number+=1

De bovenstaande code is een licht aangepaste versie van het break-keyword-voorbeeld.

Als je de bovenstaande code uitvoert, kom je opnieuw in een oneindige lus terecht. Voordat je uit frustratie aan je haar begint te trekken, kijk nog eens goed. Je zult zien dat er een continue-keyword staat na de break. Wat het continue-keyword doet, is de besturing terugsturen naar de buitenste lus nog voordat de variabele number wordt verhoogd, en daardoor gaat de code een oneindige lus in.

For-lussen onderbreken en overslaan

Wat als je de binnenste for-lus in het bovenstaande voorbeeld niet voor het hele bereik wilt uitvoeren? Je kunt een break-instructie op een vergelijkbare manier gebruiken als bij de while-lus.

# Print the below statement 3 times
for number in range(3) : 
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

In het bovenstaande voorbeeld instrueert het break-keyword na de binnenste lus de besturing om weg te breken uit de binnenste lus, waarna de besturing terugkeert naar de buitenste lus.

Voer het onderstaande codevoorbeeld uit:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    continue
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

In de bovenstaande code wordt alleen de buitenste lus uitgevoerd en raakt de besturing de binnenste lus niet eens aan.

"Waarom?" vraag je.

Kijk nog eens goed naar de code. Er staat een continue-keyword direct na de tweede print-instructie in de buitenste lus. Dat zorgt ervoor dat de besturing terug springt naar de buitenste for-lus en opnieuw begint, en daarom komt de besturing nooit aan de binnenste lus toe.

In tegenstelling tot de while-lus heb je in de for-lus geen stuk code nodig na het break-keyword. Alleen een break werkt prima binnen een for-lus.

range() versus xrange()

Deze twee functies lijken op elkaar, maar als je Python 3 gebruikt, heb je alleen de functie range() beschikbaar. In Python 3.x is de functie xrange() hernoemd naar range(). Dat betekent dat als je de functie xrange() probeert te gebruiken met Python 3, je de fout NameError: name 'xrange' is not defined krijgt.

Om te begrijpen hoe deze twee functies overeenkomen, bekijk je het volgende voorbeeld:

# Print the below statement 3 times
for number in range(5,10,2) :  
    print("I am number : "+str(number))

# I am number : 5
# I am number : 7
# I am number : 9

Als je de bovenstaande code uitvoert, zie je hoe de waarde van de variabele number met een factor 2 wordt overgeslagen, en dat komt door de parameters in de functie range().

De eerste parameter in deze functie is de start-parameter. Dat is het punt vanaf waar de besturing begint te tellen. De tweede parameter is de stop-parameter; dat is het punt waar de besturing moet stoppen. De laatste parameter is de stap, die bepaalt met welke factor de besturing moet springen tijdens het tellen.

In het bovenstaande geval begint de besturing dus bij 5, doorloopt de lus tot en met 9 en telt daarbij telkens 2 op. Dat betekent 5, 5+2=7, 7+2=9.

Je hebt geleerd hoe de functie range() wordt gebruikt om te bepalen hoe vaak je code moet loopen. In Python 2.x vind je nog een andere manier om dit te doen, namelijk met de functie xrange(). Voer de onderstaande code uit:

# Print the below statement 3 times
for number in xrange(10) :  
    print("I am number : "+str(number))

I am number : 0
I am number : 1
I am number : 2
I am number : 3
I am number : 4
I am number : 5
I am number : 6
I am number : 7
I am number : 8
I am number : 9

Welk verschil zie je in de output van de bovenstaande code versus de output van de code zonder de functie xrange()? Geen verschil?

Klopt. Je ziet geen verschil in de output van de code.

Waarom zou je dan de functie xrange() gebruiken? Daar kom je later in de tutorial op terug. Voer eerst de onderstaande code uit:

print(xrange(10))
print(range(10))

xrange(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Je ziet dat er in de output van de bovenstaande code een verschil zit tussen beide print-statements. In het print-statement met de functie xrange() wordt het xrange()-functieobject geprint. Dit is anders dan in het print-statement met de functie range(): daar krijg je een lijst met gehele getallen van 0 tot en met 9.

Dit is precies het verschil tussen de functie range() en de functie xrange().

Wanneer je de functie range() definieert, wordt een lijst van het volledige bereik in het RAM opgeslagen en aan je gepresenteerd. Wanneer je echter de functie xrange() definieert, wordt er geen lijst in het geheugen opgeslagen. In plaats daarvan genereert de functie xrange() gehele getallen in het volledige bereik wanneer je ze nodig hebt. Op deze manier helpt de functie xrange() om geheugen te besparen op systemen met beperkte middelen.

Scherp je Python-skills aan!

Gefeliciteerd, je bent aan het einde van deze tutorial gekomen. Nu je hebt geleerd hoe je lussen in Python gebruikt, kun je aan de slag met oefenen. Hoe meer je oefent, hoe beter!