Koja je razlika između promjenjivих i nepromjenjivих objekata?

Question

Accepted Answer

**Nepromjenjiv** objekt ne može se promijeniti nakon kreiranja; **promjenjiv** objekt može biti promijenjen. Ova razlika je osrednja za Python i utječe na aliasing, dict ključeve, argumente funkcije, i klasu suptilnih grešaka.

## Dvije kategorije

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

## Nepromjenjiv: "promjena" stvara novi 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
```

S nepromjenjivima, operacije koje izgleda da "mijenjaju" vrijednost zapravo proizvode novi objekt i ponovno vežu varijablu. Original se nikada ne mijenja.

## Promjenjiv: modificiran na mjestu

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

## Zamka aliasinga (praktična opasnost)

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

Dodjela promjenjivog objekta ne kopira ga — oba imena odnose se na isti objekt, pa mutacija kroz jedno utječe na drugo. To iznenađuje mnoge i stvara prave greške.

## Zašto nepromjenjivi mogu biti dict ključevi / članovi skupa

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

Dict ključevi i članovi skupa moraju biti **hashable**, što zahtijeva nepromjenjivost (promjenjiv ključ mogao bi se promijeniti i slomiti hash tablicu).

## Argumenti funkcije

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

## Zašto je to važno

Promjenjivost je temeljni Python koncept koji objašnjava širok spektar ponašanja i grešaka: zamka aliasinga (dodjela ne kopira promjenjive), zašto funkcije mogu modificirati proslijeđenu listu, ali ne int, zašto samo nepromjenjivi objekti mogu biti dict ključevi/članovi skupa, i mutable-default-argument zamku.

Razumijevanje kojih tipova su promjenjivi odnosno nepromjenjivi — i da mutacija dijeljenog objekta utječe na sve reference na njega — bitno je za pisanje ispravnog Pythona i izbjegavanje nekih od njegovih najčešćih iznenađenja.