Comment fonctionnent les paramètres de fonction et les arguments par défaut ?

Question

Accepted Answer

Les fonctions Python supportent les arguments **positionnels** et **nommés**, plus les **valeurs par défaut**. Comprendre comment ils se combinent – et une fameuse piège des arguments par défaut – est essentiel.

## Arguments positionnels, nommés et par défaut

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

Les paramètres avec des valeurs par défaut sont facultatifs ; vous pouvez passer des arguments par position ou par nom (les arguments nommés améliorent la lisibilité et vous permettent de sauter les paramètres optionnels précédents).

## La célèbre piège : les arguments par défaut mutables

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

Les valeurs par défaut sont évaluées **une fois** lors de la définition de la fonction, pas à chaque appel. Une valeur par défaut mutable (liste/dict) est donc partagée entre les appels – un bug classique. La solution :

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

## Paramètres nommés uniquement et positionnels uniquement

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

Les marqueurs `*` et `/` vous permettent d'imposer comment les arguments sont passés – utile pour des API claires et stables.

## Pourquoi c'est important

Comprendre la gestion des paramètres est fondamental pour écrire et appeler correctement les fonctions Python.

Les valeurs par défaut rendent les fonctions flexibles, et les arguments nommés rendent les appels autodocumentés.

Surtout, la **piège des arguments par défaut mutables** est l'un des bugs les plus courants et confus de Python – savoir que les valeurs par défaut sont évaluées une fois (donc les valeurs par défaut mutables persistent entre les appels) et la correction du `None`-sentinel prévient toute une classe d'erreurs subtiles.

Cette connaissance fonde la conception d'API de fonction propres et prévisibles.