Hvordan fungerer funktionsparametre og standardargumenter?

Question

Accepted Answer

Python-funktioner understøtter **positionelle** og **navngivne** argumenter, plus **standardværdier**. At forstå, hvordan de kombineres – og ét berømt standardargument-problem – er væsentligt.

## Positionelle, navngivne 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
```

Parametre med standardværdier er valgfri; du kan videregive argumenter efter position eller ved navn (navngivne argumenter forbedrer læsbarheden og lader dig springe tidligere valgfri parametre over).

## Det berømte problem: ændelige 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
```

Standardværdier evalueres **én gang** når funktionen defineres, ikke ved hvert kald. En ænderlig standardværdi (liste/ordbog) deles derfor mellem kald – en klassisk fejl. 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-navngivne og kun-positionelle parametre

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

Markeringerne `*` og `/` lader dig håndhæve, hvordan argumenter videregives – nyttig for klare, stabile API'er.

## Hvorfor det betyder noget

At forstå parameterbehandling er grundlæggende for at skrive og kalde Python-funktioner korrekt.

Standardværdier gør funktioner fleksible, og navngivne argumenter gør kald selvendokumenterende.

Vigtigst af alt er **problemet med ændelige standardargumenter** en af Pythons mest almindelige og forvirrende fejl – at vide, at standardværdier evalueres én gang (så ændelige standardværdier vedvarer mellem kald) og `None`-sentinel-løsningen forhindrer en hel klasse af subtile fejl.

Denne viden danner grundlaget for at designe rene, forudsigelige funktions-API'er.