Hoe werken functieparameters en standaardargumenten?

Question

Accepted Answer

Python-functies ondersteunen **positional** en **keyword** argumenten, plus **standaardwaarden**. Het begrijpen van hoe ze worden gecombineerd — en één beroemde standaardargument-valkuil — is essentieel.

## Positional, keyword en standaardargumenten

```python
def greet(name, greeting="Hello", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

greet("Ann")                          # positional → "Hello, Ann!"
greet("Ann", "Hi")                    # "Hi, Ann!"
greet("Ann", punctuation=".")          # keyword arg → "Hello, Ann."
greet(name="Ann", greeting="Hey")      # all by keyword
```

Parameters met standaardwaarden zijn optioneel; u kunt argumenten op positie of op naam doorgeven (sleutelwoordargumenten verbeteren de leesbaarheid en stellen u in staat eerdere optionele parameters over te slaan).

## De beroemde valkuil: mutable standaardargumenten

```python
# ❌ DANGER — the default list is created ONCE and SHARED across all calls
def add_item(item, items=[]):
    items.append(item)
    return items

add_item("a")   # ["a"]
add_item("b")   # ["a", "b"]  ← surprise! the SAME list persisted
```

Standaardwaarden worden **eenmaal** geëvalueerd wanneer de functie wordt gedefinieerd, niet bij elke aanroep. Een mutable standaardwaarde (lijst/dict) wordt daarom tussen aanroepen gedeeld — een klassieker bug. De oplossing:

```python
# ✅ use None as the default and create a fresh object inside
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items
```

## Keyword-only en positional-only parameters

```python
def f(a, b, *, key):       # `*` → `key` MUST be passed by keyword
    ...
f(1, 2, key=3)             # ✅   f(1, 2, 3) ❌

def g(a, b, /, c):         # `/` → a, b MUST be positional
    ...
```

De markeringen `*` en `/` stellen u in staat af te dwingen hoe argumenten worden doorgegeven — nuttig voor duidelijke, stabiele API's.

## Waarom het belangrijk is

Het begrijpen van parameterverwerking is fundamenteel voor het correct schrijven en aanroepen van Python-functies.

Standaardwaarden maken functies flexibel, en sleutelwoordargumenten maken aanroepen self-documenting.

Cruciaal gezegd, de **mutable-standaardargument-valkuil** is een van de meest voorkomende en verwarrende bugs van Python — weten dat standaardwaarden eenmaal worden geëvalueerd (dus mutable standaardwaarden blijven behouden over aanroepen) en de `None`-sentinel-fix voorkomt een hele klasse van subtiele fouten.

Deze kennis is de basis voor het ontwerpen van schone, voorspelbare functie-API's.