How do function parameters and default arguments work?

Question

Accepted Answer

Python functions support **positional** and **keyword** arguments, plus **default values**. Understanding how they combine — and one famous default-argument pitfall — is essential.

## Positional, keyword, and default arguments

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

Parameters with defaults are optional; you can pass arguments by position or by name (keyword args improve readability and let you skip earlier optional params).

## The famous gotcha: mutable default arguments

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

Default values are evaluated **once** when the function is defined, not each call. A mutable default (list/dict) is therefore shared between calls — a classic bug. The fix:

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

## Keyword-only and positional-only parameters

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

The `*` and `/` markers let you enforce how arguments are passed — useful for clear, stable APIs.

## Why it matters

Understanding parameter handling is fundamental to writing and calling Python functions correctly.

Defaults make functions flexible, and keyword arguments make calls self-documenting.

Crucially, the **mutable-default-argument trap** is one of Python's most common and confusing bugs — knowing that defaults are evaluated once (so mutable defaults persist across calls) and the `None`-sentinel fix prevents a whole class of subtle errors.

This knowledge underpins designing clean, predictable function APIs.