¿Cómo funcionan los parámetros de función y los argumentos por defecto?

Question

Accepted Answer

Las funciones de Python admiten argumentos **posicionales** y **por palabra clave**, además de **valores por defecto**. Comprender cómo se combinan —y una famosa trampa de los argumentos por defecto— es esencial.

## Argumentos posicionales, por palabra clave y por defecto

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

Los parámetros con valores por defecto son opcionales; puedes pasar argumentos por posición o por nombre (los argumentos por palabra clave mejoran la legibilidad y te permiten omitir parámetros opcionales anteriores).

## La famosa trampa: argumentos por defecto 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
```

Los valores por defecto se evalúan **una sola vez** cuando se define la función, no en cada llamada. Por lo tanto, un valor por defecto mutable (list/dict) se comparte entre llamadas: un error clásico. La solución:

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

## Parámetros solo por palabra clave y solo posicionales

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

Los marcadores `*` y `/` te permiten imponer cómo se pasan los argumentos, útil para APIs claras y estables.

## Por qué es importante

Comprender el manejo de parámetros es fundamental para escribir y llamar correctamente a las funciones de Python.

Los valores por defecto hacen que las funciones sean flexibles, y los argumentos por palabra clave hacen que las llamadas se autodocumenten.

Fundamentalmente, la **trampa del argumento por defecto mutable** es uno de los errores más comunes y confusos de Python: saber que los valores por defecto se evalúan una sola vez (de modo que los valores por defecto mutables persisten entre llamadas) y la solución del centinela `None` previene toda una clase de errores sutiles.

Este conocimiento sustenta el diseño de APIs de funciones limpias y predecibles.