X'inhu d-differenza bejn l-objects mutable u immutable?

Question

Accepted Answer

Oggett **immutable** ma jistax jinbidel wara l-ħolq; oggett **mutable** jista' jinbidel. Din id-distinzjoni hija ċentrali għal Python u taffettwa l-aliasing, dict keys, function arguments, u klassi ta' bugs sottili.

## It-tnejn kategoriji

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

## Immutable: "bidla" toħloq oggett ġdid

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

Ma' immutables, operazzjonijiet li jidhru "jibdlu" l-valur attwalment jipproduċu oggett ġdid u jirrebindjaw il-varjabbli. L-oriġinali qatt ma jinbidel.

## Mutable: modifika fil-post

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

## Il-qbid ta' aliasing (it-tajga prattika)

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

It-tassenja ta' oggett mutable ma nqassux - iż-żewġ ismijiet jirreferu għall-istess oggett, allokwa l-mutazzjoni permezz ta' wieħed taffettwa l-oħra. Dan jissurprizz ħafna u jikkawża bugs veri.

## Għaliex immutables jistgħu jkunu dict keys / set members

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

Dict keys u set members għandu jkunu **hashable**, li jeħtieġ immutability (immutable key jista' jinbidel u jkassar il-hash table).

## Function arguments

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

## Għaliex dan huwa importanti

Mutability hija kunċett fundamentali ta' Python li tispiega firxa wiesgħa ta' imġieba u bugs: il-qbid ta' aliasing (l-assenjazzjoni ma nqassux mutables), għaliex il-funzjonijiet jistgħu jimmodifikaw lista ppressata iżda mhux int, għaliex biss l-objects immutable jistgħu jkunu dict keys/set members, u l-qbid ta' mutable-default-argument.

L-għarfien li liema tipjiet huma mutable vs immutable — u li l-mutazzjoni ta' oggett imqassam taffettwa l-irfierenza kollha għalih — hija essenzjali għat-tiktib ta' Python korretta u l-evitar ta' xi wħud mill-aktar surpriżi komuni.