Taak 3: Geen block scope in Python

In taak 1 leerde je dat een functie zijn eigen scope heeft. De logische vervolgvraag is: geldt dat ook voor een if of een for? In veel andere talen wel. In Python niet: alleen een functie maakt een nieuwe scope.

temperature = 75

if temperature > 60:
    status = "te heet"        # binnen het if-blok aangemaakt
    limit = 60

print(f"Status: {status} (grens: {limit}°C)")
# Status: te heet (grens: 60°C)   ← werkt gewoon

Hetzelfde geldt voor een lus. De lus-variabele bestaat ná de lus nog steeds:

for value in [45, 80, 12]:
    last_reading = value

print(f"Laatst gelezen: {last_reading}")   # 12
print(f"Loop-variabele: {value}")          # 12 — bestaat nog!

Drie concrete problemen

1. Draait het blok niet, dan bestaat de variabele niet. Bij temperature = 45 wordt het if-blok overgeslagen en crasht de print() met een NameError.
2. Je ziet het niet aan de code. Of het werkt, hangt af van de waarde op dat moment — niet van hoe je code eruitziet.
3. Oude waarden blijven rondslingeren. Een variabele uit een vorige lus of if-tak staat er nog, met een waarde die niet meer klopt.

De oplossing: zet de variabele vóór het blok

temperature = 45

if temperature > 60:
    status = "te heet"

print(f"Status: {status}")

# NameError: name 'status'
#            is not defined

temperature = 45
status = "normaal"

if temperature > 60:
    status = "te heet"

print(f"Status: {status}")

# Status: normaal

Met een startwaarde vóór het blok bestaat de variabele altijd. Of het blok nu draait of niet: print() heeft altijd iets te tonen.

Interactieve demo — bestaat de variabele?

Kies een meetreeks en kijk of de print() na het blok werkt. Zet de startwaarde aan om het verschil te zien:

Python kent maar één soort scope die je zelf maakt: die van een functie. Alles wat je daarbinnen schrijft — hoe diep genest in if's en for's ook — deelt dezelfde ruimte. Dat heet function scope, tegenover de block scope van talen als Java, C# en JavaScript.

Handig, want guards worden er korter van

Function scope is niet alleen een valkuil. Het maakt het patroon dat je in sprint 2 leerde, de guard clause, juist prettig kort:

def check_reading(value, limit):
    if value is None:
        return "geen meting"

    if value > limit:
        message = f"te hoog: {value} (max: {limit})"
    else:
        message = f"in orde: {value} (max: {limit})"

    return message      # message is hier zichtbaar, uit welke tak hij ook komt

In een taal met block scope zou message buiten de if niet bestaan en zou je hem eerst moeten declareren. In Python hoeft dat niet — mits élke tak hem zet. Vergeet je de else, dan crasht het pas bij bepaalde invoer.

De vier lagen: LEGB

Als Python een naam tegenkomt, zoekt hij in vier lagen, in deze volgorde. De eerste die de naam kent, wint:

MAX_TEMPERATURE = 100          # Global

def check(value):
    limit = MAX_TEMPERATURE    # Local: limit — Global: MAX_TEMPERATURE
    return len(str(value)) > 0 # Built-in: len en str

print(check(45))               # Built-in: print

Een if- of for-blok komt in dit rijtje niet voor. Dat is precies waarom een variabele uit zo'n blok gewoon in de omliggende laag terechtkomt.

Veelgemaakte fouten

Fout 1: de lus draait nul keer

# ❌ FOUT
def get_last_above(readings, threshold):
    for value in readings:
        if value > threshold:
            last_high = value
    return last_high             # bestaat niet als niets boven de grens lag

print(get_last_above([45, 12], 60))
# UnboundLocalError: cannot access local variable 'last_high'
#   where it is not associated with a value

# ✅ JUIST
def get_last_above(readings, threshold):
    last_high = None             # startwaarde: "nog niets gevonden"
    for value in readings:
        if value > threshold:
            last_high = value
    return last_high

Let op de foutmelding: binnen een functie krijg je UnboundLocalError in plaats van NameError. Python wéét dat last_high lokaal is — er staat immers een toewijzing in de functie — maar die regel is nooit uitgevoerd.

Fout 2: een oude waarde uit een vorige ronde

# ❌ FOUT — message blijft staan als de else ontbreekt
for value in [80, 45]:
    if value > 60:
        message = f"te hoog: {value} (max: 60)"
    print(message)

# te hoog: 80 (max: 60)
# te hoog: 80 (max: 60)   ← 45 is niet te hoog, maar de oude tekst staat er nog

# ✅ JUIST — zet message elke ronde opnieuw
for value in [80, 45]:
    if value > 60:
        message = f"te hoog: {value} (max: 60)"
    else:
        message = f"in orde: {value} (max: 60)"
    print(message)

Dit is gevaarlijker dan een crash: er komt geen foutmelding, alleen een verkeerde regel op het scherm. Zorg dat élke tak de variabele zet, of zet hem bovenaan de lus.

Fout 3: een ingebouwde naam overschrijven

# ❌ FOUT
list = [45, 80, 12]            # overschrijft de built-in 'list'
readings = list("abc")         # TypeError: 'list' object is not callable

# ✅ JUIST — kies een naam die beschrijft wat erin zit
readings = [45, 80, 12]

Omdat Built-in de laatste laag is, wint jouw globale naam. Vermijd namen als list, dict, str, sum, max en input.

Edge case: de lus-variabele na afloop

for value in [45, 80, 12]:
    pass

print(value)        # 12 — de laatste waarde staat er nog

for value in []:
    pass

print(value)        # 12 — nog steeds de oude waarde uit de vorige lus!

De tweede lus draait nul keer en overschrijft value dus niet. Je leest dan de waarde uit een lus die er niets mee te maken had. Gebruik de lus-variabele daarom nooit na de lus.

Wanneer geef je vooraf een startwaarde?

• Altijd als je de variabele ná het blok gebruikt en niet zeker weet dat het blok draait.
• Altijd bij een teller of verzamelaar: total = 0, found = [], last_high = None.
• Niet nodig als elke tak van een if/else de variabele zet en je hem alleen daarna gebruikt.
• Overweeg in plaats daarvan een aparte functie met een return per geval — dan is de vraag niet meer aan de orde.

De drie regels van functie-scope

1. Wat je binnen een functie aanmaakt, blijft binnen die functie — naar buiten gaat alleen wat je met return teruggeeft.
2. Toewijzen met = maakt een lokale naam; alleen het aanpassen van een mutable object is buiten zichtbaar.
3. if en for maken géén eigen scope — maar een blok dat niet draait, maakt de variabele ook niet aan.

Interactieve demo — bestaat de variabele?

Loop alle drie de meetreeksen langs, met en zonder startwaarde. Let vooral op de lege lijst: daar zie je waarom een startwaarde geen overbodige luxe is:

Scenario: vóór het opstijgen controleert je script het vluchtplan op te grote stappen en op onbekende richtingen. Het script werkt prima zolang er iets fout is in het plan — maar bij een perfect plan, of een leeg plan, crasht het. Dat is precies het omgekeerde van wat je wilt.

Gegeven:

flight_plan = [
    {"direction": "forward", "distance": 100},
    {"direction": "up", "distance": 50},
]

VALID_DIRECTIONS = ["forward", "back", "left", "right", "up", "down"]
MAX_STEP_DISTANCE = 120

Je taak: schrijf de controle zo dat hij bij élk vluchtplan een nette uitkomst geeft — ook bij een plan zonder fouten en bij een leeg plan. Bepaal zelf welke variabelen je vooraf een startwaarde geeft.

Acceptatiecriteria:

• Het script meldt hoeveel stappen te ver gaan en welke richtingen onbekend zijn
• Een vluchtplan zonder fouten en een leeg vluchtplan geven allebei een duidelijke melding, geen foutmelding
• Geen enkele variabele wordt alleen binnen een if- of for-blok aangemaakt
• Elke meldregel toont de waarde én de grens, bijvoorbeeld Stap 1: 140 cm (max: 120 cm)
• Met de drone: is het plan in orde, dan vliegt hij het en landt; zit er een fout in, dan blijft hij aan de grond

Scenario: je wilt weten welke stap in het plan de meeste accu kost, zodat je die eventueel kunt opsplitsen. De functie moet ook een antwoord geven als het plan leeg is of als alle stappen even zwaar zijn.

Hints:

• Bedenk welke startwaarde past bij "nog niets gevonden" — een getal is hier geen goede keuze
• Je hebt zowel de stap zelf als zijn plaats in het plan nodig; bedenk hoe je die samen teruggeeft
• De functie hoort niets te printen en het plan niet aan te passen
• Test met een leeg plan, met één stap, en met twee stappen van gelijke lengte

Acceptatiecriteria:

• De functie geeft de zwaarste stap terug, of maakt duidelijk dat er geen stap is
• Een leeg vluchtplan levert geen foutmelding op
• Bij gelijke stappen is vooraf duidelijk welke er wordt teruggegeven
• Het originele vluchtplan is na de aanroep ongewijzigd