Care este diferența dintre obiectele mutabile și imutabile?

Question

Accepted Answer

Un obiect **imutabil** nu poate fi modificat după creare; un obiect **mutabil** poate fi. Această distincție este centrală în Python și afectează aliasing-ul, cheile dicționarelor, argumentele funcțiilor și o clasă de erori subtile.

## Cele două categorii

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

## Imutabil: "modificarea" creează un obiect nou

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

Cu obiecte imutabile, operațiile care par să "modifice" valoarea produc de fapt un obiect nou și rebind variabila. Originalul nu este niciodată alterat.

## Mutabil: modificat în loc

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

## Capcana aliasing-ului (pericolul practic)

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

Atribuirea unui obiect mutabil nu îl copiază — ambele nume fac referință la același obiect, deci mutarea prin unul afectează și pe celălalt. Aceasta surprinde mulți și provoacă erori reale.

## De ce obiectele imutabile pot fi chei dict / membri set

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

Cheia dict și membrii set trebuie să fie **hashable**, ceea ce necesită imutabilitate (o cheie mutabilă ar putea se schimbe și ar putea defecta tabelul hash).

## Argumente funcție

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

## De ce conteaza

Mutabilitatea este un concept fundamental în Python care explică o gamă largă de comportament și erori: capcana aliasing-ului (atribuirea nu copiază mutabilele), de ce funcțiile pot modifica o listă transmisă dar nu un int, de ce doar obiectele imutabile pot fi chei dict/membri set, și capcana argumentului implicit mutabil.

Înțelegerea care tipuri sunt mutabile vs imutabile — și că mutarea unui obiect partajat afectează toate referințele la el — este esențială pentru scrierea unui Python corect și pentru evitarea unor dintre cele mai comune surprize ale sale.