Jaka jest różnica między obiektami mutowalnymi a niemutowalnymi?

Question

Accepted Answer

Obiekt **nieruchomy** (immutable) nie może być zmieniony po utworzeniu; obiekt **mutowalny** (mutable) może. To rozróżnienie jest centralne dla Pythona i wpływa na aliasing, klucze dict, argumenty funkcji oraz klasę subtelnych błędów.

## Dwie kategorie

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

## Immutable: "zmiana" tworzy nowy obiekt

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

Dla obiektów niezmiennych operacje, które wydają się "zmienić" wartość, faktycznie tworzą nowy obiekt i ponownie wiążą zmienną. Oryginał nigdy nie jest zmieniany.

## Mutable: modyfikacja w miejscu

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

## Pułapka aliasingu (praktyczne niebezpieczeństwo)

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

Przypisanie obiektu mutowalnego go nie kopiuje — obie nazwy odnoszą się do tego samego obiektu, więc mutacja przez jeden wpływa na drugi. To zaskakuje wiele osób i powoduje rzeczywiste błędy.

## Dlaczego obiekty immutable mogą być kluczami dict / członkami set

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

Klucze dict i członkowie set muszą być **hashowalne**, co wymaga niezmienności (mutowalny klucz mógłby się zmienić i złamać tablicę hash).

## Argumenty funkcji

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

## Dlaczego to ważne

Mutowalność jest fundamentalną koncepcją Pythona, która wyjaśnia szeroki zakres zachowań i błędów: pułapka aliasingu (przypisanie nie kopiuje mutowali), dlaczego funkcje mogą modyfikować przekazaną listę, ale nie int, dlaczego tylko obiekty niezmienne mogą być kluczami dict/członkami set, oraz pułapka mutowalnego argumentu domyślnego.

Zrozumienie, które typy są mutowalne a które niezmienne — oraz że mutacja obiektu wspóldzielonego wpływa na wszystkie odniesienia do niego — jest niezbędne do pisania poprawnego Pythona i unikania niektórych z jego najczęstszych niespodzianek.