Hva er forskjellen mellom mutable og immutable objekter?

Question

Accepted Answer

Et **immutable** objekt kan ikke endres etter opprettelse; et **mutable** objekt kan det. Denne distinksjonen er sentral i Python og påvirker aliasing, dict-nøkler, funksjonsargumenter og en klasse subtile bugs.

## De to kategoriene

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

## Immutable: "endring" skaper et nytt 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 immutable-objekter produserer operasjoner som ser ut til å "endre" verdien faktisk et nytt objekt og rebinder variabelen. Originalen blir aldri endret.

## Mutable: modifisert på plass

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

## Aliasing-fellen (den praktiske faren)

```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[:]
```

Å tildele et mutable objekt kopierer det ikke — begge navn refererer til samme objekt, så mutasjon gjennom en påvirker den andre. Dette overrasker mange og forårsaker ekte bugs.

## Hvorfor immutables kan være dict-nøkler / set-medlemmer

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

Dict-nøkler og set-medlemmer må være **hashable**, noe som krever immutability (en mutable nøkkel kunne endres og ødelegge hash-tabellen).

## Funksjonsargumenter

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

Mutability er et grunnleggende Python-konsept som forklarer et bredt spekter av atferd og bugs: aliasing-fellen (tildeling kopierer ikke mutable-objekter), hvorfor funksjoner kan modifisere en passert liste men ikke en int, hvorfor bare immutable-objekter kan være dict-nøkler/set-medlemmer, og problemet med mutable default-argumenter.

Å forstå hvilke typer som er mutable kontra immutable — og at mutasjon av et delt objekt påvirker alle referanser til det — er essensielt for å skrive riktig Python og unngå noen av dens mest vanlige overraskelser.