Taak 3: Call stack & return values

Je hebt nu functies geleerd. Volgende stap: dezelfde functie meerdere keren aanroepen in hetzelfde programma.

Probleem: zonder functies

Stel: je wilt 3 getallen controleren:

# Herhaalde logica
if temp1 < 0 or temp1 > 100:
    print("ERROR: temp1 ongeldig")
else:
    print("OK: temp1")

if temp2 < 0 or temp2 > 100:
    print("ERROR: temp2 ongeldig")
else:
    print("OK: temp2")

if temp3 < 0 or temp3 > 100:
    print("ERROR: temp3 ongeldig")
else:
    print("OK: temp3")

Probleem: 15 regels code voor 3 controles. Bug op één plek = bug op drie plekken.

Oplossing: functie 1x definiëren, 3x aanroepen

def check_temp(value):
    if value < 0 or value > 100:
        print("ERROR: ongeldig")
    else:
        print("OK")

# Aanroepen
check_temp(temp1)
check_temp(temp2)
check_temp(temp3)

Voordeel: 6 regels logica + 3 aanroepen = 9 regels. Eenmaal schrijven, drievoudig gebruiken.

Interactieve demo: aanroep-volgorde

Wat gebeurt er stap voor stap? Klik "Volgende stap" om te zien:

def add(a, b):
    return a + b

result = add(5, 3)
print(result)

Wanneer je een functie aanroept, gebeurt er veel achter de schermen. Python houdt bij: wie roept wie aan? Waar moeten we daarna verdergaan?

Call stack: wat roept wat aan?

De call stack is de "stapel" van functie-aanroepen. Python werkt van boven naar beneden, maar als een functie een andere functie aanroept, stapelt die zich er bovenop.

def outer():
    print("Start outer")
    inner()
    print("Klaar outer")

def inner():
    print("In inner")

outer()

Wat gebeurt:

1. outer() wordt aangeroepen
2. Print: "Start outer"
3. inner() wordt aangeroepen (stack: outer → inner)
4. Print: "In inner"
5. inner() klaar, terug naar outer (stack: outer)
6. Print: "Klaar outer"
7. outer() klaar

Return value keten: output van één is invoer van ander

Vaak geeft één functie een waarde terug die een andere functie nodig heeft:

def double(x):
    return x * 2

def add_ten(x):
    return x + 10

value = 5
step1 = double(value)     # step1 = 10
step2 = add_ten(step1)    # step2 = 20
print(step2)              # 20

Of in één lijn (chaining):

result = add_ten(double(5))  # (5 * 2) + 10 = 20

Belangrijk: Python voert eerst double(5) uit (geeft 10), dan add_ten(10) (geeft 20).

Voorbeeld: complexere keten

def celsius_to_fahrenheit(c):
    return (c * 9/5) + 32

def round_to_int(f):
    return int(f)

def log_temp(temp):
    print(f"Temperatuur: {temp}°F")
    return temp

# Keten
celsius_value = 25
fahrenheit = celsius_to_fahrenheit(celsius_value)  # 77.0
rounded = round_to_int(fahrenheit)                  # 77
log_temp(rounded)                                   # Print + return 77

Veelgemaakte fouten

Fout 1: return vergeten — waarde is None

def double(x):
    x * 2  # Fout: geen return!

result = double(5)
print(result)  # None (niet 10)

# Daarna gebruiken crasht
final = result + 10  # TypeError: unsupported operand type(s)

Fout 2: chaining met None

def process(x):
    print(f"Processing {x}")
    # Fout: geen return

def save(x):
    return f"Saved: {x}"

result = save(process(5))  # save(None) → "Saved: None"

Best practices

• Duidelijke return values. Als een functie niets teruggeeft, zeg dat in de naam: log_error() niet process_error()
• Chaining begrenzen. add_ten(double(square(5))) wordt snel onleesbaar. Beter: tussenvariabelen gebruiken
• Return types consistent. get_value() moet altijd een getal teruggeven, niet soms getal soms None

Interactieve demo: call stack stap voor stap

Klik "Volgende stap" om door de stack te gaan:

def double(x):
    return x * 2

def add_ten(x):
    return x + 10

result = add_ten(double(5))

Scenario: een webserver schrijft logregels. Elke regel bestaat uit drie delen, gescheiden door een |: het tijdstip, het niveau (INFO, ERROR of DEBUG) en een bericht. Jij schrijft een kleine pijplijn van drie functies: regel opknippen → niveau beoordelen → een nette uitvoerregel maken.

Gegeven:

entry = "2025-07-28 10:45:23|ERROR|Database connection failed"

def parse_log(text):
    # TODO
    pass

def is_error(level):
    # TODO
    pass

def format_result(parts):
    # TODO
    pass

Acceptatiecriteria:

• parse_log() geeft een lijst terug met drie onderdelen: tijdstip, niveau en bericht
• is_error() geeft True bij het niveau ERROR en False bij elk ander niveau
• format_result() geeft één regel terug: een ALERT-regel bij een fout, een OK-regel bij de rest — met tijdstip en bericht erin
• De uitkomst van de ene functie is de invoer van de volgende; er staan geen gekopieerde stukken code tussen
• Alleen het hoofdscript print — de drie functies geven hun uitkomst terug

Scenario: het logbestand heeft niet één regel, maar tientallen. En niet elke regel is netjes: soms ontbreekt een deel, of staat er een lege regel tussen.

Hints:

• Je hoeft je drie functies niet aan te passen om ze vaker te gebruiken — je roept ze gewoon vaker aan
• Bedenk wat parse_log() moet teruggeven als een regel niet uit drie delen bestaat, en wie daar iets mee doet
• Tel onderweg hoeveel regels een fout waren, en print dat aantal pas aan het eind

Acceptatiecriteria:

• Minstens vijf logregels worden verwerkt, waarvan één lege en één zonder bericht
• Een regel die niet klopt, laat het script niet crashen; hij krijgt een eigen melding
• Aan het eind staat hoeveel ERROR-regels er waren