# Python'da döngüler ve koşullar: for, while, range, enumerate, break, if/elif ve match/case

URL: https://skillaria.top/tr/guides/python/python-donguler-ve-kosullar

Python'da döngüler işlemleri tekrarlar: for, bir koleksiyonun ya da range() aralığının elemanlarını sırayla dolaşır, while ise koşul doğru olduğu sürece çalışır. break ile döngüden çıkılır, continue ile bir tur atlanır, enumerate() sıra numarası verir. Kararları if/elif/else koşulları, veri biçimine göre ayrıştırmayı ise match/case (Python 3.10'dan itibaren) verir.

Python'da döngüler bir işlemi tekrarlamak için kullanılır: alışveriş listesini dolaşmak, dosyanın her satırını işlemek ya da kullanıcı geçerli bir sayı girene kadar sormak. Dilde iki döngü vardır, `for` ve `while`; döngülerin içinde karar vermek için ise `if/elif/else` koşulları ve `match/case` yapısı kullanılır. Her aracı çalışan örneklerle inceleyelim.

## Koşullar: if, elif, else

Koşul yapısı, ifade doğru olduğunda bir blok çalıştırır. Blok 4 boşluklu girintiyle belirtilir; Python'da süslü parantez yoktur ve yanlış girinti hemen `IndentationError` hatası verir.

```
spent = 4200
limit = 5000

if spent > limit:
    print("Limit aşıldı")
elif spent > limit * 0.8:
    print("Bütçenin %20'sinden azı kaldı")
else:
    print("Her şey yolunda")
```

`elif` dalları yukarıdan aşağıya kontrol edilir ve yalnızca ilk uyan dal çalışır. Bu yüzden daha sıkı koşulları yukarı koyun: `spent > limit * 0.8` kontrolü birinci sırada olsaydı, limit aşımı mesajı hiç görünmezdi.

### Neyin doğru sayıldığı

Koşulda karşılaştırma yazmak zorunda değilsiniz. `False`, `None`, sıfır (`0`, `0.0`) ve boş koleksiyonlar (`""`, `[]`, `{}`) yanlış sayılır; geri kalan her şey doğrudur. Bu yüzden "liste boş değil" kontrolü kısa yazılır:

```
expenses = []
if not expenses:
    print("Henüz harcama yok")
```

Koşulları `and`, `or` ve `not` ile birleştirirsiniz; bir aralığı zincirleme karşılaştırmayla kontrol etmek de kolaydır: `if 0 < amount <= 100_000:`. Kısa bir seçim için üçlü operatör vardır: `status = "yüksek" if spent > limit else "normal"`.

## for döngüsü: sözdizimi ve örnekler

Python'daki `for`, C dilindeki gibi bir sayaç değildir; elemanları tek tek dolaşır. Yinelenebilir bir nesnenin, yani bir listenin, bir metnin, bir sözlüğün, bir dosyanın ya da bir aralığın elemanlarını sırayla alır. Diğer dillerdeki foreach işlevi, Python'da zaten normal `for` ile görülür.

```
expenses = [350, 1200, 89, 4500]
total = 0
for amount in expenses:
    total += amount
print(total)  # 6139
```

Sözdizimi: `for değişken in koleksiyon:`, ardından girintili blok. Döngüden sonra değişken son değerini korur; bu bazen işe yarar, ama büyük programlarda buna güvenmemek daha iyidir.

### Metin, liste ve sözlükte dolaşmak

Bir metin karakter karakter, bir liste eleman eleman dolaşılır. Sözlük üzerinde döngü varsayılan olarak anahtarları verir; anahtarla değeri birlikte almak için `.items()` kullanın:

```
by_category = {"yiyecek": 3200, "ulaşım": 900, "sinema": 600}

for category, amount in by_category.items():
    print(f"{category}: {amount} TL")
```

Yalnızca değerler için `.values()` vardır. Döngü sırasında sözlüğün boyutunu değiştirmek yasaktır; `RuntimeError: dictionary changed size during iteration` hatası alırsınız. Eleman silmeniz gerekiyorsa kopya üzerinde dolaşın: `for key in list(d):`.

## range fonksiyonu: sayılar üzerinde döngü

Sayılar üzerinde dolaşmak için `range()` kullanılır. Bellekte liste oluşturmaz, sayıları birer birer üretir; bu yüzden `range(10**9)` anında çalışır.

| Çağrı | Sayılar |
| --- | --- |

| `range(5)` | 0, 1, 2, 3, 4 |

| `range(2, 6)` | 2, 3, 4, 5 |

| `range(0, 10, 3)` | 0, 3, 6, 9 |

| `range(5, 0, -1)` | 5, 4, 3, 2, 1 |

Temel kural: sağ sınır aralığa dahil değildir. `range(1, 10)` 9'da biter; bu, "bir eksik" hatasının en yaygın nedenidir. Adım negatif olabilir, ama sıfır olamaz.

```
for i in range(1, 4):
    print(f"{i}. gün")
# 1. gün
# 2. gün
# 3. gün
```

## enumerate: döngüde sayaç

Yeni başlayanlar sıra numarasını bilmek için sık sık `for i in range(len(items))` yazar. Bu da çalışır, ama okunması zordur. `enumerate()` fonksiyonu "numara, eleman" çiftleri verir; `start` parametresi sayımın hangi sayıdan başlayacağını belirler:

```
items = ["kahve", "taksi", "öğle yemeği"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 kahve
# 2 taksi
# 3 öğle yemeği
```

İki listeyi birlikte dolaşmak için `zip()` vardır: `for name, price in zip(names, prices):`. En kısa listede durur; Python 3.10'dan itibaren `strict=True` verilirse uzunluklar farklı olduğunda hata verir.

## while döngüsü

`while` döngüsü, koşul doğru olduğu sürece bloğu tekrarlar. Tekrar sayısı önceden bilinmediğinde kullanılır: doğru girdi beklerken, veri sonuna kadar okunurken ya da bir istek başarılı olana kadar denenirken.

```
balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"Para {month} ay yeter")  # 4
```

En büyük tehlike, koşuldaki değişkeni değiştirmeyi unutmaktır; döngü hiç bitmez. Program donarsa Ctrl+C'ye basın: Python çalışmayı `KeyboardInterrupt` ile durdurur.

### Sonsuz döngü ve do while

Sonsuz döngü bilerek yazılabilir: `break` ile çıkışı olan `while True:`. Python'da `do while` yapısı yoktur; sondan kontrollü döngünün yerini bu kalıp alır: gövde en az bir kez çalışır, kontrol ise sonda yapılır.

```
while True:
    raw = input("Tutar: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("Lütfen tam sayı girin")
```

Sonsuz `for` döngüsü nadirdir; yalnızca `itertools.count()` gibi sonsuz bir yineleyici dolaşılırsa oluşur.

## break ve continue: döngüden çıkmak ve tur atlamak

`break` döngüyü hemen keser ve program döngüden sonraki koda geçer. `continue` ise o turun kalanını atlayıp bir sonraki tura geçer.

```
expenses = [350, -10, 1200, 0, 99_999, 89]

for amount in expenses:
    if amount  50_000:
        print("Şüpheli tutar, duruyoruz")
        break             # döngüden çık
    print(amount)
```

Bu kod 350 ve 1200'ü yazdırır, ardından uyarıyı verir; 89'a döngü gelmez. İki komut da yalnızca içinde bulundukları en yakın döngüyü etkiler.

### Döngünün else bloğu

`for` ve `while` için alışılmadık bir `else` dalı vardır: döngü `break` olmadan kendi kendine bittiğinde çalışır. Arama işlemlerinde işe yarar:

```
for amount in expenses:
    if amount > 50_000:
        print("Büyük bir harcama bulundu")
        break
else:
    print("Büyük harcama yok")
```

## İç içe döngüler

Bir döngünün içindeki döngü, dıştaki her turda tamamen çalışır. Tablolar, matrisler ve ikili kombinasyonlar bu şekilde dolaşılır.

```
for row in range(1, 4):
    for col in range(1, 4):
        print(row * col, end="\t")
    print()
```

İki noktaya dikkat edin. Birincisi, karmaşıklık hızla artar: 10 000 elemanlık iki iç içe döngü 100 milyon işlem demektir. İkincisi, `break` yalnızca iç döngüden çıkar. İki döngüyü birden durdurmak için döngüleri bir fonksiyona koyup `return` kullanın; bu, bayraklar kullanmaktan daha temizdir.

## match/case yapısı

Python 3.10 ile `if cmd == ... elif ...` zincirinin yerine `match` ifadesi gelebilir (PEP 634). Bu yalnızca bir switch değildir: değeri bir kalıpla (pattern) eşleştirir, veri biçimine bakar ve parçaları doğrudan değişkenlere ayırır.

```
def parse(text):
    match text.split():
        case ["ekle", item, amount]:
            return f"{item} eklendi: {amount}"
        case ["liste"] | ["ls"]:
            return "Harcamalar gösteriliyor"
        case ["çıkış"]:
            return "Çıkılıyor"
        case _:
            return "Bilinmeyen komut"

print(parse("ekle Kahve 250"))  # Kahve eklendi: 250
print(parse("ekle Kahve"))      # Bilinmeyen komut
```

Liste kalıbı `["ekle", item, amount]` yalnızca ilk elemanı `"ekle"` olan ve tam üç elemanlı listelerle eşleşir. Bu yüzden tutarsız bir komut, her şeyi yakalayan `_` dalına düşer. `|` işareti seçenekleri birleştirir.

### Sözlük kalıpları, tür kontrolü ve koruma koşulu

Sözlük kalıbı yalnızca yazılan anahtarları kontrol eder, fazla anahtarları yok sayar. `int(a)` yazımı hem türü denetler hem değeri yakalar; kalıptan sonra gelen `if` ise ek bir koşul (guard) ekler:

```
match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("Büyük harcama", a)
    case {"type": "expense", "amount": int(a)}:
        print("Harcama", a)
```

### match'in asıl tuzağı

`case` içindeki çıplak bir isim karşılaştırma değil, yakalamadır. `case limit:` her değerle eşleşir ve değeri `limit` adına yazar. Sabitlerle karşılaştırmak için nokta içeren bir isim kullanın, örneğin `case Color.RED:`, ya da doğrudan bir değişmez değer yazın.

Python 3.10'dan beri match sözdizimi neredeyse değişmedi. Python 3.15'te küçük bir asimetri giderildi: değişmez değer kalıplarında önceden yalnızca sayının önündeki eksi işareti kabul ediliyordu; artık `case +1:` de yazılabilir. Daha eski sürümlerde bu kod sözdizimi hatası verir.

## Döngülerde tipik hatalar

- **Döngü sırasında listeyi değiştirmek.** `for` içinde eleman silmek komşu elemanları atlatır. Yeni bir liste kurun: `clean = [x for x in items if x > 0]`.
- **range sınırı.** `range(1, n)`, `n` değerini içermez.
- **while içindeki koşulu güncellememek** — sonsuz döngü.
- **Döngüde `+=` ile metin birleştirmek**: büyük veride `"".join(parts)` çok daha hızlıdır.
- **Karşılaştırma yerine atama**: `if x = 5` sözdizimi hatasıdır; karşılaştırma için `==` kullanılır.

## Pratik için döngü görevleri

1. Harcama listesindeki negatif değerleri atlayarak toplamı ve ortalamayı hesaplayın.
2. İç içe döngülerle 1–9 çarpım tablosunu yazdırın.
3. Kullanıcı boş satır girene kadar sayı isteyin, sonra en büyüğünü yazdırın.
4. Listedeki 1000'den büyük ilk sayıyı bulun; yoksa bunu bildirin (`for ... else` ile).
5. `ekle`, `sil`, `liste` komutlarını `match` ile ayrıştırın.

## Özet

Python döngüleri iki yapıya dayanır: `for` bir koleksiyonun ya da `range()` aralığının elemanlarını dolaşır, `while` koşul sürdükçe çalışır. `break` ve `continue` döngünün akışını yönetir, `enumerate()` ve `zip()` elle sayaç tutma ihtiyacını ortadan kaldırır, `if/elif/else` ve `match/case` ise kararları verir. Bu araçların tümü harcama takipçisi örneğiyle kursun Python dersinde uygulamalı olarak işlenir.

## FAQ

**Python'da for ile while arasındaki fark nedir?**

for hazır bir diziyi dolaşır ve ne zaman duracağını bilir; while ise koşul doğru olduğu sürece tekrarlanır. Tekrar sayısı biliniyorsa ya da bir koleksiyon varsa for, bir olayı bekliyorsanız while kullanın.

**Bir döngüyü ters sırada nasıl dolaşırım?**

Koleksiyon için reversed(items), sayılar için range(n - 1, -1, -1) kullanın. reversed listeyi kopyalamaz, sondan başlayarak dolaşır.

**Python'da switch var mı?**

Ayrı bir switch yoktur; bunun yerini if/elif zinciri ve Python 3.10'da gelen match/case alır. match daha fazlasını yapar: listeleri ve sözlükleri biçimlerine göre ayırır ve değerleri yakalar.

**Döngü mü yoksa liste üretimi (comprehension) mi daha hızlıdır?**

[x * 2 for x in items] gibi liste üretimleri, eşdeğer append kullanan döngüden genellikle biraz hızlı ve daha kısadır. Birden fazla koşullu karmaşık mantıkta ise sıradan döngü daha okunaklıdır.

**İki iç içe döngüden aynı anda nasıl çıkarım?**

break yalnızca iç döngüyü keser. En kolay yol, döngüleri bir fonksiyona taşıyıp return ile çıkmaktır.


---
Source: Skillaria.Top (https://skillaria.top)