mutable आणि immutable ऑब्जेक्ट्स मध्ये काय फरक आहे?

Question

IT Interview Practice · 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 function (व्यावहारिक धोका)

```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 ऑब्जेक्ट नियोजित करणे त्याची प्रति तयार करत नाही — दोन्ही नावे एकाच ऑब्जेक्टचा संदर्भ देतात, म्हणून एकाद्वारे mutating दुसर्याला प्रभावित करते. हे अনेकांना आश्चर्यचकित करते आणि खरे 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** असणे आवश्यक आहे, ज्यासाठी 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 trap (assignment मutable्स प्रतिलिपि करत नाही), कार्ये पास केलेल्या सूचीला बदलू शकतात पण int ला नाही, फक्त immutable वस्तू dict keys/set members असू शकतात, आणि mutable-default-argument pitfall.

कोणत्या प्रकारे mutable vs immutable आहेत हे समजून घेणे — आणि साझा ऑब्जेक्ट mutating करणे त्याचा सर्व संदर्भांवर परिणाम करते — हे योग्य Python लिहिण्यासाठी आवश्यक आहे आणि त्याच्या सर्वात सामान्य आश्चर्यांपासून बचणे आवश्यक आहे.

दोन श्रेणी

Immutable: "बदल" नव्हा ऑब्जेक्ट तयार करतो

Mutable: जागेवर सुधारित

Aliasing function (व्यावहारिक धोका)

इम्मेटेबल्स dict keys / set members असू शकतात

Function arguments

हे महत्वाचे का आहे

संबंधित प्रश्न