Cum funcționează parametrii funcțiilor și argumentele implicite?

Question

Accepted Answer

Funcțiile Python acceptă argumente **poziționale** și **keyword**, plus **valori implicite**. Înțelegerea modului în care se combină acestea — și o faimoasă problemă cu argumentele implicite — este esențială.

## Argumente poziționale, keyword și implicite

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

Parametrii cu valori implicite sunt opționali; puteți transmite argumente după poziție sau după nume (argumentele keyword îmbunătățesc lizibilitatea și vă permit să omiteți parametrii opționali anteriori).

## Cea faimoasă capcană: argumente implicite mutabile

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

Valorile implicite sunt evaluate **o singură dată** când funcția este definită, nu la fiecare apel. O valoare implicită mutabilă (listă/dicționar) este deci împărtășită între apeluri — o eroare clasică. Soluția:

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

## Parametrii numai keyword și numai poziționale

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

Marajele `*` și `/` vă permit să aplicați restricții asupra modului în care sunt transmise argumentele — util pentru API-uri clare și stabile.

## De ce este important

Înțelegerea gestionării parametrilor este fundamentală pentru scrierea și apelarea corectă a funcțiilor Python.

Valorile implicite fac funcțiile flexibile, iar argumentele keyword fac apelurile autodocumentate.

Crucial, **capcana argumentelor implicite mutabile** este una dintre cele mai frecvente și confuze erori din Python — știind că valorile implicite sunt evaluate o singură dată (deci valorile implicite mutabile persistă între apeluri) și soluția cu `None`-sentinel previne o întreagă clasă de erori subtile.

Această cunoaștere stă la baza proiectării API-urilor de funcții curate și previzibile.