Hvad er forskellen mellem ændelige og uændelige objekter?

Question

Accepted Answer

Et **uændeligt** objekt kan ikke ændres efter oprettelse; et **ændeligt** objekt kan. Denne sondring er central i Python og påvirker aliasing, dict keys, funktionsargumenter og en klasse af subtile fejl.

## De to kategorier

```text
Immutable: int, float, bool, str, tuple, frozenset, bytes, None
Mutable:   list, dict, set, bytearray, and most custom objects
```

## Uændeligt: "ændring" skaber et nyt objekt

```python
x = "hello"
x.upper()       # returns a NEW string "HELLO" — x is unchanged
x += " world"   # rebinds x to a NEW string; the original "hello" is untouched

n = 5
n += 1          # creates a new int 6; doesn't modify the int object 5
```

Med uændelige objekter producerer operationer, der ser ud til at "ændre" værdien, faktisk et nyt objekt og rebinder variablen. Det originale ændres aldrig.

## Ændeligt: ændret på stedet

```python
lst = [1, 2, 3]
lst.append(4)   # modifies the SAME list object → [1, 2, 3, 4]
lst[0] = 99     # in-place change
```

## Aliasing-fælden (den praktiske fare)

```python
# mutable — two names point to the SAME object
a = [1, 2, 3]
b = a            # b is NOT a copy — it's the same list
b.append(4)
print(a)         # [1, 2, 3, 4] ← a changed too! (they're aliases)

# to actually copy:
b = a.copy()     # or list(a), or a[:]
```

At tildele et ændeligt objekt kopierer det ikke — begge navne refererer til samme objekt, så mutation gennem det ene påvirker det andet. Dette overrasker mange og forårsager virkelige fejl.

## Hvorfor uændelige kan være dict keys / set members

```python
d = {(1, 2): "point"}   # ✅ tuple key — immutable, hashable
d = {[1, 2]: "x"}       # ❌ TypeError — lists are unhashable (mutable)
```

Dict keys og set members skal være **hashable**, hvilket kræver uændelighed (en ændeligt nøgle kunne ændres og ødelægge hash table).

## Funktionsargumenter

```python
def modify(lst): lst.append(99)   # mutates the caller's list (passed by reference)
def rebind(n): n += 1             # rebinds locally; caller's int unchanged
```

## Hvorfor det betyder noget

Ændelighed er et grundlæggende Python-koncept, der forklarer et bredt spektrum af adfærd og fejl: aliasing-fælden (tildeling kopierer ikke ændelige), hvorfor funktioner kan ændre en videregivet liste, men ikke et tal, hvorfor kun uændelige objekter kan være dict keys/set members, og problemet med mutable-default-argument.

At forstå, hvilke typer der er ændelige versus uændelige — og at mutation af et delt objekt påvirker alle referencer til det — er væsentligt for at skrive korrekt Python og undgå nogle af dets mest almindelige overraskelser.