while-lussen — lopen zolang een voorwaarde waar is

Het probleem dat we oplossen

In het vorige hoofdstuk hebben we leren ongeldige invoer op te vangen — als iemand twenty typt, kan het programma zeggen "dat is geen getal".

Maar wat doet het daarna? Het stopt. De persoon moet het hele programma opnieuw starten. Echte software werkt zo niet — die vraagt opnieuw, en blijft vragen tot er een geldig antwoord is.

Daar zijn lussen (loops) voor: hetzelfde werk herhalen zolang het nodig is. Vandaag leer je while, die doorloopt zolang een voorwaarde waar blijft.

Er wacht vandaag ook een nieuwe ervaring op je: een programma dat maar niet stopt, met tekst die door de terminal raast. Je hoeft niet bang te zijn — je leert in dit hoofdstuk hoe je het stopt.

Aan het einde van dit hoofdstuk kun je

• Een while-lus schrijven en aangeven wanneer hij stopt
• Herkennen waarom oneindige lussen ontstaan, en hoe je er een stopt met Ctrl + C
• Een som of een teller opbouwen binnen een lus
• break en continue op de juiste plekken gebruiken
• Blijven vragen tot de invoer geldig is

Voorkennis: Beslissingen nemen — if, elif, else.

De eenvoudigste lus

count = 3

while count > 0:
    print(count)
    count = count - 1

print("Go")

3
2
1
Go

De vorm lijkt precies op een if — voorwaarde, dubbele punt, ingesprongen blok. Er is één verschil, en dat is alles: een if controleert de voorwaarde één keer; een while controleert hem opnieuw telkens als het blok klaar is.

Wat het programma hierboven deed:

1. count is 3. De voorwaarde 3 > 0 is waar → het blok liep, printte 3, en count werd 2
2. Voorwaarde opnieuw: 2 > 0 is waar → printte 2, count werd 1
3. Voorwaarde opnieuw: 1 > 0 is waar → printte 1, count werd 0
4. Voorwaarde opnieuw: 0 > 0 is onwaar → de lus stopte en het programma ging verder

Elke werkende while-lus heeft drie onderdelen, en alle drie zijn nodig:

• Een startwaarde — vóór de lus (count = 3)
• Een voorwaarde — wanneer er doorgegaan moet worden (count > 0)
• Een verandering — iets binnenin dat de voorwaarde uiteindelijk onwaar maakt (count = count - 1)

Oneindige lussen

Het is goed om te zien wat er gebeurt als het derde onderdeel ontbreekt:

count = 3

while count > 0:
    print(count)

Dit print 3 voor altijd. count verandert nooit, dus count > 0 wordt nooit onwaar.

Hoe je het stopt: druk op Ctrl + C in de terminal. Het programma stopt dan meteen en toont iets als dit:

Traceback (most recent call last):
  File "D:\python-lab\lesson-10\loop.py", line 4, in <module>
    print(count)
KeyboardInterrupt

De regel File toont het volledige pad van je bestand, en het regelnummer hangt af van het exacte moment waarop je de toetsen indrukte. KeyboardInterrupt betekent dat jij het zelf hebt gestopt. Dat is geen fout in je code, het is jouw beslissing.

Oneindige lussen horen bij het leren. Elke programmeur heeft er ooit een geschreven, en schrijft er nog steeds. Je hoeft niet bang te zijn — als je weet hoe je Ctrl + C gebruikt, is het een kleine ergernis. Vraag jezelf bij het schrijven van een lus altijd één keer af: "hoe wordt deze voorwaarde onwaar?" Kun je dat niet beantwoorden, dan stopt de lus niet.

Accumuleren

De meest voorkomende taak voor een lus is iets opbouwen — een som, een teller, de grootste waarde die je tegenkomt:

total = 0
number = 1

while number <= 5:
    total = total + number
    number = number + 1

print("Sum of 1 to 5:", total)

Sum of 1 to 5: 15

total heet een accumulator — de verzamelplek waarin je optelt. Let op dat hij buiten de lus begint, op 0. Als je hem binnen de lus zou zetten, wordt hij elke ronde gereset, en aan het eind heb je alleen het laatste getal over.

break — nu meteen stoppen

break beëindigt de lus meteen, wat de voorwaarde ook zegt:

number = 1

while number <= 100:
    if number % 7 == 0:
        print("First multiple of 7:", number)
        break
    number = number + 1

First multiple of 7: 7

De voorwaarde zei dat er tot 100 doorgegaan moest worden, maar het werk was klaar op het moment dat 7 verscheen — dus er was geen reden om nog 93 keer rond te gaan.

break maakt ook een patroon mogelijk dat erg handig blijkt te zijn — True als voorwaarde zetten en op de juiste plek binnenin weggaan:

while True:
    answer = input("Type 'quit' to exit: ").strip().lower()
    if answer == "quit":
        print("Goodbye")
        break
    print(f"You typed: {answer}")

Type 'quit' to exit: hello
You typed: hello
Type 'quit' to exit: QUIT
Goodbye

while True betekent "doorgaan voor altijd", dus een break binnenin is verplicht — anders is het een oneindige lus.

continue — deze ronde overslaan

continue beëindigt de lus niet; het slaat de rest van het blok over en gaat meteen naar de volgende ronde:

number = 0

while number < 10:
    number = number + 1
    if number % 2 == 0:
        continue
    print(number)

1
3
5
7
9

Bij elk even getal werd continue uitgevoerd, dus werd de print overgeslagen.

Er zit een valkuil in het gebruik van continue. Staat de regel die de voorwaarde laat vorderen (number = number + 1) na de continue, dan slaat continue hem over — en blijft de lus daar voor altijd hangen. Daarom staat de ophoging in de code hierboven vooraan. Controleer die volgorde elke keer als je continue gebruikt.

Eindelijk: vragen tot de invoer klopt

Dit is waar we twee hoofdstukken op hebben gewacht:

while True:
    raw = input("Your age: ").strip()
    if raw.isdigit():
        age = int(raw)
        break
    print("Please type a whole number, digits only.")

print(f"Thank you. Age recorded as {age}.")

Your age: twenty
Please type a whole number, digits only.
Your age: 22.5
Please type a whole number, digits only.
Your age: 22
Thank you. Age recorded as 22.

Dit is het patroon dat je voor de rest van je programmeerwerk gebruikt: oneindig laten lopen, binnenin valideren, break als de invoer goed is, en een melding printen en opnieuw beginnen als dat niet zo is. Het programma valt niet meer om bij foute invoer, en de persoon hoeft niet opnieuw te beginnen.

Een compleet voorbeeld

shopping.py:

# Keep taking item prices until the user is done, then summarise
total = 0.0
item_count = 0

print("Enter item prices. Type 'done' to finish.")

while True:
    entry = input("Price: ").strip().lower()

    if entry == "done":
        break

    if entry == "":
        print("  Nothing typed — try again.")
        continue

    # Accept only digits and at most one decimal point
    if entry.replace(".", "", 1).isdigit():
        price = float(entry)
        total = total + price
        item_count = item_count + 1
        print(f"  Added {price:.2f}. Running total {total:.2f}")
    else:
        print(f"  '{entry}' is not a price. Try again.")

print()
if item_count == 0:
    print("No items were entered.")
else:
    average = total / item_count
    print(f"Items   : {item_count}")
    print(f"Total   : {total:.2f}")
    print(f"Average : {average:.2f}")

Enter item prices. Type 'done' to finish.
Price: 120
  Added 120.00. Running total 120.00
Price: abc
  'abc' is not a price. Try again.
Price: 85.5
  Added 85.50. Running total 205.50
Price: done

Items   : 2
Total   : 205.50
Average : 102.75

Drie dingen werken hier samen, en alle drie horen bij het materiaal van vandaag:

• break — de lus verlaten wanneer de persoon done typt
• continue — de rest overslaan en opnieuw vragen bij een lege regel
• Accumulators — total en item_count beginnen allebei buiten de lus en groeien binnenin

Denk even na over waarom die laatste if item_count == 0 nodig is. Als iemand meteen done typt zonder iets in te voeren, is item_count 0, en dan zou total / item_count het programma laten stoppen met een ZeroDivisionError. Stel je bij alles wat een lus heeft opgebouwd altijd deze vraag: "is er eigenlijk wel iets opgeteld?"

Wanneer het misgaat

Het programma stopt niet, de tekst schiet voorbij Druk op Ctrl + C. Controleer daarna of het lusblok de regel bevat die de voorwaarde laat vorderen, en of die regel niet ná een continue staat.

De lus is helemaal niet uitgevoerd De voorwaarde was al onwaar. Vergelijk de startwaarde met de voorwaarde — while count > 0 die begint bij count = 0 komt nooit binnen.

Het loopt één keer te vaak of te weinig < en <= zijn door elkaar gehaald. Begin je bij n = 1, dan loopt while n < 5 vier keer (met n op 1, 2, 3, 4) en while n <= 5 vijf keer. Verander de startwaarde en het aantal verandert ook — begin je bij n = 0, dan loopt while n < 5 vijf keer. Controleer dus altijd de startwaarde en de voorwaarde samen.

IndentationError: expected an indented block after 'while' statement De regel na de while is niet ingesprongen.

NameError na de lus — de variabele is onbekend De variabele is alleen binnen de lus aangemaakt, en als de lus nooit draaide, is die variabele ook nooit aangemaakt. Geef elke variabele die je na de lus nodig hebt een startwaarde vóór de lus.

Het totaal klopt niet aan het eind van de lus Controleer of de accumulator binnen de lus een startwaarde krijgt. De regel total = 0 moet buiten de lus staan.

Jouw beurt

Schrijf een raadspel, guess.py:

1. Leg in de code een geheim getal vast, tussen 1 en 100
2. Vraag de persoon om te raden, en zeg elke keer "hoger" of "lager"
3. Bij een juist antwoord feliciteer je de persoon en verlaat je de lus
4. Print hoeveel pogingen de persoon nodig had
5. Typt iemand iets dat geen getal is, dan mag het programma niet vastlopen — print een melding en vraag opnieuw
6. Na zeven pogingen is het spel afgelopen, en wordt het geheime getal getoond

Eis zes is degene die je aan het denken zet: je lus kan nu op twee verschillende manieren eindigen — een juist antwoord, of pogingen die op zijn. Hoe je die twee uitgangen inricht, is de echte vraag in deze oefening. En als het werkt, lees je je eigen code nog één keer en vraag je jezelf af: is er een situatie waarin deze lus voor altijd blijft draaien?