Hogyan működnek a függvény paraméterek és az alapértelmezett argumentumok?

Question

Accepted Answer

A Python függvények támogatnak **pozicionális** és **kulcsszavas** argumentumokat, valamint **alapértelmezett értékeket**. Annak megértése, hogy ezek hogyan kombinálódnak — és egy híres alapértelmezett argumentum csapda — elengedhetetlen.

## Pozicionális, kulcsszavas és alapértelmezett argumentumok

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

Az alapértelmezett értékkel rendelkező paraméterek opcionálisak; az argumentumokat pozíció szerint vagy név szerint (kulcsszavas argumentumok) adhatja át, amely javítja az olvashatóságot és lehetővé teszi a korábbi opcionális paraméterek kihagyását.

## A híres csapda: megváltoztatható alapértelmezett argumentumok

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

Az alapértelmezett értékeket **egyszer** értékelnek fel, amikor a függvény definiálva van, nem pedig minden egyes híváskor. A megváltoztatható alapértelmezett (lista/szótár) ezért megosztott a hívások között — klasszikus hiba. A megoldás:

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

## Csak kulcsszavas és csak pozicionális paraméterek

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

A `*` és `/` jelölések lehetővé teszik az argumentumok átadásának módjára vonatkozó előírások — hasznos az egyértelmű, stabil API-khoz.

## Miért fontos

A paraméter kezelésének megértése alapvető a Python függvények helyes írásához és meghívásához.

Az alapértelmezett értékek rugalmassá teszik a függvényeket, a kulcsszavas argumentumok pedig önmagyarázóvá teszik a hívásokat.

Döntően a **megváltoztatható-alapértelmezett-argumentum csapda** a Python egyik legelterjedtebb és legzavaróbb hibája — tudva, hogy az alapértelmezett értékeket egyszer értékelnek fel (így a megváltoztatható alapértelmezések megmaradnak a hívások között) és a `None`-sentinel javítás megelőzi a finom hibák egész osztályát.

Ez a tudás a tiszta, kiszámítható függvény API-k tervezésének alapja.