Hvordan fungerer funksjonsparametere og standardargumenter?

Question

Accepted Answer

Python-funksjoner støtter **posisjonsbaserte** og **navnebaserte** argumenter, pluss **standardverdier**. Å forstå hvordan de kombineres — og en kjent gotcha med standardargumenter — er essensielt.

## Posisjonsbaserte, navnebaserte og standardargumenter

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

Parametere med standardverdier er valgfrie; du kan sende argumenter etter posisjon eller ved navn (navnebaserte argumenter forbedrer lesbarhet og lar deg hoppe over tidligere valgfrie parametere).

## Den kjente gotchaen: mutable standardargumenter

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

Standardverdier evalueres **en gang** når funksjonen defineres, ikke ved hver anrop. En mutable standardverdi (list/dict) deles derfor mellom anrop — en klassisk feil. 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
```

## Kun-navnebaserte og kun-posisjonsbaserte parametere

```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ørene `*` og `/` lar deg håndheve hvordan argumenter sendes — nyttig for klare, stabile APIer.

## Hvorfor det betyr noe

Å forstå parameterbehandling er grunnleggende for å skrive og kalle Python-funksjoner riktig.

Standardverdier gjør funksjoner fleksible, og navnebaserte argumenter gjør anrop selvforklarende.

Avgjørende er at **mutable-default-argument-fellen** er en av Pythons mest vanlige og forvirrende feil — å vite at standardverdier evalueres en gang (så mutable standardverdier vedvarer på tvers av anrop) og `None`-sentinel-løsningen forhindrer en hel klasse subtile feil.

Denne kunnskapen legger grunnlaget for å designe rene, forutsigbare funksjons-APIer.