Jak fungují parametry funkcí a výchozí argumenty?

Question

Accepted Answer

Funkce v Pythonu podporují **poziční** a **pojmenované** argumenty, plus **výchozí hodnoty**. Pochopení jejich kombinace – a jednoho slavného chybného chování výchozích argumentů – je nezbytné.

## Poziční, pojmenované a výchozí argumenty

```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 s výchozími hodnotami jsou volitelné; argumenty lze předávat podle pozice nebo podle názvu (pojmenované argumenty zlepšují čitelnost a umožňují přeskočit dřívější volitelné parametry).

## Slavné chybné chování: měnitelné výchozí argumenty

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

Výchozí hodnoty jsou vyhodnoceny **jednou** při definici funkce, ne při každém volání. Měnitelná výchozí hodnota (seznam/slovník) je proto sdílena mezi voláními – klasická chyba. Řešení:

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

## Argumenty pouze s klíčem a argumenty pouze s pozicí

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

Znaky `*` a `/` vám umožňují vymáhat, jak se argumenty předávají – užitečné pro jasné a stabilní API.

## Proč na tom záleží

Pochopení zpracování parametrů je zásadní pro správné psaní a volání funkcí v Pythonu.

Výchozí hodnoty činí funkce pružnými a pojmenované argumenty činí volání samodokumentující se.

Vlastně je **past měnitelných výchozích argumentů** jednou z nejčastějších a nejvíce matoucích chyb v Pythonu – vědět, že výchozí hodnoty jsou vyhodnoceny jednou (takže měnitelné výchozí hodnoty přetrvávají mezi voláními) a oprava s `None`-sentinelem zabrání celé třídě jemných chyb.

Tato znalost vytváří základ pro navrhování čistých a předvídatelných rozhraní funkcí.