परिवर्तनीय और अपरिवर्तनीय वस्तुओं के बीच क्या अंतर है?

Question

Accepted Answer

एक **अपरिवर्तनीय** वस्तु निर्माण के बाद बदली नहीं जा सकती; एक **परिवर्तनीय** वस्तु बदली जा सकती है। यह अंतर Python के लिए केंद्रीय है और aliasing, dict keys, फ़ंक्शन arguments, और सूक्ष्म bugs के एक वर्ग को प्रभावित करता है।

## दो श्रेणियाँ

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

## अपरिवर्तनीय: "बदलना" एक नई वस्तु बनाता है

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

अपरिवर्तनीय वस्तुओं के साथ, ऐसे संचालन जो मूल्य को "बदलने" जैसे लगते हैं, वास्तव में एक नई वस्तु का उत्पादन करते हैं और चर को पुन: बाध्य करते हैं। मूल को कभी नहीं बदला जाता है।

## परिवर्तनीय: स्थान पर संशोधित

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

एक परिवर्तनीय वस्तु को असाइन करने से इसे कॉपी नहीं किया जाता है — दोनों नाम एक ही वस्तु को संदर्भित करते हैं, इसलिए एक के माध्यम से mutation दूसरे को प्रभावित करता है। यह कई को आश्चर्यचकित करता है और वास्तविक bugs का कारण बनता है।

## क्यों अपरिवर्तनीय 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** होना चाहिए, जिसके लिए अपरिवर्तनीयता की आवश्यकता होती है (एक परिवर्तनीय key बदल सकता है और hash table को तोड़ सकता है)।

## फ़ंक्शन 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
```

## यह महत्वपूर्ण क्यों है

परिवर्तनीयता एक मौलिक Python अवधारणा है जो व्यवहार और bugs की एक विस्तृत श्रृंखला की व्याख्या करती है: aliasing जाल (assignment परिवर्तनीय को कॉपी नहीं करता), क्यों फ़ंक्शन एक पास की गई list को संशोधित कर सकते हैं लेकिन int को नहीं, क्यों केवल अपरिवर्तनीय वस्तुएं dict keys/set members हो सकती हैं, और mutable-default-argument pitfall।

कौन से types परिवर्तनीय बनाम अपरिवर्तनीय हैं — और यह कि एक साझा वस्तु को mutate करने से इसके सभी references प्रभावित होते हैं — सही Python लिखने और इसके कुछ सबसे सामान्य आश्चर्यों से बचने के लिए आवश्यक है।