மாற்றக்கூடிய மற்றும் மாற்ற முடியாத பொருள்களுக்கு இடையே என்ன வேறுபாடு உள்ளது?

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** ஆக இருக்க வேண்டும், இது மாற்ற முடியாமை தேவை (மாற்றக்கூடிய 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-ல் ஒரு அடிப்படை கருத்தாகும், இது பரந்த அளவிலான நடத்தை மற்றும் பிழைகளை விளக்குகிறது: aliasing பொறி (assignment mutables ஐ நகল செய்யாது), functions ஒரு பாஸ் செய்த list ஐ மாற்ற முடியும் ஆனால் int ஐ நிறிவேற்ற முடியாது ஏன், மாற்ற முடியாத பொருள்கள் மட்டுமே dict keys/set members ஆக இருக்க முடியும் ஏன், மற்றும் mutable-default-argument pitfall.

கொடுக்கப்பட்ட object ஐ மாற்றும் போது அது பொதிந்த object ஐ பாதிக்கிறது என்பதை தெரிந்து கொள்ள வேண்டியது — சரியான Python கோடை எழுதுவதற்கும் அதன் பொதுவான ஆச்சரியங்களை தவிர்ப்பதற்கும் அவசியமாகும்.