Kuna tofauti gani kati ya vitu vinavyobadilika na visivyobadilika?

Question

Accepted Answer

Kitu **kisichobadilika** hakiwezi kubadilishwa baada ya kuumbwa; kitu **kinachobadilika** kinaweza. Tofauti hii ni ya msingi katika Python na huathiri aliasing, dict keys, arguments ya kazi, na kategoria ya mababa ya ajabu.

## Kategoria mbili

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

## Kisichobadilika: "mabadiliko" huunda kitu kipya

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

Kwa visichobadilika, operesheni zinazoonekana "kubadilisha" thamani kwa kweli huzalisha kitu kipya na kurudisha variable. Kile asili hakibadilishwi kamwe.

## Kinachobadilika: kinabadilishwa kwa mahali

```python
lst = [1, 2, 3]
lst.append(4)   # modifies the SAME list object → [1, 2, 3, 4]
lst[0] = 99     # in-place change
```

## Mitego ya aliasing (hatari ya vitendo)

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

Kugawa kitu kinachobadilika hakuna kumlinganisha — majina yote mawili yanarejelea kitu kimoja, kwa hiyo kubadilisha kupitia moja kunaathiri nyingine. Hii inahangaisha wengi na husababisha mababa ya kweli.

## Kwa nini visichobadilika vinaweza kuwa dict keys / set members

```python
d = {(1, 2): "point"}   # ✅ tuple key — immutable, hashable
d = {[1, 2]: "x"}       # ❌ TypeError — lists are unhashable (mutable)
```

Dict keys na set members lazima iwe **hashable**, ambayo inahitaji kutobadilika (key inayobadilika inaweza kubadilika na kuvunja 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
```

## Kwa nini hii ni muhimu

Kudadilika ni dhana ya kimsingi ya Python inayoeleza mipango mpana ya tabia na mababa: mitego ya aliasing (mgao haufuti visivyobadilika), kwa nini kazi zinaweza kubadilisha orodha iliyopitiwa lakini si int, kwa nini tu vitu visichobadilika vinaweza kuwa dict keys/set members, na hatari ya argument chaguomsingi linayobadilika.

Kuelewa ni aina gani zinazobadilika dhidi ya zisizobadilika — na kwamba kubadilisha kitu kilichoshirikiwa kunaathiri marejeleo yote yake — ni muhimu kwa kuandika Python sahihi na kuepuka baadhi ya maajabu yake yanayojirudia zaidi.