Vad är skillnaden mellan muterbara och omuterbara objekt?

Question

Accepted Answer

Ett **omäderligt** objekt kan inte ändras efter skapandet; ett **muterbara** objekt kan. Denna skillnad är central i Python och påverkar aliasering, dict-nycklar, funktionsargument och en klass av subtila buggar.

## De två kategorierna

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

## Omuterbara: "ändringar" skapar ett 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 omuterbara, operationer som verkar "ändra" värdet producerar faktiskt ett nytt objekt och återbinder variabeln. Originalet ändras aldrig.

## Muterbara: modifierat på plats

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

## Aliaseringsfällan (den praktiska faran)

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

Att tilldela ett muterbara objekt kopierar det inte — båda namnen refererar till samma objekt, så mutation genom ett påverkar det andra. Detta överraskar många och orsakar verkliga buggar.

## Varför omuterbara kan vara dict-nycklar / set-medlemmar

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

Dict-nycklar och set-medlemmar måste vara **hashbara**, vilket kräver omutabilitet (en muterbara nyckel kunde ändras och bryta hash-tabellen).

## Funktionsargument

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

## Varför det är viktigt

Mutabilitet är ett grundläggande Python-koncept som förklarar ett brett spektrum av beteende och buggar: aliaseringsfällan (tilldelning kopierar inte muterbara), varför funktioner kan ändra en skickad lista men inte en int, varför endast omuterbara objekt kan vara dict-nycklar/set-medlemmar, och pitfallet för muterbara standardargument.

Att förstå vilka typer som är muterbara jämfört med omuterbara — och att mutation av ett delat objekt påverkar alla referenser till det — är väsentligt för att skriva korrekt Python och undvika några av dess vanligaste överraskningar.