mutable र immutable वस्तुहरु बीचको अन्तर के हो?

Question

Accepted Answer

**immutable** वस्तु सृजन पछि परिवर्तन गर्न सकिदैन; **mutable** वस्तु परिवर्तन गर्न सकिन्छ। यो भेद Python मा केन्द्रीय हो र aliasing, dict keys, function arguments, र सूक्ष्म bugs को कक्षामा असर गर्छ।

## दुई वर्ग

```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 वस्तु तोकिएको यसलाई नक्कल गर्दैन — दुवै नामहरु एकै वस्तुलाई सन्दर्भ गर्छन्, त्यसैले एकको माध्यमबाट परिवर्तन अर्कोलाई असर गर्छ। यो धेरैलाई अचम्मित गर्छ र वास्तविक bugs कारण गर्छ।

## किन 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** हुनु आवश्यक हो, जसलाई immutability चाहिन्छ (mutable key परिवर्तन हुन सक्छ र 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
```

## यो किन महत्वपूर्ण छ

Mutability एक आधारभूत Python अवधारणा हो जो व्यवहार र bugs को विस्तृत दायरा व्याख्या गर्छ: aliasing को फन्दा (assignment mutables नक्कल गर्दैन), किन प्रकार्यहरु पठाइएको सूची परिवर्तन गर्न सक्छन् तर int छैन, किन केवल immutable वस्तुहरु dict keys/set members हुन सक्छन्, र mutable-default-argument को समस्या।

कुन प्रकारहरु mutable vs immutable छन् भन्ने कुरा बुझ्ने — र साझा वस्तुको परिवर्तन यसको सबै सन्दर्भमा असर गर्छ — सही Python लेख्न र यसका सबैभन्दा सामान्य आश्चर्यहरु बच्न आवश्यक हो।