ਮਿਊਟੇਬਲ ਅਤੇ ਇਮਿਊਟੇਬਲ ਆਬਜੈਕਟਸ ਵਿੱਚ ਕੀ ਫਰਕ ਹੈ?

Question

Accepted Answer

ਇੱਕ **immutable** ਆਬਜੈਕਟ ਬਣਾਉਣ ਤੋਂ ਬਾਅਦ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ; ਇੱਕ **mutable** ਆਬਜੈਕਟ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਫਰਕ Python ਵਿੱਚ ਕੇਂਦਰੀ ਹੈ ਅਤੇ aliasing, dict keys, function arguments, ਅਤੇ subtle 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 ਆਬਜੈਕਟ ਨੂੰ ਅਸਾਈਨ ਕਰਨਾ ਇਸ ਨੂੰ ਕਾਪੀ ਨਹੀਂ ਕਰਦਾ — ਦੋਨੋਂ ਨਾਮ ਉਸੀ ਆਬਜੈਕਟ ਦਾ ਸੰਦਰਭ ਦਿੰਦੇ ਹਨ, ਇਸ ਲਈ ਇੱਕ ਦੁਆਰਾ mutate ਕਰਨ ਨਾਲ ਦੂਸਰਾ ਪ੍ਰਭਾਵਿਤ ਹੁੰਦਾ ਹੈ। ਇਹ ਬਹੁਤਿਆਂ ਨੂੰ ਹੈਰਾਨ ਕਰਦਾ ਹੈ ਅਤੇ ਅਸਲ 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 mutable ਨੂੰ ਕਾਪੀ ਨਹੀਂ ਕਰਦਾ), ਕਿਉਂ ਫੰਕਸ਼ਨਸ pass-in ਕੀਤੀ list ਨੂੰ modify ਕਰ ਸਕਦੇ ਹਨ ਪਰ int ਨੂੰ ਨਹੀਂ, ਕਿਉਂ ਸਿਰਫ immutable ਆਬਜੈਕਟਸ dict keys/set members ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ mutable-default-argument ਪਤੀ।

ਇਹ ਸਮਝਣਾ ਕਿ ਕਿਹੜੀ ਕਿਸਮ mutable vs immutable ਹਨ — ਅਤੇ ਇਹ ਕਿ shared ਆਬਜੈਕਟ ਨੂੰ mutate ਕਰਨਾ ਇਸ ਦੇ ਸਾਰੇ ਸੰਦਰਭਾਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ — ਸਹੀ Python ਲਿਖਣ ਅਤੇ ਇਸ ਦੀਆਂ ਸਭ ਤੋਂ ਆਮ ਹੈਰਾਨੀਆਂ ਨੂੰ ਰੋਕਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।