11. While loops#

De volgende code tekent een vierkant met Python turtle:

turtle_square.py#

import turtle

tony = turtle.Turtle()

tony.fd(100)
tony.lt(90)
tony.fd(100)
tony.lt(90)
tony.fd(100)
tony.lt(90)
tony.fd(100)
tony.lt(90)

De regels 5 t/m 11 bevatten veel herhaling. Het zou beter zijn als we tegen Python konden zeggen: ‘voer de regels 5 en 6 vier keer achter elkaar uit.’ Dat scheelt typwerk en het maakt de code overzichtelijker.

Vergelijkingsoperatoren#

Voordat we de while loop introduceren, moet je weten wat een vergelijkingsoperator is. Het begrip operator ben je eerder tegengekomen in het hoofdstuk Berekeningen in de CLI bij de behandeling van de rekenkundige operatoren: de symbolen die je gebruikt voor berekeningen zoals +, * en //. Vergelijkingsoperatoren zijn symbolen die je gebruikt om twee waarden met elkaar te vergelijken. We hebben er zes:

Vergelijkingsoperatoren

Operator	Naam	Voorbeeld	Uitkomst
`==`	Gelijk aan	`1 == 2`	`False`
`!=`	Niet gelijk aan	`1 != 2`	`True`
`>`	Groter dan	`3 > 3`	`False`
`<`	Kleiner dan	`4 < 5`	`True`
`>=`	Groter of gelijk aan	`3 >= 3`	`True`
`<=`	Kleiner of gelijk aan	`4 <= 5`	`True`

Je kunt de werking van de vergelijkingsoperatoren testen in de CLI:

Let op het verschil tussen de assignment operator = en de vergelijkingsoperator ==. Deze twee moet je niet met elkaar verwarren.

Code herhalen#

Maak in Mu editor een nieuw bestand, kopieer en plak de onderstaande code erin en sla het op als turtle_while.py.

turtle_while.py#

import turtle

tony = turtle.Turtle()

zijde = 0
while zijde < 4:
    tony.fd(100)
    tony.lt(90)
    zijde = zijde + 1

Run de code om het resultaat te bekijken. Snap je hoe deze code werkt? Het Python keyword while in regel 6 kun je vertalen als terwijl of zolang. En de vergelijkingsoperator < symbool betekent kleiner dan. Je kunt deze regel dus lezen als ‘Zolang de waarde van zijde kleiner is dan 4:’. Let ook op de dubbele punt : aan het einde van deze regel.
Schematisch weergegeven doet de code het volgende:

@startuml
<style>
activityDiagram {
FontName Monospaced
FontSize 15
}
document {
BackgroundColor transparent
}
</style>
start
:zijde = 0;
while (zijde < 4) is (True)
:tony.fd(100);
:tony.lt(90);
:zijde = zijde + 1;
endwhile (False)
stop
@enduml

Eerst krijgt de variabele zijde de waarde 0. Vervolgens checkt Python of zijde kleiner is dan 4. Als dat zo is, wordt tony vooruit gestuurd en gedraaid. Daarna wordt de waarde van zijde met 1 opgehoogd. We springen terug naar regel 6 en Python checkt weer of zijde kleiner is dan 4.

We gebruiken de variabele zijde in dit voorbeeld als een teller variabele. De waarde ervan geeft aan hoeveel zijden er tot op dat moment zijn getekend. Doordat we de waarde van zijde na elke tekenactie ophogen, zal de check in regel 6 op een zeker moment False zijn. De uitvoering van de loop stopt, en in dit geval is het programma dan ook afgelopen.

Debugging mode#

Mu editor biedt de mogelijkheid om de uitvoering van een programma stap voor stap te volgen. Je kunt op die manier goed zien hoe de while loop werkt.

Klik op regel 6 in turtle_while.py met de muiscursor in het grijze stukje rechts naast het regelnummer 6 om een zogenoemd breakpoint te plaatsen.

Klik daarna op Debug bovenin de knoppenbalk.

Nu start Mu editor de uitvoering van de code, maar pauzeert op regel 6, waar je zojuist het breakpoint plaatste. Gebruik de knop Step over om de code vanaf het breakpoint telkens een stapje verder uit te voeren. Houd daarbij in de gaten wat er in de turtle tekening gebeurt, maar ook wat de waarde van de variabele zijde is. Die waarde wordt in Mu editor aan de rechterkant getoond.

Begrijp je nu hoe de while loop werkt? Klik op Stop om het debuggen te stoppen.

In de volgende opdrachten ga je je eigen while loops schrijven. Je zult merken dat je met loops mooie patronen kunt tekenen.

Indentation#

Kijk nog eens goed naar de regels 7, 8 en 9 van turtle_while.py. Deze regels zijn ingesprongen. Dat is belangrijk! Daardoor weet Python dat die drie regels binnen de ‘while lus’ vallen. In Python bepaalt de inspringing (Engels: indentation) van een coderegel tot welk blok die regel behoort. Kopieer de onderstaande code naar Mu editor (in een bestand hello_while.py) om te zien hoe dat werkt:

hello_while.py#

i = 0
while i < 3:
    print('Deze zin wordt drie keer geprint.')
    print('En deze zin valt ook binnen de while lus.')
    i = i + 1
print('Maar deze zin wordt slechts één keer geprint.')

De regels 3, 4 en 5 van hello_while.py zijn ingesprongen: ze worden voorafgegaan door 4 spaties. Daardoor weet Python dat die regels één blokje vormen binnen de while lus. Regel 6 is niet ingesprongen en hoort daardoor niet bij het blokje dat wordt herhaald.

Bestudeer nu de volgende code eens, nadat je hem in Mu editor hebt uitgevoerd. Je ziet hier een while lus bínnen een andere while lus.

turtle_while.py#

import turtle

tony = turtle.Turtle()

vierkant = 0
while vierkant < 3:
    zijde = 0
    while zijde < 4:
        tony.fd(100)        # Deze regels
        tony.lt(90)         # vallen binnen
        zijde = zijde + 1   # de 2e while lus
    tony.pu()
    tony.lt(120)
    tony.fd(100)
    tony.pd()
    vierkant = vierkant + 1

De regels 7 t/m 16 in deze code vallen binnen de while lus die begint op regel 6. Maar in dat blok begint op regel 8 een tweede while lus, die de regels 9 t/m 11 herhaalt. Let op de inspringing van regel 12: die valt niet meer onder de tweede while lus.

Wanneer je in Mu editor op Enter drukt nadat je regel 6 hebt getypt, springt de volgende regel automatisch in. Wil je handmatig een regel laten inspringen, dan kun je daarvoor de Tab toets gebruiken (links naast de Q).

Verschillende voorwaarden#

In de voorgaande voorbeelden gebruikten we in de voorwaarde van de while loop telkens een teller variabele, oftewel een integer. Maar je kunt in de voorwaarde van een while loop ook andere datatypes gebruiken, zoals een string:

annoying_while.py#

name = ''
while name != 'je naam':
    name = input('Typ je naam: ')

print('Dankjewel!')

Probeer dit programma maar eens uit. Het is afkomstig uit het boek Automate the Boring Stuff van Al Sweigart. Daarin heet dit programma An Annoying while Loop. Kun je bedenken waarom?

Hieronder zi je het stroomdiagram dat hoort bij de code. Er wordt nu geen integer variabele gebruikt voor de while loop, maar een string naam. Zolang de waarde van naam ongelijk is aan 'je naam' blijft de loop zich herhalen.

@startuml
<style>
activityDiagram {
FontName Monospaced
FontSize 15
}
document {
BackgroundColor transparent
}
</style>
start
:naam = '';
while (naam != 'je naam') is (True)
:name = input('Typ je naam: ');
endwhile (False)
:print('Dankjewel!');
stop
@enduml

Je kunt in de voorwaarde van de while loop variabelen ook helemaal achterwege laten, zoals in het volgende voorbeeld:

endless_while.py#

while True:
    print('Dit stopt niet meer!')

Met while True: creëer je een oneindige loop. Er zijn wel mogelijkheden om daar weer uit te ontsnappen, maar die bewaren we voor een ander moment. Uiteraard wil je liever niet dat je programma in een loop blijft hangen waar de gebruiker nooit meer uitkomt. Let dus altijd goed op wanneer je een while loop programmeert.