Como funcionam os parâmetros de função e argumentos padrão?

Question

Accepted Answer

As funções Python suportam argumentos **posicionais** e **nominados**, além de **valores padrão**. Compreender como eles se combinam — e uma famosa armadilha de argumento padrão — é essencial.

## Argumentos posicionais, nominados e padrão

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

Parâmetros com valores padrão são opcionais; você pode passar argumentos por posição ou por nome (argumentos nomeados melhoram a legibilidade e permitem pular parâmetros opcionais anteriores).

## A famosa armadilha: argumentos padrão mutáveis

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

Valores padrão são avaliados **uma única vez** quando a função é definida, não a cada chamada. Um padrão mutável (lista/dicionário) é portanto compartilhado entre chamadas — um bug clássico. A solução:

```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 apenas nominados e apenas posicionais

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

Os marcadores `*` e `/` permitem forçar como os argumentos são passados — útil para APIs claras e estáveis.

## Por que isso importa

Compreender o tratamento de parâmetros é fundamental para escrever e chamar funções Python corretamente.

Valores padrão tornam as funções flexíveis, e argumentos nomeados tornam as chamadas auto-documentadas.

Crucialmente, a **armadilha do argumento padrão mutável** é um dos bugs mais comuns e confusos do Python — saber que valores padrão são avaliados uma única vez (portanto padrões mutáveis persistem entre chamadas) e a solução do `None`-sentinela previne toda uma classe de erros sutis.

Esse conhecimento é fundamental para projetar APIs de função limpas e previsíveis.