మార్పు చేయదగిన మరియు మార్పు చేయలేని ఆబ్జెక్టుల మధ్య తేడా ఏమిటి?

Question

Accepted Answer

**మార్పు చేయలేని** ఆబ్జెక్ట్‌ను సృష్టించిన తర్వాత మార్చలేరు; **మార్పు చేయదగిన** ఆబ్జెక్ట్‌ను చేయవచ్చు. ఈ వ్యత్యాసం 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
```

## మార్పు చేయలేనిది: "మార్పు" ఒక నতুన ఆబ్జెక్ట్‌ను సృష్టిస్తుంది

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

మార్పు చేయదగిన ఆబ్జెక్ట్‌ను కేటాయించడం దానిని నకల్ చేయదు — రెండు పేర్లు ఒకే ఆబ్జెక్ట్‌ను సూచిస్తాయి, కాబట్టి ఒక ద్వారా మార్పు చేయడం మరొకటిని ప్రభావితం చేస్తుంది. ఇది చాలా మందిని ఆశ్చర్యపరుస్తుంది మరియు నిజమైన బగ్‌లను కలిగిస్తుంది.

## మార్పు చేయలేని వాటి 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** ఉండాలి, దీనికి మార్పు చేయలేనితను అవసరం (మార్పు చేయదగిన కీ మార్చవచ్చు మరియు 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 లో ఒక ఆధారమైన కధన, ఇది విస్తృత శ్రేణి ప్రవర్తన మరియు బగ్‌లను వివరిస్తుంది: aliasing ట్రాప్ (కేటాయింపు mutables ను నకల్ చేయదు), functions ఆ పాస్ చేసిన జాబితాను సవరించగలరు కానీ int ఎందుకు, మార్పు చేయలేని ఆబ్జెక్టులు మాత్రమే dict keys/set members ఎందుకు, మరియు mutable-default-argument pitfall.

ఏ రకాలు మార్పు చేయదగినవి మరియు మార్పు చేయలేనివి — మరియు ఒక భాగస్వామ్య ఆబ్జెక్ట్‌ను సవరించడం దానికి సంబంధించిన అన్ని సూచనలను ప్రభావితం చేస్తుంది — సరైన Python లను వ్రాయడానికి మరియు దాని సర్వసాధారణ ఆశ్చర్యాలను నివారించడానికి అవసరం.