Come funzionano i parametri della funzione e gli argomenti predefiniti?

Question

Accepted Answer

Le funzioni Python supportano argomenti **posizionali** e **keyword**, oltre a **valori predefiniti**. Capire come si combinano — e una famosa trappola relativa agli argomenti predefiniti — è essenziale.

## Argomenti posizionali, keyword e predefiniti

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

I parametri con valori predefiniti sono facoltativi; puoi passare argomenti per posizione o per nome (gli argomenti keyword migliorano la leggibilità e ti permettono di saltare i parametri facoltativi precedenti).

## La famosa trappola: argomenti predefiniti mutevoli

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

I valori predefiniti vengono valutati **una sola volta** quando la funzione è definita, non ad ogni chiamata. Un valore predefinito mutevole (lista/dict) viene quindi condiviso tra le chiamate — un bug classico. La soluzione:

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

## Parametri solo keyword e solo posizionali

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

I marcatori `*` e `/` ti permettono di imporre come vengono passati gli argomenti — utile per API chiare e stabili.

## Perché è importante

Comprendere la gestione dei parametri è fondamentale per scrivere e chiamare correttamente le funzioni Python.

I valori predefiniti rendono le funzioni flessibili, e gli argomenti keyword rendono le chiamate auto-documentate.

Fondamentalmente, **la trappola dell'argomento-predefinito-mutevole** è uno dei bug Python più comuni e confusi — sapere che i valori predefiniti vengono valutati una sola volta (quindi i valori predefiniti mutevoli persistono tra le chiamate) e la correzione `None`-sentinel previene un'intera classe di errori sottili.

Questa conoscenza è alla base della progettazione di API funzione pulite e prevedibili.