Jak działają parametry funkcji i argumenty domyślne?

Question

Accepted Answer

Funkcje Pythona obsługują argumenty **pozycyjne** i **nazwane (keyword)**, a także **wartości domyślne**. Zrozumienie, jak się je łączy — i jedna słynna pułapka dotycząca argumentów domyślnych — jest niezbędne.

## Argumenty pozycyjne, nazwane i domyślne

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

Parametry z wartościami domyślnymi są opcjonalne; można przekazywać argumenty poprzez pozycję lub po nazwie (argumenty keyword poprawiają czytelność i pozwalają pominąć wcześniejsze parametry opcjonalne).

## Słynna pułapka: zmienne argumenty domyślne

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

Wartości domyślne są oceniane **raz** podczas definiowania funkcji, a nie przy każdym wywołaniu. Zmienna wartość domyślna (lista/słownik) jest zatem współdzielona między wywołaniami — to klasyczny błąd. Rozwiązanie:

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

## Parametry zależne wyłącznie od słowa kluczowego i pozycji

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

Znaczniki `*` i `/` pozwalają wymusić sposób przekazywania argumentów — przydatne do tworzenia przejrzystych, stabilnych interfejsów API.

## Dlaczego to ważne

Zrozumienie obsługi parametrów jest fundamentalne do prawidłowego pisania i wywoływania funkcji Pythona.

Wartości domyślne czynią funkcje elastycznymi, a argumenty keyword sprawiają, że wywołania są samo-dokumentujące się.

Kluczowe jest to, że **pułapka zmiennych argumentów domyślnych** to jeden z najpowszechniejszych i najbardziej mylących błędów w Pythonie — wiedza o tym, że wartości domyślne są oceniane raz (więc zmienne wartości domyślne utrzymują się między wywołaniami) i naprawa `None`-sentinel zapobiega całej klasie subtelnych błędów.

Ta wiedza stanowi podstawę projektowania czystych, przewidywalnych interfejsów API funkcji.