Wie funktionieren Funktionsparameter und Standardargumente?

Question

Accepted Answer

Python-Funktionen unterstützen **positionelle** und **Schlüsselwort**-Argumente sowie **Standardwerte**. Das Verständnis, wie diese kombiniert werden – und eine berühmte Standardargument-Falle – ist unverzichtbar.

## Positionelle, Schlüsselwort- und Standardargumente

```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
```

Parameter mit Standardwerten sind optional; Sie können Argumente nach Position oder nach Name (Schlüsselwort-Argumente verbessern die Lesbarkeit und ermöglichen es, frühere optionale Parameter zu überspringen) übergeben.

## Die berühmte Falle: veränderliche Standardargumente

```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
```

Standardwerte werden **einmal** bei der Funktionsdefinition ausgewertet, nicht bei jedem Aufruf. Ein veränderbarer Standardwert (Liste/Dict) wird daher zwischen Aufrufen geteilt – ein klassischer Fehler. Die Lösung:

```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
```

## Nur-Schlüsselwort- und Nur-Positionsparameter

```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
    ...
```

Die Marker `*` und `/` ermöglichen es Ihnen, durchzusetzen, wie Argumente übergeben werden – nützlich für klare, stabile APIs.

## Warum es wichtig ist

Das Verständnis der Parameterbehandlung ist grundlegend für das korrekte Schreiben und Aufrufen von Python-Funktionen.

Standardwerte machen Funktionen flexibel, und Schlüsselwort-Argumente machen Aufrufe selbstdokumentierend.

Vor allem ist die **Falle mit veränderbaren Standardargumenten** einer der häufigsten und verwirrendsten Fehler in Python – zu wissen, dass Standardwerte einmal ausgewertet werden (also veränderbare Standardwerte über Aufrufe hinweg bestehen bleiben) und die `None`-Sentinel-Lösung eine ganze Klasse subtiler Fehler verhindert.

Dieses Wissen bildet die Grundlage für die Gestaltung sauberer, vorhersehbarer Funktions-APIs.