Wat is het verschil tussen mutable en immutable objecten?

Question

Accepted Answer

Een **immutable** object kan niet worden gewijzigd na creatie; een **mutable** object wel. Dit onderscheid is centraal in Python en beïnvloedt aliasing, dict keys, functieargumenten en een klasse van subtiele bugs.

## De twee categorieën

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

## Immutable: "veranderen" creëert een nieuw object

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

Bij immutables produceren operaties die de waarde "veranderen" eigenlijk een nieuw object en binden ze de variabele opnieuw. Het origineel wordt nooit gewijzigd.

## Mutable: ter plaatse gewijzigd

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

## De aliasing-val (het praktische gevaar)

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

Het toewijzen van een mutable object kopieert het niet — beide namen verwijzen naar hetzelfde object, dus mutatie via de ene beïnvloedt de ander. Dit verrast velen en veroorzaakt echte bugs.

## Waarom immutables dict keys / set members kunnen zijn

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

Dict keys en set members moeten **hashable** zijn, wat immutabiliteit vereist (een mutable key zou kunnen veranderen en de hash table breken).

## Functieargumenten

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

## Waarom het belangrijk is

Mutabiliteit is een fundamenteel Python-concept dat een breed scala aan gedrag en bugs verklaart: de aliasing-val (toewijzing kopieert mutables niet), waarom functies een doorgegeven lijst kunnen wijzigen maar geen int, waarom alleen immutable objecten dict keys/set members kunnen zijn, en het mutable-default-argument-probleem.

Begrijpen welke typen mutable versus immutable zijn — en dat mutatie van een gedeeld object alle verwijzingen ernaar beïnvloedt — is essentieel voor het schrijven van juiste Python en het vermijden van enkele van de meest voorkomende verrassingen.