Jaký je rozdíl mezi proměnnými a neproměnnými objekty?

Question

Accepted Answer

**Neproměnný** objekt nelze po vytvoření změnit; **proměnný** objekt lze změnit. Tento rozdíl je ústřední v Pythonu a ovlivňuje aliasing, dict keys, argumenty funkcí a třídu jemných chyb.

## Dvě kategorie

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

## Neproměnný: "změna" vytvoří 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
```

U neproměnných objektů operace, které se zdají "měnit" hodnotu, ve skutečnosti vytvořují nový objekt a znovu váží proměnnou. Původní objekt se nikdy nezmění.

## Proměnný: změněn na místě

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

## Vlastnost aliasingová past (praktické nebezpečí)

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

Přiřazení proměnného objektu jej nekopíruje — oba názvy odkazují na stejný objekt, takže mutace prostřednictvím jednoho ovlivní druhý. To překvapí mnohé a způsobuje skutečné chyby.

## Proč neproměnné mohou být dict keys / set members

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

Dict keys a set members musí být **hashable**, což vyžaduje neměnnost (proměnný klíč by se mohl změnit a zlomit hash table).

## Argumenty funkcí

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

## Proč na tom záleží

Proměnnost je základní koncept v Pythonu, který vysvětluje širokou řadu chování a chyb: aliasingovou past (přiřazení nekopíruje proměnné), proč mohou funkce upravit předaný seznam, ale ne int, proč pouze neproměnné objekty mohou být dict keys/set members, a problemem s mutable-default-argument.

Rozvětšení, které typy jsou proměnné versus neproměnné — a že mutace sdíleného objektu ovlivňuje všechny odkazy na něj — je nezbytné pro psaní správného Pythonu a vyhnutí se některým jeho nejčastějším překvapením.