Değiştirilebilir ve değiştirilemeyen nesneler arasındaki fark nedir?

Question

Accepted Answer

**Değiştirilemeyen** bir nesne oluşturulduktan sonra değiştirilemez; **değiştirilebilir** bir nesne değiştirilebilir. Bu ayrım Python'da merkezidir ve aliasing, dict keys, function arguments ve ince hataların bir sınıfını etkiler.

## İki kategori

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

## Değiştirilemeyen: "değişiklik" yeni bir nesne oluşturur

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

Değiştirilemeyen nesnelerle, değeri "değiştirmeye" görünen işlemler aslında yeni bir nesne üretir ve değişkeni yeniden bağlar. Orijinal hiçbir zaman değiştirilmez.

## Değiştirilebilir: yerinde değiştirilir

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

## Aliasing tuzağı (pratik tehlike)

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

Değiştirilebilir bir nesneyi atamak onu kopyalamaz — her iki ad aynı nesneye referans verir, bu nedenle biri aracılığıyla mutasyonlar diğerini etkiler. Bu birçoğunu şaşırtır ve gerçek hatalara neden olur.

## Neden değiştirilemeyen nesneler dict keys / set members olabilir

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

Dict keys ve set members **hashable** olmalıdır; bu değiştirilmezlik gerektirir (değiştirilebilir bir key değişebilir ve hash table'ı bozabilir).

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

## Neden önemli

Değişebilirlik, geniş bir davranış ve hata sınıfını açıklayan temel bir Python konseptidir: aliasing tuzağı (atama değiştirilebilir nesneleri kopyalamaz), işlevlerin geçirilen bir listeyi neden değiştirebileceği ama int'i neden değiştiremeyeceği, yalnızca değiştirilemeyen nesnelerin dict keys/set members olabilmesi, ve mutable-default-argument pitfall'u.

Hangi türlerin değiştirilebilir ve değiştirilemeyen olduğunu — ve paylaşılan bir nesnenin mutasyonunun ona olan tüm referansları etkilediğini — anlamak, doğru Python yazmak ve en yaygın sürprizlerinden bazılarını önlemek için gereklidir.