რა განსხვავებაა mutable და immutable ობიექტებს შორის?

Question

Accepted Answer

**immutable** ობიექტი შექმნის შემდეგ შეუძლია შეიცვალოს; **mutable** ობიექტი შეიძლება. ეს განსხვავება ცენტრალური است Python-ში და გავლენას ახდენს aliasing-ზე, dict keys-ზე, function arguments-ზე და რთული ხარვეზების კლასზე.

## ორი კატეგორია

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

## Immutable: "ცვლილება" ახალი ობიექტის შექმნა

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

immutables-ის შემთხვევაში, ოპერაციები, რომლებიც ღირებულების "შეცვლას" გამოიყურება, სინამდვილეში ახალი ობიექტს აწარმოებენ და ცვლადს კვლავ აკავშირებენ. ორიგინალი არასოდეს იცვლება.

## Mutable: ადგილზე შეცვლა

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

## Aliasing-ის ხაფანგი (პრაქტიკული საფრთხე)

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

mutable ობიექტის მინიჭება არ აკოპირებს - ორივე სახელი ერთ ობიექტზე მიმართავს, ამიტომ ერთის მუტაცია მეორეს აზეგავლენებს. ეს მრავალ განვითარებელს აკვირებინებს და რეალური ხარვეზებს იწვევს.

## რატომ immutables შეიძლება იყოს dict keys / set members

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

Dict keys და set members უნდა იყოს **hashable**, რაც იმუტაციულობას მოითხოვს (mutable key შეიცვლებოდა და hash ცხრილს დააზიანებს).

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

## რატომ არის ეს მნიშვნელოვანი

Mutability არის Python-ის ფუნდამენტური კონცეფცია, რომელიც აიხსნის ყოფაქცევის ფართო დიაპაზონს და ხარვეზებს: aliasing-ის ხაფანგი (assignment არ აკოპირებს mutables), რატომ შეუძლია ფუნქციას შეცვალოს გადაცემული სია მაგრამ არა int, რატომ შეიძლება მხოლოდ immutable ობიექტები იყოს dict keys/set members, და mutable-default-argument ხაფანგი.

რომელი ტიპებია mutable vs immutable - და ის, რომ გაზიარებული ობიექტის მუტაცია აკავშირებს ყველა მითითებას მასზე - აუცილებელია სწორი Python-ის დასაწერად და მის ყველაზე ხშირი გასაკვირი მომენტების თავიდან აცილებისთვის.