Koks yra skirtumas tarp mutable ir immutable objektų?

Question

Accepted Answer

**immutable** objektas negali būti keičiamas po sukūrimo; **mutable** objektas gali. Šis skirtumas yra esmingas Python kalbai ir daro poveikį aliasavimui, dict raktams, funkcijų argumentams ir subtiliems klaidoms.

## Dvi kategorijos

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

## Immutable: "keitimas" sukuria naują 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
```

Su immutable objektais, operacijos, kurios atrodo "keičia" reikšmę, iš tikrųjų sukuria naują objektą ir iš naujo susieja kintamąjį. Originalas niekada nebus pakeistas.

## Mutable: keičiamas vietoje

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

## Aliasavimo spąstai (praktinis pavojus)

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

Mutable objekto priskyrimas jį nekopijuoja — abi vardai nurodo tą patį objektą, todėl mutavimas per vieną paveikia kitą. Tai nustebina daugelį ir sukelia tikras klaidas.

## Kodėl immutable objektai gali būti dict raktai / set nariai

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

Dict raktai ir set nariai turi būti **hashable**, o tai reikalauja neišmainymo (mutable raktas galėtų pasikeisti ir sugadinti maišos lentelę).

## Funkcijų argumentai

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

## Kodėl tai svarbu

Neišmainymas yra esminė Python koncepcija, kuri paaiškina plačią elgesio ir klaidų gamą: aliasavimo spąstai (priskyrimas nekopijuoja mutable), kodėl funkcijos gali modifikuoti perduotą sąrašą bet ne int, kodėl tik immutable objektai gali būti dict raktai/set nariai, ir mutable-default-argument spąstai.

Supratimas, kurie tipai yra mutable vs immutable — ir kad bendro objekto mutavimas paveikia visas nuorodas į jį — yra būtinas norint parašyti teisingą Python kodą ir išvengti kai kurių dažniausiai sutinkamų netikėtumų.