Python for Döngüsü: Kapsamlı Bir Rehber

Programlamada, belirli bir dizi komutu veya işlemleri tekrar tekrar yürütmek sıkça karşılaşılan bir gereksinimdir. Bu tekrar eden görevleri otomatize etmek için döngüler (loops) kullanılır. Python, bu konuda oldukça güçlü ve okunabilir iki temel döngü yapısı sunar: while döngüsü ve for döngüsü. Bu makale, Python’ın for döngüsüne odaklanarak, temel yapısından ileri seviye kullanımına, performans ipuçlarından sık yapılan hatalara kadar geniş bir yelpazede kapsamlı bir rehber sunmaktadır. Python’ın “okunabilirlik” felsefesinin en güzel örneklerinden biri olan for döngüsü, veri yapıları üzerinde gezinmeyi ve tekrarlayan işlemleri gerçekleştirmeyi son derece kolaylaştırır.

Giriş: Python’da Döngülerin Önemi ve for Döngüsünün Rolü

Yazılım geliştirmenin temel taşlarından biri, tekrarlayan görevleri etkin bir şekilde otomatize etme yeteneğidir. Bir listeyi işlemek, bir dosyanın her satırını okumak, bir veri kümesindeki her öğeyi analiz etmek veya belirli bir işlemi sabit sayıda tekrarlamak gibi senaryolar, döngülerin devreye girdiği yerlerdir. Döngüler olmasaydı, bu tür görevler için her bir öğe veya tekrar için ayrı ayrı kod yazmak zorunda kalırdık ki bu, kod tekrarına yol açan, bakımı zor ve hataya açık bir yaklaşım olurdu.

Python’da for döngüsü, genellikle “yinelenebilir” (iterable) nesneler üzerinde gezinmek (iterate) için kullanılır. Bir liste, demet (tuple), dize (string), küme (set) veya sözlük (dictionary) gibi veri yapıları yinelenebilir nesnelerdir. for döngüsü, bu nesnelerin her bir öğesini sırayla ele alarak belirli bir kod bloğunu yürütmenizi sağlar. Python’ın for döngüsü, diğer dillerdeki C tarzı (for (int i = 0; i < n; i++)) döngülerden farklı olarak, doğrudan bir indeks üzerinden ziyade, yinelenebilir nesnenin öğeleri üzerinde doğrudan gezinmeye odaklanır. Bu yaklaşım, kodu daha okunaklı ve sezgisel hale getirir, aynı zamanda "indeks dışı hata" (IndexError) gibi yaygın hataların önüne geçmeye yardımcı olur. Python'ın bu özelliği, onu veri işleme ve otomasyon görevleri için özellikle güçlü bir araç haline getirir.

for Döngüsünün Temel Yapısı ve Söz Dizimi

Python'daki for döngüsünün temel söz dizimi oldukça basittir ve aşağıdaki gibidir:

for eleman in yinelenebilir_nesne:
    # Döngü içinde her eleman için çalışacak kod bloğu
    # Bu satırlar girintili olmalıdır.
    print(eleman)

Bu yapıdaki anahtar bileşenler şunlardır:

for anahtar kelimesi, döngünün başlangıcını belirtir.
eleman, her döngü iterasyonunda yinelenebilir nesnenin o anki öğesini temsil eden bir değişkendir. Bu değişkenin adı isteğe bağlıdır ve anlamlı bir isim seçilmelidir (örn. sayi, harf, kisi).
in anahtar kelimesi, eleman değişkeninin hangi yinelenebilir_nesne içinde aranacağını belirtir.
yinelenebilir_nesne, üzerinde gezilecek olan koleksiyon veya veri yapısıdır (liste, dize, demet vb.).
İki nokta üst üste (:), döngü başlığını sonlandırır.
Döngü bloğu (print(eleman) satırı), döngü başlığından sonra girintili (indent) olarak yazılan kod satırlarından oluşur. Python'da girinti, kod bloklarını tanımlamak için kritik öneme sahiptir. Genellikle 4 boşluk kullanılır.

İşte basit bir liste üzerinde gezinme örneği:

meyveler = ["elma", "muz", "kiraz"]
for meyve in meyveler:
    print(meyve)

Bu kod, meyveler listesindeki her bir öğeyi sırayla meyve değişkenine atar ve her atamada print(meyve) komutunu çalıştırır. Çıktı şu şekilde olacaktır:

elma
muz
kiraz

Yinelenebilir Nesneler (Iterables) Nelerdir?

for döngüsünün gücü, çeşitli yinelenebilir nesneler üzerinde çalışabilmesinden gelir. Bir nesne, üzerinde gezilebiliyorsa (yani öğeleri tek tek elde edilebiliyorsa) "yinelenebilir" olarak adlandırılır. Python'da yaygın olarak kullanılan yinelenebilir nesneler şunlardır:

1. Listeler (Lists)

Öğelerin sıralı ve değiştirilebilir koleksiyonlarıdır.

sayilar = [1, 2, 3, 4, 5]
for sayi in sayilar:
    print(sayi * 2)

2. Demetler (Tuples)

Öğelerin sıralı ve değiştirilemez koleksiyonlarıdır.

koordinatlar = (10, 20, 30)
for kord in koordinatlar:
    print(f"Koordinat: {kord}")

3. Dizeler (Strings)

Karakterlerin sıralı koleksiyonlarıdır. Her karakter ayrı bir öğe olarak işlenir.

kelime = "Python"
for harf in kelime:
    print(f"Harf: {harf}")

4. Kümeler (Sets)

Benzersiz ve sırasız öğelerin koleksiyonlarıdır.

renkler = {"kırmızı", "mavi", "yeşil"}
for renk in renkler:
    print(f"Renk: {renk}")

5. Sözlükler (Dictionaries)

Anahtar-değer çiftlerinin koleksiyonlarıdır. for döngüsü varsayılan olarak sözlüğün anahtarları üzerinde gezinir.

ogrenci = {"ad": "Ali", "yas": 25, "bolum": "Bilgisayar"}

Anahtarlar üzerinde gezinme (varsayılan)
for anahtar in ogrenci:
    print(f"Anahtar: {anahtar}")

Değerler üzerinde gezinme
for deger in ogrenci.values():
    print(f"Değer: {deger}")

Anahtar-değer çiftleri üzerinde gezinme
for anahtar, deger in ogrenci.items():
    print(f"{anahtar}: {deger}")

6. `range()` Fonksiyonu

Belirli bir sayı dizisi oluşturmak için kullanılır. Özellikle belirli sayıda tekrar yapmak veya indekslerle çalışmak gerektiğinde çok kullanışlıdır.

for i in range(5): # 0'dan 4'e kadar sayılar üretir
    print(i)

7. Dosya Nesneleri

Bir dosyayı açtığınızda elde ettiğiniz dosya nesnesi de yinelenebilirdir; dosyanın her satırı üzerinde gezinmenizi sağlar.

# Ornek bir dosya olusturalim
with open("ornek.txt", "w") as f:
    f.write("İlk satır\n")
    f.write("İkinci satır\n")
    f.write("Üçüncü satır\n")

Dosya uzerinde gezinme
with open("ornek.txt", "r") as dosya:
    for satir in dosya:
        print(satir.strip()) # strip() ile satır sonu boşluklarını kaldırırız

8. Özel Sınıflar (Iterator Protokolü)

Kendi özel sınıflarınızı da yinelenebilir hale getirebilirsiniz. Bu, sınıfınızda __iter__() ve __next__() metodlarını uygulayarak yapılır. Bu konu ileri düzey bir konudur, ancak Python'ın for döngüsünün ne kadar esnek olduğunu gösterir.

`range()` Fonksiyonu ile for Döngüleri

range() fonksiyonu, Python'da belirli bir sayı dizisi oluşturmak için kullanılan yerleşik bir fonksiyondur. Genellikle for döngüleriyle birlikte, belirli sayıda tekrar gerçekleştirmek veya indeks tabanlı işlemleri yapmak için kullanılır. range() aslında bir liste oluşturmaz, bunun yerine sayıları "talep üzerine" üreten bir yineleyici (iterator) döndürür. Bu, özellikle çok büyük sayı dizileriyle çalışırken bellek verimliliği sağlar.

range() fonksiyonunun üç farklı kullanım şekli vardır:

1. `range(stop)`

Tek bir argüman verildiğinde, 0'dan başlayıp stop-1'e kadar (stop dahil değil) sayılar üretir.

print("range(5):")
for i in range(5): # 0, 1, 2, 3, 4 üretir
    print(i)

2. `range(start, stop)`

İki argüman verildiğinde, start değerinden başlayıp stop-1'e kadar (stop dahil değil) sayılar üretir.

print("\nrange(2, 7):")
for i in range(2, 7): # 2, 3, 4, 5, 6 üretir
    print(i)

3. `range(start, stop, step)`

Üç argüman verildiğinde, start değerinden başlayıp stop-1'e kadar (stop dahil değil) step kadar artırarak sayılar üretir.

print("\nrange(1, 10, 2):")
for i in range(1, 10, 2): # 1, 3, 5, 7, 9 üretir
    print(i)

print("\nrange(10, 0, -1):") # Geriye doğru sayma
for i in range(10, 0, -1): # 10, 9, 8, ..., 1 üretir
    print(i)

range() fonksiyonu, belirli bir sayıda işlemi tekrar etmek veya bir listenin öğelerine indeksleri aracılığıyla erişmek istediğinizde vazgeçilmezdir. Ancak, Python'ın felsefesi gereği, doğrudan öğeler üzerinde gezinmek mümkünken indeks kullanmaktan kaçınmak genellikle daha "Pythonik" bir yaklaşımdır. Yine de, bazen indekslere ihtiyaç duyulur ve range() burada devreye girer.

`break` ve `continue` Deyimleri

Bazen bir döngü devam ederken özel koşullarla karşılaşabiliriz. Bu durumlarda, döngünün akışını değiştirmek için break ve continue deyimleri kullanılır.

`break` Deyimi

break deyimi, içinde bulunduğu döngüyü tamamen sonlandırır. break ile karşılaşıldığında, döngüden hemen çıkılır ve döngüden sonraki ilk kod satırına geçilir.

urunler = ["kalem", "defter", "silgi", "kitap", "cetvel"]
aranan_urun = "silgi"

print("Aranan ürün bulunana kadar listeleniyor:")
for urun in urunler:
    if urun == aranan_urun:
        print(f"'{aranan_urun}' bulundu! Aramayı durduruyoruz.")
        break # Ürün bulunduğunda döngüden çık
    print(f"Ürün: {urun}")

print("Döngü sona erdi.")

Bu örnekte, "silgi" bulunduğunda döngü durur ve "kitap" ile "cetvel" yazdırılmaz.

`continue` Deyimi

continue deyimi, mevcut döngü iterasyonunu atlar ve döngünün bir sonraki iterasyonuna geçer. continue ile karşılaşıldığında, döngü bloğundaki o andan sonraki kod satırları atlanır, ancak döngü tamamen sonlandırılmaz.

sayilar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print("Çift sayılar atlanıyor:")
for sayi in sayilar:
    if sayi % 2 == 0: # Eğer sayı çift ise
        continue # Bu iterasyonu atla, bir sonraki sayıya geç
    print(f"Tek Sayı: {sayi}")

print("Döngü sona erdi.")

Bu örnekte, çift sayılar için print komutu atlanır ve sadece tek sayılar ekrana yazdırılır.

`else` Bloğu ile for Döngüleri

Python'daki for döngüleri, isteğe bağlı bir else bloğuna sahip olabilir. Bu else bloğu, döngü normal bir şekilde (yani break deyimi ile sonlandırılmadan) tamamlandığında yürütülür. Bu özellik, bir öğeyi arama gibi senaryolarda oldukça kullanışlıdır.

urunler = ["kalem", "defter", "silgi", "kitap"]
aranan_urun_1 = "silgi"
aranan_urun_2 = "masa"

Örnek 1: Ürün bulunur ve döngü break ile sonlandırılır
print("--- Arama 1 ---")
for urun in urunler:
    if urun == aranan_urun_1:
        print(f"'{aranan_urun_1}' bulundu.")
        break
else: # Bu blok çalışmaz, çünkü döngü break ile sonlandı
    print(f"'{aranan_urun_1}' listede bulunamadı.")

Örnek 2: Ürün bulunamaz ve döngü normal şekilde tamamlanır
print("\n--- Arama 2 ---")
for urun in urunler:
    if urun == aranan_urun_2:
        print(f"'{aranan_urun_2}' bulundu.")
        break
else: # Bu blok çalışır, çünkü döngü normal şekilde tamamlandı
    print(f"'{aranan_urun_2}' listede bulunamadı.")

İlk aramada "silgi" bulunduğu için break çalışır ve else bloğu atlanır. İkinci aramada "masa" bulunamadığı için döngü tüm öğeleri kontrol eder ve normal şekilde tamamlandığında else bloğu çalışır.

İç İçe for Döngüleri (Nested for Loops)

Bazen, bir döngünün her iterasyonunda başka bir döngüyü çalıştırmak gerekebilir. Bu duruma iç içe (nested) döngüler denir. İç içe döngüler genellikle çok boyutlu veri yapıları (matrisler gibi) üzerinde işlem yaparken veya her öğe kombinasyonunu kontrol etmek gerektiğinde kullanılır.

# Çarpım tablosu örneği
for i in range(1, 6): # Dış döngü (1'den 5'e kadar)
    for j in range(1, 6): # İç döngü (1'den 5'e kadar)
        print(f"{i} x {j} = {i * j}")
    print("-" * 15) # Her dış döngü iterasyonundan sonra ayırıcı

Bu örnekte, dış döngü i değeri için 1'den 5'e kadar dönerken, her i değeri için iç döngü j değeri için 1'den 5'e kadar döner. Böylece i * j çarpımları hesaplanır.

İç içe döngülerin karmaşıklığı, döngü derinliği arttıkça üssel olarak artabilir. Örneğin, iki iç içe döngü, eleman sayısı N ise O(N^2) karmaşıklığa sahip olabilir. Bu nedenle, büyük veri kümeleriyle çalışırken iç içe döngülerin performans etkilerini göz önünde bulundurmak önemlidir.

for Döngüsünün Gelişmiş Kullanımları ve Yardımcı Fonksiyonlar

Python, for döngüsünün yeteneklerini artıran ve yaygın görevleri daha zarif ve verimli hale getiren bir dizi yerleşik fonksiyon ve yapı sunar.

1. `enumerate()` Fonksiyonu

Bir yinelenebilir nesne üzerinde gezinirken hem öğeye hem de öğenin indeksine aynı anda ihtiyaç duyduğunuzda enumerate() fonksiyonu çok kullanışlıdır. Bu fonksiyon, her iterasyonda bir demet (tuple) döndürür: (index, value).

meyveler = ["elma", "muz", "kiraz"]

for indeks, meyve in enumerate(meyveler):
    print(f"{indeks}. meyve: {meyve}")

İndeksi farklı bir sayıdan başlatma
for indeks, meyve in enumerate(meyveler, start=1):
    print(f"{indeks}. meyve: {meyve}")

2. `zip()` Fonksiyonu

Birden fazla yinelenebilir nesne üzerinde paralel olarak gezinmek istediğinizde zip() fonksiyonu kullanılır. zip(), her yinelenebilir nesneden bir öğeyi alarak bunları bir demet halinde birleştirir ve bu demetler üzerinde gezinmenizi sağlar. Döngü, en kısa yinelenebilir nesne bittiğinde sona erer.

isimler = ["Ali", "Ayşe", "Mehmet"]
yaslar = [30, 24, 35]
sehirler = ["Ankara", "İzmir", "İstanbul"]

for isim, yas, sehir in zip(isimler, yaslar, sehirler):
    print(f"{isim}, {yas} yaşında ve {sehir}'de yaşıyor.")

3. Liste Anlayışları (List Comprehensions)

Liste anlayışları, mevcut bir yinelenebilir nesneden yeni bir liste oluşturmanın kısa, okunabilir ve genellikle daha verimli bir yoludur. Temel bir for döngüsüne kıyasla tek bir satırda daha karmaşık işlemler yapabilirler.

# Geleneksel for döngüsü ile kareler listesi oluşturma
sayilar = [1, 2, 3, 4, 5]
kareler_for = []
for sayi in sayilar:
    kareler_for.append(sayi  2)
print(f"For döngüsü ile kareler: {kareler_for}")

Liste anlayışı ile kareler listesi oluşturma
kareler_lc = [sayi  2 for sayi in sayilar]
print(f"Liste anlayışı ile kareler: {kareler_lc}")

Koşullu liste anlayışı (sadece çift sayıların karesi)
cift_kareler_lc = [sayi  2 for sayi in sayilar if sayi % 2 == 0]
print(f"Koşullu liste anlayışı ile çift kareler: {cift_kareler_lc}")

Liste anlayışları, Python'da listeler üzerinde dönüşüm veya filtreleme işlemleri yapmanın en popüler ve Pythonik yollarından biridir.

4. Sözlük Anlayışları (Dictionary Comprehensions)

Liste anlayışlarına benzer şekilde, sözlük anlayışları da mevcut yinelenebilir nesnelerden yeni sözlükler oluşturmanın kısa bir yolunu sunar.

urunler = ["elma", "armut", "muz"]
fiyatlar = [10, 12, 8]

Ürünleri fiyatlarıyla eşleştiren sözlük
urun_fiyatlari = {urun: fiyat for urun, fiyat in zip(urunler, fiyatlar)}
print(f"Ürün fiyatları: {urun_fiyatlari}")

Bir stringdeki harflerin uzunluğunu gösteren sözlük
kelime = "Merhaba"
harf_uzunluklari = {harf: len(kelime) for harf in kelime} # Tekrarlı harflerde sonuncusu kalır
print(f"Harf uzunlukları (basit): {harf_uzunluklari}")

Harflerin tekrar sayısını sayan daha gelişmiş bir örnek
from collections import Counter
harf_sayilari = {harf: count for harf, count in Counter(kelime).items()}
print(f"Harf sayıları: {harf_sayilari}")

5. Üreteç İfadeleri (Generator Expressions)

Söz dizimi olarak liste anlayışlarına çok benzeyen üreteç ifadeleri, liste yerine bir üreteç (generator) döndürür. Üreteçler, öğeleri "talep üzerine" (on-demand) üretir, yani tüm öğeleri belleğe yüklemezler. Bu, özellikle büyük veri kümeleriyle çalışırken bellek verimliliği açısından çok önemlidir.

sayilar = [1, 2, 3, 4, 5]

Liste anlayışı (tüm kareleri belleğe yükler)
kareler_listesi = [sayi  2 for sayi in sayilar]
print(f"Kareler listesi (tip: {type(kareler_listesi)}): {kareler_listesi}")

Üreteç ifadesi (talep üzerine kareleri üretir)
kareler_uretici = (sayi  2 for sayi in sayilar)
print(f"Kareler üreteci (tip: {type(kareler_uretici)}): {kareler_uretici}")

Üreteçten öğeleri tek tek alma
print("Üreteçten öğeler:")
for kare in kareler_uretici:
    print(kare)

Üreteç ifadeleri, özellikle sum(), max(), min() gibi fonksiyonlarla birlikte kullanıldığında veya büyük veri akışlarını işlerken performansı artırabilir.

Performans ve Optimizasyon İpuçları

Python'ın for döngüsü genellikle oldukça hızlıdır, ancak büyük veri kümeleriyle veya yoğun hesaplamalarla çalışırken performansı artırmak için bazı noktaları göz önünde bulundurmak faydalı olabilir:

Yerleşik Fonksiyonları Kullanın: Mümkün olduğunca sum(), min(), max(), map(), filter() gibi Python'ın optimize edilmiş yerleşik fonksiyonlarını kullanmaya çalışın. Bu fonksiyonlar genellikle eşdeğer for döngülerinden daha hızlıdır, çünkü C dilinde uygulanmışlardır.
Liste Anlayışları ve Üreteç İfadeleri: Yeni listeler veya yinelenebilirler oluşturmak için liste anlayışları ve üreteç ifadeleri, genellikle geleneksel for döngülerinden daha performanslıdır. Liste anlayışları, döngü ve append() çağrılarının birleşmesinden daha hızlı olabilirken, üreteç ifadeleri bellek verimliliği sağlar.
Gereksiz Hesaplamalardan Kaçının: Döngü içinde tekrar tekrar aynı hesaplamayı yapmaktan kaçının. Eğer bir değer döngüden önce hesaplanabiliyorsa, onu döngüden önce hesaplayın.
Modül İçe Aktarımlarını Döngü Dışında Tutun: Eğer bir modül veya fonksiyonu döngü içinde tekrar tekrar içe aktarıyorsanız, bunu döngü dışına taşıyın.
itertools Modülü: Python'ın itertools modülü, döngülerle ilgili karmaşık ve verimli işlemler için birçok özel yineleyici sunar (örn. itertools.chain(), itertools.cycle(), itertools.combinations()). Bu modül, özellikle büyük veri kümeleri üzerinde gelişmiş yineleme desenleri uygulamanız gerektiğinde çok güçlüdür.
Döngü İçinde Fonksiyon Çağrısı Sayısını Azaltın: Eğer bir fonksiyonu döngünün her iterasyonunda çağırıyorsanız ve bu fonksiyon pahalı bir işlem yapıyorsa, mümkünse fonksiyon çağrısı sayısını azaltmaya çalışın.

Sık Yapılan Hatalar ve Çözümleri

for döngülerini kullanırken sıkça karşılaşılan bazı hatalar ve bunlardan kaçınma yolları:

1. Girinti Hataları (`IndentationError`)

Python'da kod blokları (döngüler, koşullu ifadeler, fonksiyonlar vb.) girintilerle tanımlanır. Yanlış veya tutarsız girinti, IndentationError hatasına yol açar.

# Hatalı
for i in range(3):
print(i) # IndentationError: expected an indented block

Doğru
for i in range(3):
    print(i)

2. Döngü İçinde Yinelenebilir Nesneyi Değiştirme

Bir liste veya başka bir koleksiyon üzerinde gezinirken aynı koleksiyonu döngü içinde değiştirmek (öğe eklemek, çıkarmak) beklenmedik sonuçlara veya hatalara yol açabilir. Genellikle, değiştirilmiş bir kopya üzerinde çalışmak veya yeni bir liste oluşturmak daha güvenlidir.

sayilar = [1, 2, 3, 4]
Hatalı yaklaşım:
for sayi in sayilar:
if sayi % 2 == 0:
sayilar.remove(sayi) # Bu, döngüyü bozabilir ve bazı öğeleri atlayabilir

Doğru yaklaşım: Yeni bir liste oluşturmak
yeni_sayilar = [sayi for sayi in sayilar if sayi % 2 != 0]
print(yeni_sayilar) # [1, 3]

Veya bir kopyası üzerinde gezinmek
for sayi in list(sayilar): # list() ile bir kopya oluşturulur
if sayi % 2 == 0:
sayilar.remove(sayi)
print(sayilar)

3. Döngü Değişkeninin Kapsamı (Loop Variable Leakage)

Python'da, for döngüsünde kullanılan döngü değişkeni (örn. for item in my_list: içindeki item), döngü sona erdikten sonra bile erişilebilir kalır ve döngünün son iterasyonundaki değerini korur. Bu bazen beklenmedik davranışlara yol açabilir, özellikle fonksiyonlar içinde closure'lar ile çalışırken.

for i in range(3):
    pass # Sadece döngüyü çalıştır

print(f"Döngü bittikten sonra i'nin değeri: {i}") # Çıktı: 2

Bu bir hata olmasa da, bu davranışın farkında olmak önemlidir.

4. Yanlış `range()` Kullanımı

range() fonksiyonunun start, stop ve step argümanlarını karıştırmak veya yanlış anlamak, istenmeyen sayı dizileri üretilmesine neden olabilir.

# Hatalı: 1'den 5'e kadar (5 dahil) sayılar istiyoruz ama range(1, 5) sadece 1,2,3,4 verir
for i in range(1, 5):
print(i) # 1, 2, 3, 4

Doğru: 5'i dahil etmek için stop değerini 6 yapmalıyız
for i in range(1, 6):
    print(i) # 1, 2, 3, 4, 5

Sonuç

Python'ın for döngüsü, dilin en temel ve güçlü özelliklerinden biridir. Yinelenebilir nesneler üzerinde kolayca gezinme yeteneği, range(), enumerate(), zip() gibi yardımcı fonksiyonlarla zenginleştirilmiş kullanımı ve liste/sözlük anlayışları gibi modern Pythonik yapılarla birleştiğinde, veri işleme ve otomasyon görevleri için inanılmaz derecede esnek ve verimli bir araç haline gelir.

Bu makalede, for döngüsünün temel söz diziminden başlayarak, farklı yinelenebilir nesneler üzerindeki kullanımına, break, continue ve else gibi kontrol akışı deyimlerine, iç içe döngülere ve enumerate(), zip(), liste anlayışları gibi gelişmiş özelliklere kadar geniş bir yelpazeyi ele aldık. Ayrıca, performans ipuçları ve sık yapılan hatalar üzerinde durarak, daha sağlam ve verimli Python kodları yazmanıza yardımcı olmayı amaçladık.

Python programlamada yetkinleşmek için for döngüsünü ve onunla ilişkili kavramları derinlemesine anlamak kritik öneme sahiptir. Bu rehberin, Python yolculuğunuzda size sağlam bir temel sunmasını umuyoruz.

Python for Döngüsü: Kapsamlı Bir Rehber