Taak 2: Getal vs lijst als parameter

In taak 1 zag je dat variabelen binnen een functie lokaal zijn. Nu wordt het lastiger: wat gebeurt er met een waarde die je meegeeft als parameter? Het antwoord hangt af van het soort waarde — en dat verrast bijna iedereen de eerste keer.

Een getal aanpassen werkt niet

def pay(balance, amount):
    balance = balance - amount
    print(f"Binnen de functie: € {balance}")

balance = 80
pay(balance, 25)
print(f"Buiten de functie: € {balance}")

# Binnen de functie: € 55
# Buiten de functie: € 80   ← onveranderd!

Een lijst aanpassen werkt wél

def add_entry(entries, text):
    entries.append(text)

system_log = []
add_entry(system_log, "opgestart")
print(system_log)

# ['opgestart']   ← de lijst buiten de functie is echt veranderd

Drie concrete problemen

1. De regels lijken elkaar tegen te spreken. Dezelfde soort code geeft bij een getal een ander resultaat dan bij een lijst.
2. Er komt geen foutmelding. Je code draait gewoon door met de oude waarde — je merkt het pas als er iets anders misgaat.
3. Het werkt ook per ongeluk. Een functie die een lijst aanpast terwijl jij dat niet verwachtte, verandert gegevens waar je niet naar kijkt.

Waar het verschil zit

Een naam in Python wijst naar een object. Sommige objecten kun je aanpassen (mutable), andere niet (immutable):

• Immutable: int, float, str, bool, tuple — je kunt het getal 80 niet veranderen in 55.
• Mutable: list, dict, set — je kunt er iets in stoppen of uithalen zonder een nieuw object te maken.

Met = laat je een naam naar iets anders wijzen. Met .append() of entries[0] = ... pas je het object zelf aan. Het eerste blijft binnen de functie, het tweede is buiten zichtbaar.

def pay(balance, amount):
    balance = balance - amount
    # nieuwe waarde, nieuwe plek
    # de naam buiten wijst nog
    # steeds naar 80

balance = 80
pay(balance, 25)
print(balance)      # 80

def pay(balance, amount):
    return balance - amount

balance = 80
balance = pay(balance, 25)
print(f"Saldo: € {balance}")

# Saldo: € 55

Interactieve demo — wat gebeurt er in het geheugen?

Kies een type en kijk wat de functie met de waarde buiten doet:

Het verschil tussen een getal en een lijst als parameter is geen willekeurige regel. Het volgt uit hoe Python met namen en objecten omgaat. Als je dat model eenmaal snapt, kun je bij elke functie voorspellen wat er buiten gebeurt.

Namen zijn labels, geen dozen

In veel talen stel je een variabele voor als een doosje met een waarde erin. In Python werkt het anders: een naam is een label dat aan een object hangt. Meerdere labels kunnen aan hetzelfde object hangen:

readings = [45, 80, 12]
backup = readings          # geen kopie! tweede label op hetzelfde object

backup.append(99)
print(readings)            # [45, 80, 12, 99]  ← ook veranderd
print(backup)              # [45, 80, 12, 99]

Bij een functieaanroep gebeurt precies hetzelfde: de parameter wordt een tweede label op het object dat je meegeeft. Pas je het object aan, dan zien beide labels dat. Laat je het label naar iets anders wijzen, dan raakt dat de ander niet.

Toewijzen vs aanpassen

Dit is de kern. Twee handelingen die er in code op elkaar lijken, maar totaal anders werken:

Let op de valkuil in de tweede rij van "toewijzen": ook bij een lijst breekt een toewijzing de verbinding:

def reset_log(entries):
    entries = []               # nieuw lijst-object, alleen binnen zichtbaar

def clear_log(entries):
    entries.clear()            # past HET object aan

system_log = ["opgestart", "meting"]
reset_log(system_log)
print(system_log)              # ['opgestart', 'meting']  ← niet leeg!

clear_log(system_log)
print(system_log)              # []  ← nu wel

Twee varianten van dezelfde functie

Er zijn twee manieren om een functie iets te laten veranderen. Beide komen voor, en het is belangrijk dat je ze allebei herkent:

# Variant 1 — muteren: past het meegegeven object aan, geeft niets terug
def add_entry(entries, text):
    entries.append(text)

system_log = []
add_entry(system_log, "opgestart")     # geen toewijzing nodig
print(system_log)                      # ['opgestart']


# Variant 2 — teruggeven: laat het origineel met rust, geeft een nieuwe lijst
def with_entry(entries, text):
    return entries + [text]

system_log = []
new_log = with_entry(system_log, "opgestart")
print(system_log)                      # []  ← origineel ongemoeid
print(new_log)                         # ['opgestart']

Variant 1 is korter en zuiniger met geheugen. Variant 2 is voorspelbaarder: de aanroeper ziet aan de = dat er iets verandert. Voor grote lijsten is variant 1 gebruikelijk, voor code waar fouten duur zijn variant 2.

Veelgemaakte fouten

Fout 1: rekenen op een gewijzigd getal

# ❌ FOUT
def apply_payment(balance, amount):
    balance = balance - amount

balance = 80
apply_payment(balance, 25)
apply_payment(balance, 25)
print(f"Saldo: € {balance}")    # Saldo: € 80

# ✅ JUIST
def apply_payment(balance, amount):
    return balance - amount

balance = 80
balance = apply_payment(balance, 25)
balance = apply_payment(balance, 25)
print(f"Saldo: € {balance}")    # Saldo: € 30

Fout 2: per ongeluk de originele lijst aanpassen

# ❌ FOUT — sort() past de lijst zelf aan
def get_highest(readings):
    readings.sort()
    return readings[-1]

measurements = [45, 12, 80]
highest = get_highest(measurements)
print(measurements)        # [12, 45, 80]  ← de volgorde is weg!

# ✅ JUIST — werk op een kopie
def get_highest(readings):
    ordered = sorted(readings)     # sorted() geeft een NIEUWE lijst
    return ordered[-1]

De aanroeper vroeg om de hoogste waarde, niet om een gesorteerde lijst. Een functie hoort geen bijwerkingen te hebben waar zijn naam niets over zegt.

Fout 3: een lijst als standaardwaarde van een parameter

# ❌ FOUT — de lijst wordt één keer gemaakt en hergebruikt
def add_reading(value, readings=[]):
    readings.append(value)
    return readings

print(add_reading(45))     # [45]
print(add_reading(80))     # [45, 80]  ← de vorige waarde staat er nog in!

# ✅ JUIST
def add_reading(value, readings=None):
    if readings is None:
        readings = []
    readings.append(value)
    return readings

De standaardwaarde wordt aangemaakt bij het definiëren van de functie, niet bij elke aanroep. Gebruik daarom nooit een lijst of dict als standaardwaarde.

Edge case: een echte kopie maken

Wil je zeker weten dat je het origineel niet raakt, maak dan expliciet een kopie:

safe = readings.copy()      # of: list(readings)  of: readings[:]
safe.append(99)
print(readings)             # ongewijzigd

Let op: dit is een ondiepe kopie. Bevat je lijst weer lijsten of dicts, dan delen de kopie en het origineel nog steeds die binnenste objecten.

Wanneer muteer je wel, en wanneer niet?

• Wel muteren: als het de duidelijke taak van de functie is, en de naam dat zegt — add_entry(), clear_log(), append_result().
• Niet muteren: in functies die iets berekenen of opzoeken. Een functie die get_ of calc_ heet, hoort niets te veranderen.
• Nooit allebei: een functie die muteert én een waarde teruggeeft, is moeilijk te doorgronden. Kies er één.

Interactieve demo — wat gebeurt er in het geheugen?

Vergelijk beide types met en zonder return. Let op waar de naam naartoe wijst en wanneer het object zelf verandert:

Scenario: tijdens het uitvoeren van een vluchtplan wil je twee dingen bijhouden: hoeveel accu er nog over is, en wat de drone allemaal gedaan heeft. Het accupercentage is een getal, het vluchtlogboek is een lijst — en die twee gedragen zich dus verschillend.

Gegeven:

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

battery = 100          # procent
POWER_PER_100_CM = 8   # procent accu per 100 cm
MIN_BATTERY = 20       # onder deze grens niet meer vliegen

Je taak: schrijf een functie die het accuverbruik van één stap verwerkt en een functie die een regel aan het logboek toevoegt. Voer daarna het plan stap voor stap uit en houd beide bij.

Acceptatiecriteria:

• Het accupercentage wordt bijgewerkt via return, niet door de parameter aan te passen
• Het logboek wordt gevuld door de lijst aan de functie mee te geven
• Zakt de berekende accu onder MIN_BATTERY, dan stopt de vlucht en wordt dat gemeld; elke regel toont waarde én grens, zoals Accu: 76% (min: 20%)
• Test zonder drone met een lage startwaarde dat het stoppen werkt, en met 100% dat het hele plan doorgaat
• Met de drone: vlieg het plan echt en print na de landing de berekende én de gemeten accu (get_battery()) naast elkaar

Scenario: je wilt een functie die een vluchtplan omkeert, zodat de drone dezelfde route terugvliegt. Het originele plan moet daarbij onaangetast blijven — je hebt het straks nog nodig voor het logboek.

Hints:

• Bedenk eerst welke lijstbewerkingen het origineel aanpassen en welke een nieuwe lijst opleveren
• Bij het terugvliegen hoort elke richting omgewisseld te worden met zijn tegenovergestelde
• Een dictionary in een lijst is zelf ook mutable — een kopie van de lijst beschermt de dicts erin niet
• Controleer je aanname door na afloop het originele plan opnieuw te printen

Acceptatiecriteria:

• De functie geeft een nieuw vluchtplan terug met omgekeerde volgorde en tegengestelde richtingen
• Het originele vluchtplan is na de aanroep nog exact hetzelfde
• Ook de dictionaries in het originele plan zijn ongewijzigd