Taak 1: Lokale variabelen & NameError

In US1 tot US3 heb je geleerd functies te schrijven die één taak doen. Nu komt de vraag die daarbij hoort: waar leven de variabelen die je in zo'n functie gebruikt?

Elke functie heeft zijn eigen werkruimte, de lokale scope. Variabelen die je daarin aanmaakt bestaan alleen zolang de functie draait. Daarna zijn ze weg:

def calculate_average(readings):
    total = 0
    for value in readings:
        total = total + value
    average = total / len(readings)

readings = [45, 80, 12]
calculate_average(readings)
print(average)

Dit ziet er logisch uit, maar het crasht:

NameError: name 'average' is not defined

Drie concrete problemen

1. De variabele is opgeruimd. Zodra de functie klaar is, verdwijnt average — Python houdt hem niet vast.
2. De berekening is voor niets gedaan. De functie rekende alles uit, maar gaf niets terug. Het resultaat is nergens meer te vinden.
3. De foutmelding komt op de verkeerde regel. Python klaagt bij print(), terwijl de oorzaak in de functie zit.

De oplossing: return

Met return stuur je de waarde naar buiten. Buiten de functie vang je hem op in een nieuwe variabele:

def calculate_average(readings):
    total = 0
    for value in readings:
        total = total + value
    average = total / len(readings)

readings = [45, 80, 12]
calculate_average(readings)
print(average)

# NameError: name 'average'
#            is not defined

def calculate_average(readings):
    total = 0
    for value in readings:
        total = total + value
    return total / len(readings)

readings = [45, 80, 12]
result = calculate_average(readings)
print(f"Gemiddelde: {result}")

# Gemiddelde: 45.666...

De variabele average bestaat nog steeds alleen binnen de functie. Wat naar buiten gaat is de waarde — en die sla je op onder een naam die je zelf kiest.

Interactieve demo — de scope-grens

Loop de drie momenten door en kijk welke variabelen op dat moment bestaan. Zet return aan of uit om het verschil te zien:

Scope is de vraag: welke namen kan Python op dit punt in de code zien? Als je die vraag kunt beantwoorden, verdwijnt een hele categorie bugs uit je werk — niet alleen de NameError, maar ook de veel vervelendere fouten waarbij je code gewoon draait en stilletjes het verkeerde antwoord geeft.

Waarom bestaat lokale scope eigenlijk?

Stel dat alle variabelen overal zichtbaar waren. Dan zou elke functie die een teller i of een tussenresultaat total gebruikt, de i of total van een andere functie kunnen overschrijven. In een script van 500 regels met twintig functies wordt dat onhoudbaar.

Door elke functie zijn eigen ruimte te geven, kun je een functie schrijven zonder te weten welke namen de rest van het programma gebruikt. Dat is precies wat de helper-functies uit US3 herbruikbaar maakt.

Lezen mag wel, toewijzen maakt een nieuwe variabele

Hier zit een subtiliteit die veel mensen verrast. Een functie mag een globale variabele lezen. Maar zodra je er met = een waarde aan toewijst, maakt Python een nieuwe, lokale variabele met dezelfde naam. De globale blijft ongewijzigd:

max_temperature = 100          # globaal

def show_limit():
    print(f"Limiet: {max_temperature}°C")   # lezen mag

def lower_limit():
    max_temperature = 60       # NIEUWE lokale variabele!
    print(f"Binnen de functie: {max_temperature}°C (max: 100°C)")

show_limit()                   # Limiet: 100°C
lower_limit()                  # Binnen de functie: 60°C (max: 100°C)
print(f"Buiten: {max_temperature}°C")   # Buiten: 100°C — ongewijzigd

Dit heet shadowing: de lokale naam overschaduwt de globale. Het gevaar is dat je code gewoon draait. Er is geen foutmelding — alleen een waarde die niet verandert terwijl jij denkt van wel.

Parameters zijn óók lokale variabelen

Een parameter is een lokale variabele die Python voor je aanmaakt bij de aanroep. Pas je hem aan, dan verandert de variabele buiten de functie niet mee:

def apply_offset(temperature):
    temperature = temperature + 5      # alleen de lokale kopie
    return temperature

sensor_value = 20
corrected = apply_offset(sensor_value)
print(f"Origineel: {sensor_value}°C")     # Origineel: 20°C
print(f"Gecorrigeerd: {corrected}°C")     # Gecorrigeerd: 25°C

Dat geldt voor getallen en teksten. Voor lijsten ligt het net anders — dat is taak 2.

Veelgemaakte fouten

Fout 1: return vergeten — de functie geeft None terug

# ❌ FOUT
def count_errors(log_lines):
    errors = 0
    for line in log_lines:
        if "ERROR" in line:
            errors = errors + 1
    print(errors)              # printen is niet hetzelfde als teruggeven

result = count_errors(log_lines)
print(f"Aantal fouten: {result}")
# 2
# Aantal fouten: None       ← de functie gaf niets terug

# ✅ JUIST
def count_errors(log_lines):
    errors = 0
    for line in log_lines:
        if "ERROR" in line:
            errors = errors + 1
    return errors

Dit is de gemeenste variant: er is géén NameError. Een functie zonder return geeft altijd None terug, en daar rekent je programma vrolijk mee verder tot het ergens anders misgaat.

Fout 2: de teruggegeven waarde niet opvangen

# ❌ FOUT
def get_status(cpu_usage):
    if cpu_usage > 90:
        return "kritiek"
    return "normaal"

get_status(95)                 # de waarde wordt nergens bewaard
print(status)                  # NameError: name 'status' is not defined

# ✅ JUIST
status = get_status(95)
print(f"Status: {status} (bij 95% van max 100%)")

Fout 3: global gebruiken om het probleem te omzeilen

# Kan wel, maar doe het niet
counter = 0

def increment():
    global counter             # vertel Python: gebruik de globale
    counter = counter + 1

increment()
print(counter)                 # 1

Dit werkt, maar zodra meerdere functies dezelfde globale variabele aanpassen, kun je niet meer nagaan wanneer en waardoor de waarde veranderde. Gebruik een parameter en een return — dan staat op de aanroepregel zelf wat er gebeurt.

Edge case: gebruiken vóór het aanmaken

Python leest een functie pas echt op het moment dat je hem aanroept. Deze code geeft dus pas bij de aanroep een fout, niet bij het definiëren:

def show_report():
    print(f"Totaal: {total}")   # total bestaat hier nog niet

show_report()                   # NameError: name 'total' is not defined

total = 100
show_report()                   # Totaal: 100 — nu wél

De functie zoekt total pas op tijdens de aanroep, en kijkt dan in de globale scope. Handig om te weten, maar bouw er niet op: een functie die afhangt van een globale variabele die later ergens wordt gezet, is lastig te volgen.

Hoe lees je een NameError?

De melding NameError: name 'x' is not defined betekent altijd: Python kent deze naam hier niet. Loop drie dingen na:

1. Spelling. Is het total of totaal? readings of reading?
2. Scope. Is de variabele binnen een functie aangemaakt en probeer je hem erbuiten te gebruiken? Dan hoort er een return bij.
3. Volgorde. Is de regel die de variabele aanmaakt al uitgevoerd voordat je hem gebruikt?

Interactieve demo — de scope-grens

Zelfde inspecteur als in het korte deel. Loop nu vooral stap 3 na met en zonder return, en let op wat er met de lokale variabelen gebeurt:

Scenario: voordat de drone opstijgt wil je weten of het vluchtplan haalbaar is. Je hebt drie gegevens nodig: de totale afstand, de langste losse stap, en of het plan binnen het bereik van de accu valt. Drie berekeningen, dus drie functies — en elke functie moet zijn resultaat naar buiten kunnen geven.

Gegeven:

flight_plan = [
    {"direction": "forward", "distance": 100},
    {"direction": "left", "distance": 60},
    {"direction": "up", "distance": 40},
    {"direction": "forward", "distance": 80},
]

MAX_FLIGHT_DISTANCE = 250   # cm die de accu aankan

Je taak: schrijf de drie functies en gebruik ze in één overzicht. Bepaal zelf de parameters en wat elke functie teruggeeft.

Acceptatiecriteria:

• Er is een functie die de totale afstand van het plan teruggeeft
• Er is een functie die de langste losse stap teruggeeft
• Er is een functie die teruggeeft of het plan binnen MAX_FLIGHT_DISTANCE past
• Geen enkele functie print zelf iets; de uitvoer toont per regel de waarde én de grens, zoals Totaal: 280 cm (max: 250 cm)
• Met de drone: past het plan, dan vliegt hij het en landt; past het niet (zoals het gegeven plan), dan stijgt hij niet op — test beide

Scenario: je wilt niet alleen weten óf het plan past, maar ook bij welke stap de accu onder de veilige grens van 20% zou komen. Bouw dit bovenop je functies uit de opdracht.

Hints:

• Reken met een startpercentage en een vast verbruik per honderd centimeter
• Je hebt zowel het stapnummer als het accupercentage nodig — bedenk hoe je twee waarden uit één functie krijgt
• Een functie die niets vindt moet daar ook iets over kunnen zeggen; bedenk welke waarde daarbij past
• Houd de berekening en het printen strikt gescheiden

Acceptatiecriteria:

• De functie geeft terug bij welke stap de accu onder 20% komt, of maakt duidelijk dat dat niet gebeurt
• De functie print niets; de aanroeper bepaalt wat er op het scherm komt
• De uitvoer toont het accupercentage én de grens van 20%
• Een leeg vluchtplan levert geen foutmelding op