# Python Dersleri #28: Kısayol Atama İşleçleri

Kaynak: https://webodasi.com/python-dersleri-28-kisayol-atama-islecleri/
Yazar: Uzmoon
Yayın: 2026-11-18
Güncelleme: 2026-11-18

> Bu ders Python'da kısayol atama işleçlerini (+=, -=, *=, /=, //=, %=, **=) anlatır. Değişken değerlerini güncellerken kodun okunabilirliğini ve yazım hızını artıran bu operatörlerin kullanım kuralları ve örnekleri gösterilmiştir.

## Bu Dersin Amacı

 

Bu dersin amacı, Python'da sayısal değişkenlerin değerlerini aritmetik işlemlerle güncellerken yazılabilecek kısayol atama işleçlerini (augmented assignment operators) tanıtmak ve pratik kullanımını kavratmaktır.

 

## Kısayol Atama İşleçleri Nedir?

 

Programlamada bir değişkenin üzerine ekleme, çıkarma, çarpma veya bölme yaparak kendisini güncellemek yaygın bir işlemdir. Standart yazımda `sayi = sayi + 5` şeklinde yazılırken, Python bu işlemi `sayi += 5` şeklinde kısaltmamızı sağlar. Bu operatörler kodun hem daha kısa hem de daha okunabilir olmasını sağlar. Genel sözdizimi `degisken operator= deger` şeklindedir.

 

## Temel Aritmetik Kısayol İşleçleri

 

Python'da standart matematiksel işlemlere karşılık gelen kısayol atama operatörleri şunlardır:

 

- **+=** : Toplama ve atama (`x += y` → `x = x + y`)
- **-=** : Çıkarma ve atama (`x -= y` → `x = x - y`)
- ***=** : Çarpma ve atama (`x *= y` → `x = x * y`)
- **/=** : Bölme ve atama (`x /= y` → `x = x / y`, sonuç her zaman float olur)
- **//=** : Tam bölme ve atama (`x //= y` → `x = x // y`)
- **%=** : Modül (kalan) alma ve atama (`x %= y` → `x = x % y`)
- ****=** : Üs alma ve atama (`x **= y` → `x = x ** y`)

 

## Kod Örnekleri

 

### Örnek 1: Temel Kullanım ve Sayaç Mantığı

 

Aşağıdaki örnekte bir sayaç değişkeni farklı kısayol operatörleriyle güncellenmektedir. Çıktılar yorum satırlarında belirtilmiştir.

 

```
sayi = 10
print(f"Başlangıç: {sayi}")  # Başlangıç: 10

sayi += 5      # sayi = sayi + 5
print(f"Toplama (+=): {sayi}")  # Toplama (+=): 15

sayi -= 3      # sayi = sayi - 3
print(f"Çıkarma (-=): {sayi}")  # Çıkarma (-=): 12

sayi *= 2      # sayi = sayi * 2
print(f"Çarpma (*=): {sayi}")  # Çarpma (*=): 24

sayi /= 4      # sayi = sayi / 4 (float sonuç)
print(f"Bölme (/=): {sayi}")  # Bölme (/=): 6.0

sayi //= 2     # sayi = sayi // 2 (tam bölme)
print(f"Tam Bölme (//=): {sayi}")  # Tam Bölme (//=): 3.0

sayi **= 2     # sayi = sayi ** 2 (karesi)
print(f"Üs Alma (**=): {sayi}")  # Üs Alma (**=): 9.0

sayi %= 4      # sayi = sayi % 4 (modül)
print(f"Modül (%=): {sayi}")  # Modül (%=): 1.0
```

 

### Örnek 2: Döngülerde Biriktirme (Accumulator) Deseni

 

Kısayol atama işleçleri, döngüler içinde toplam, çarpım veya sayaç tutmak için en yaygın kullanıldığı alandır. Bu örnekte bir listedeki sayıların toplamı ve çarpımı hesaplanmaktadır.

 

```
degerler = [2, 3, 4, 5]

# Toplam hesaplama
toplam = 0
for deger in degerler:
    toplam += deger  # toplam = toplam + deger
print(f"Liste toplamı: {toplam}")  # Liste toplamı: 14

# Çarpım hesaplama
carpim = 1
for deger in degerler:
    carpim *= deger  # carpim = carpim * deger
print(f"Liste çarpımı: {carpim}")  # Liste çarpımı: 120

# Eleman sayısı (len() yerine sayaç)
sayac = 0
for _ in degerler:
    sayac += 1
print(f"Eleman sayısı: {sayac}")  # Eleman sayısı: 4
```

 

### Örnek 3: Farklı Veri Tipleriyle Kullanım (String ve Liste)

Bu işleçler sayısal tiplerle sınırlı değildir; `+` ve `*` operatörlerini destekleyen tiplerde (string, liste, demet) de çalışır. Ancak `-=`, `/=` gibi matematiksel operatörler bu tiplerde hata verir.

 

```
# String birleştirme
metin = "Merhaba"
metin += " Dünya"  # metin = metin + " Dünya"
print(metin)  # Merhaba Dünya

# String tekrar etme
kelime = "Py"
kelime *= 3  # kelime = kelime * 3
print(kelime)  # PyPyPy

# Liste genişletme
liste = [1, 2]
liste += [3, 4]  # liste.extend([3, 4]) ile aynı etki
print(liste)  # [1, 2, 3, 4]

# Liste tekrar etme
olcu = [0]
olcu *= 5
print(olcu)  # [0, 0, 0, 0, 0]
```

 

## Önemli Davranış: Değiştirilebilir vs Değiştirilemez Nesneler

 

Kısayol atama işleçleri, nesnenin değiştirilebilir (mutable) olup olmamasına göre farklı davranır.

 

- **Değiştirilemez nesneler (int, float, str, tuple):** `x += y` işlemi yeni bir nesne oluşturur ve `x` bu yeni nesneyi referans eder. Eski nesne çöp toplayıcı tarafından temizlenir.
- **Değiştirilebilir nesneler (list, dict, set):** `liste += [1, 2]` işlemi (veya `liste.extend([1, 2])`) listeyi **yerinde (in-place)** değiştirir. Yeni bir liste oluşturmaz; aynı nesne bellekte güncellenir. Bu, birden fazla değişkene aynı liste atanmışsa hepsini etkiler.

 

## Sık Yapılan Hatalar

 

- **Operatör sırasını ters yazmak:** `=+` yerine `+=` yazılmalıdır. `x =+ 5` yazılırsa bu «x = +5» (pozitif 5 ata) anlamına gelir, x'in üzerine 5 eklemez.
- **Tanılmamış değişken kullanmak:** `sayac += 1` yazarken `sayac` önceden tanımlanmamışsa `NameError` alırsınız. Önce `sayac = 0` ataması yapılmalıdır.
- **Uyumsuz tiplerle işlem yapmak:** String ifadeye `-=` veya `/=` uygulanamaz (`TypeError`). Sadece `+=` (birleştirme) ve `*=` (tekrar) geçerlidir.
- **Float sonucunu beklememek:** `/=` operatörü her zaman `float` döndürür. `sayi = 10; sayi /= 2` sonucunda `sayi` `5.0` olur, `5` olmaz. Tam sayı kalması isteniyorsa `//=` kullanılmalıdır.
- **Referans paylaşımını göz ardı etmek:** Listelerde `liste1 = [1]; liste2 = liste1; liste1 += [2]` yapıldığında `liste2` de değişir çünkü `+=` listeyi yerinde genişletir. Yeni liste isteniyorsa `liste1 = liste1 + [2]` yazılmalıdır.

 

## Alıştırma

 

Başlangıç değeri 100 olan bir `bakiye` değişkeni tanımlayın. Aşağıdaki işlemleri sırasıyla kısayol atama işleçleri kullanarak yapın ve her adımda bakiyeyi yazdırın:

 

1. 50 TL yatırın (`+=`).
2. 30 TL çekin (`-=`).
3. Bankanın faiz oranı %10 olarak uygulansın, bakiyeyi 1.1 ile çarpın (`*=`).
4. Yıllık karta 12 TL kesintisi yapın (`-=`).
5. Son bakiyeyi 2'ye bölerek ikiye ayırın (`/=`).

 

### Çözüm

 

```
bakiye = 100
print(f"Başlangıç bakiyesi: {bakiye}")

bakiye += 50      # Para yatırma
print(f"Yatırma sonrası: {bakiye}")

bakiye -= 30      # Para çekme
print(f"Çekim sonrası: {bakiye}")

bakiye *= 1.1     # %10 faiz uygulama
print(f"Faiz sonrası: {bakiye}")

bakiye -= 12      # Kart ücreti kesintisi
print(f"Kesinti sonrası: {bakiye}")

bakiye /= 2       # İkiye bölme
print(f"Son bakiye (yarısı): {bakiye}")
```

 

## Özet

 

- Kısayol atama işleçleri (`+=`, `-=`, `*=`, `/=`, `//=`, `%=`, `**=`) değişken güncelleme işlemlerini tek satırda ve okunabilir bir şekilde yapmamızı sağlar.
- `x += y` ifadesi `x = x + y` ile eşdeğerdir; operatörün solunda değişken, sağında değer yer alır.
- Bu operatörler sayılar haricinde string ve listeler gibi sıralı tiplerle de (uygun operatörlerle) çalışır.
- Değiştirilebilir nesnelerde (liste) `+=` işlemi nesneyi yerinde değiştirirken, değiştirilemez nesnelerde (sayı, string) yeni nesne oluşturur.
