Kakšna je razlika med spremenljivimi in nespremenljivimi objekti?

Question

Accepted Answer

**Nespremenljiv** objekt se ne more spremeniti po ustvarjanju; **spremenljiv** objekt pa se lahko. Ta razlikovanje je osrednje za Python in vpliva na povezovanje, ključe slovarjev, argumente funkcij in razred subtilnih napak.

## Dve kategoriji

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

## Nespremenljivo: "spreminjanje" ustvari nov 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
```

Z nespremenljivimi objekti operacije, ki se zdijo, da "spreminjajo" vrednost, dejansko ustvarijo nov objekt in ponovno povežejo spremenljivko. Original se nikoli ne spremeni.

## Spremenljivo: spremenjeno na mestu

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

## Pasti povezovanja (praktična nevarnost)

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

Dodelitev spremenljivega objekta ga ne kopira — oba imena se nanašata na isti objekt, zato spreminjanje preko enega vpliva na drugega. To preseneti mnoge in povzroči prave napake.

## Zakaj so nespremenljivi objekti lahko ključi slovarjev / člani množic

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

Ključi slovarjev in člani množic morajo biti **zgoščljivi**, kar zahteva nespremenljivost (spremenljiv ključ bi se lahko spremenil in prekinil razpršilno tabelo).

## Argumenti funkcij

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

## Zakaj je to pomembno

Spremenljivost je temeljna koncepta Pythona, ki pojasnjuje širok spekter vedenja in napak: past povezovanja (dodelitev ne kopira spremenljivih objektov), zakaj funkcije lahko spremenijo posredovani seznam, vendar ne celo število, zakaj samo nespremenljivi objekti lahko postanejo ključi slovarjev/člani množic, in past spremenljivih privzetih argumentov.

Razumevanje, kateri tipi so spremenljivi v primerjavi z nespremenljivimi — in da spreminjanje deljenega objekta vpliva na vse reference nanj — je bistveno za pisanje pravilnega Pythona in izogibanje nekaterim njegovim najbolj pogostim presenetljem.