Hur fungerar funktionsparametrar och standardargument?

Question

IT Interview Practice · Accepted Answer

Python-funktioner stöder **positionella** och **nyckelord**-argument, plus **standardvärden**. Att förstå hur de kombineras — och ett berömt fallgrop med standardargument — är väsentligt.

## Positionella, nyckelord- och standardargument

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

Parametrar med standardvärden är valfria; du kan skicka argument efter position eller efter namn (nyckelord förbättrar läsbarheten och låter dig hoppa över tidigare valfria parametrar).

## Det berömda fallet: muterbar standardargument

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

Standardvärden utvärderas **en gång** när funktionen definieras, inte vid varje anrop. En mutbar standard (lista/dict) delas därför mellan anrop — en klassisk bugg. Lösningen:

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

## Nyckelord-endast och positionell-endast parametrar

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

Markörerna `*` och `/` låter dig tvinga hur argument skickas — användbart för tydliga, stabila API:er.

## Varför det är viktigt

Att förstå parameterhantering är grundläggande för att skriva och anropa Python-funktioner korrekt.

Standardvärden gör funktioner flexibla, och nyckelord gör anrop själv-dokumenterande.

Kruciallt är **fällan med mutbar standardargument** en av Pythons vanligaste och mest förvirrande buggar — att veta att standardvärden utvärderas en gång (så mutbara standardvärden kvarstår mellan anrop) och `None`-sentinel-fixet förhindrar en hel klass av subtila fel.

Denna kunskap understödjer utformning av rena, förutsägbara funktions-API:er.

Positionella, nyckelord- och standardargument

Det berömda fallet: muterbar standardargument

Nyckelord-endast och positionell-endast parametrar

Varför det är viktigt

Relaterade frågor