Lussen sturen: break, continue en geneste lussen

In les 5 liep een lus netjes van begin tot eind. Soms wil je eerder stoppen ("antwoord gevonden!") of één ronde overslaan ("dit getal telt niet mee"). Daarvoor zijn break en continue. Daarna zet je een lus in een lus, zodat je met twee regels code een hele tafelkaart maakt.

break: stop de lus nu

for getal in range(1, 100):
    if getal * getal > 50:
        print(f"Eerste getal met kwadraat boven 50: {getal}")
        break
print("Na de lus")

Eerste getal met kwadraat boven 50: 8
Na de lus

break stopt de lus direct. Python gaat verder met de eerste regel na de lus. De rondes 9 tot en met 99 worden niet meer uitgevoerd.

continue: sla de rest van deze ronde over

for getal in range(1, 8):
    if getal % 3 == 0:
        continue
    print(getal)

1
2
4
5
7

Bij continue springt Python terug naar de kop van de lus en begint de volgende ronde. Alles wat onder continue staat, wordt voor deze ronde overgeslagen.

Invoer blijven vragen tot die klopt

Het belangrijkste gebruik van break: een invoerlus (input loop) die blijft vragen tot het antwoord bruikbaar is.

while True:
    antwoord = input("Wil je doorgaan? (j/n) ").lower()
    if antwoord == "j" or antwoord == "n":
        break
    print("Typ j of n.")
print(f"Je koos {antwoord}")

Wil je doorgaan? (j/n) misschien
Typ j of n.
Wil je doorgaan? (j/n) J
Je koos j

while True is een lus die nooit uit zichzelf stopt. Dat is hier juist de bedoeling: de enige uitgang is de break, en die bereik je pas bij geldige invoer. .lower() maakt de invoer kleine letters, zodat J ook goed is (meer over zulke methodes in les 7).

Een tweede voorbeeld: getallen optellen tot de gebruiker 0 typt.

totaal = 0
while True:
    getal = int(input("Getal (0 = stoppen): "))
    if getal == 0:
        break
    totaal += getal
print(f"Totaal: {totaal}")

Geneste lussen

Een lus in een lus heet een geneste lus (nested loop). Voor elke ronde van de buitenste lus loopt de binnenste lus helemaal.

for rij in range(1, 4):
    for kolom in range(1, 5):
        print(rij * kolom, end="\t")
    print()

1	2	3	4
2	4	6	8
3	6	9	12

Twee nieuwe dingen:

• end="\t" laat print eindigen met een tab in plaats van een nieuwe regel. Zo komen getallen naast elkaar.
• De lege print() na de binnenste lus begint een nieuwe regel. Hij springt maar één niveau in, dus hij hoort bij de buitenste lus: één keer per rij.

Het aantal rondes vermenigvuldigt zich: 3 rijen × 4 kolommen = 12 keer de binnenste print.

Uitgewerkt voorbeeld: een driehoek tekenen

Voorspel de uitvoer.

for regel in range(1, 5):
    for _ in range(regel):
        print("*", end="")
    print()

*
**
***
****

De binnenste lus loopt regel keer: op regel 1 één keer, op regel 4 vier keer. Het liggende streepje _ is een gebruikelijke naam voor een lusvariabele die je niet gebruikt.

Typische fout: verkeerde inspringing van de binnenste lus

for rij in range(1, 4):
    for kolom in range(1, 5):
        print(rij * kolom, end="\t")
        print()

Hier springt de lege print() twee niveaus in en hoort hij bij de binnenste lus. Elk getal komt dan op een eigen regel. Kijk bij geneste lussen altijd naar de inspringing van elke regel en vraag je af: hoe vaak moet deze regel uitgevoerd worden? Eén keer per rij → buitenste lus. Eén keer per vakje → binnenste lus.

Oefenen

Oefening 1. Voorspel de uitvoer:

for i in range(1, 10):
    if i == 6:
        break
    if i % 2 == 0:
        continue
    print(i)

1
3
5

Oefening 2. Schrijf een invoerlus die een cijfer tussen 1 en 10 vraagt (kommagetal toegestaan) en blijft vragen tot het cijfer in dat bereik ligt.

while True:
    cijfer = float(input("Cijfer (1-10): "))
    if 1 <= cijfer <= 10:
        break
    print("Dat cijfer ligt niet tussen 1 en 10.")
print(f"Ingevoerd: {cijfer}")

Oefening 3. Print met geneste lussen alle combinaties van een dobbelsteen met een munt: 1 kop, 1 munt, 2 kop, … tot 6 munt. Gebruik voor de munt for kant in ["kop", "munt"]: (lijsten komen in les 8).

for ogen in range(1, 7):
    for kant in ["kop", "munt"]:
        print(ogen, kant)

Lab: tafels oefenen

Samenvatting

• break stopt de lus direct; Python gaat verder na de lus.
• continue slaat de rest van de huidige ronde over.
• while True met een break bij geldige invoer is het standaardpatroon voor invoervalidatie.
• In een geneste lus loopt de binnenste lus volledig voor elke ronde van de buitenste.
• De inspringing bepaalt bij welke lus een regel hoort; break stopt alleen de binnenste lus.

In les 7 duik je in tekst: letters opvragen, stukken uitknippen en tekst opschonen met stringmethodes.