2.13. Lusbesturing¶

Twee sleutelwoorden veranderen hoe een lus verloopt:

break – verlaat de lus onmiddellijk.
continue – sla de rest van de huidige iteratie over en begin de volgende.

Beide gelden voor de binnenste lus waarin ze voorkomen.

2.13.1. break¶

Gebruik break om een lus te stoppen zodra aan een voorwaarde is voldaan. Het klassieke patroon “zoeken en stoppen”:

found = None
for item in items:
    if matches(item):
        found = item
        break

if found is not None:
    print("found:", found)

In een while True:-lus is break de manier waarop de lus eindigt:

while True:
    line = next_line()
    if line == "quit":
        break
    process(line)

2.13.2. continue¶

Gebruik continue om de rest van de body over te slaan en naar de volgende iteratie te springen. Handig om items binnen een lus te filteren:

for n in numbers:
    if n < 0:
        continue            # skip negatives
    print(n)

Hetzelfde effect kun je schrijven als een if-blok rond de rest van de body. continue is soms duidelijker wanneer de overslaan-voorwaarde gemakkelijker vooraf te formuleren is dan de behoud-voorwaarde.

Binnen een lus vervult continue dezelfde rol als een vroege return in een functie: sla de gevallen die je niet afhandelt over en houd het hoofdwerk vlak op de buitenste inspringing. De filter-en-verwerk-lus is de canonieke vorm:

for item in items:
    if item is None:
        continue
    if not item.is_valid():
        continue
    process(item)

De ingesprongen regel process(item) is het eigenlijke werk; elke bewaker erboven beschrijft precies welke items worden overgeslagen.

2.13.3. else op een lus¶

Zowel for als while accepteren een optioneel else-blok. Het wordt uitgevoerd wanneer de lus voltooit zonder een break te raken. Het meest voorkomende gebruik is een zoeklus die een terugval wil als er niets is gevonden:

for item in items:
    if matches(item):
        print("found:", item)
        break
else:
    print("no match")

Als een break afgaat, wordt het else-blok overgeslagen. Lees de constructie als “for X in Y: …; of anders, als we er nooit uitbraken, doe Z.”

2.13.4. Veelvoorkomende luspatronen¶

Een paar patronen duiken vaak op in echte scripts:

Pollen – wacht tot een bepaalde voorwaarde waar wordt voordat je verdergaat. De body gebruikt pass, Pythons no-op-instructie; elk ingesprongen blok moet ten minste één instructie bevatten, en pass is de manier om “doe hier niets” te zeggen:
```
while not ready():
    pass
proceed()
```

Toestandsmachine – een enkele while True:-lus die kiest wat te doen op basis van een toestandsvariabele. Nuttig wanneer het werk netjes opsplitst in een paar genoemde fasen:

state = "header"
for line in lines:
    if state == "header":
        if line.startswith("---"):
            state = "body"
    elif state == "body":
        print(line)

Accumuleren – bouw een resultaat op terwijl je een reeks doorloopt:
```
total = 0
for x in samples:
    total += x
mean = total / len(samples)
```
Veel accumulatielussen hebben een one-liner-equivalent met een ingebouwde functie. Gebruik de ingebouwde functie wanneer er een van toepassing is:
- sum() – telt elk item in een iterable op.
- max() / min() – het grootste of kleinste item.
- any() – True als minstens één item waarheidsgetrouw is.
- all() – True alleen wanneer elk item waarheidsgetrouw is.
- sorted() – een nieuwe lijst met de items in volgorde.
- len() – het aantal items (waar de iterable zijn lengte kent).
```
>>> samples = [3, 1, 4, 1, 5, 9, 2, 6]
>>> sum(samples)
31
>>> sum(samples) / len(samples)        # mean
3.875
>>> max(samples)
9
>>> min(samples)
1
>>> sorted(samples)
[1, 1, 2, 3, 4, 5, 6, 9]
>>> any([False, False, True])
True
>>> all([True, True, False])
False
```
De ingebouwde versie is korter, duidelijker en meestal sneller dan dezelfde lus met de hand schrijven.