Python List Comprehension
Ders 22'de kümeleri işledik; listeleri tekilleştirmeyi ve hızlı üyelik testini öğrendin. O derste sık yaptığımız bir hareket vardı: bir listeyi al, dönüştür, yeni liste kur. İşte bugünün konusu, o kurulum işini Python'un en zarif sözdizimlerinden biriyle yapmak: list comprehension.
Bu konuyu anlattığım her stajyere aynı şeyi söylerim: ilk başta garip görünecek, iki hafta sonra onsuz kod yazamayacaksın. Gerçekten de öyle olur. List comprehension hem daha kısa hem çoğu zaman daha hızlı hem de — doğru kullanıldığında — daha okunaklıdır. "Doğru kullanıldığında" kısmını özellikle vurguluyorum; bu silahın bir emniyeti var ve birazdan ona da bakacağız.
Uzun Yol: for Döngüsüyle Liste Kurmak
Önce herkesin öğrendiği yolu yazalım. Bir sayı listesi al, her elemanın karesini hesapla, yeni listeye koy.
sayilar = [1, 2, 3, 4, 5]
kareler = [] # 1. Boş liste kur
for s in sayilar: # 2. Döngüyle gez
kareler.append(s ** 2) # 3. Hesapla ve ekle
print(kareler) # [1, 4, 9, 16, 25]
Üç adım: boş liste, döngü, append. Hata yok, herkes anlar. Ama beş satır boyunca anlattığın tek şey "her elemanın karesini al" — gerisi seramoni. Üstelik bu desen her seferinde aynı kurulumu tekrar eder: liste adı, döngü değişkeni, girinti. Proje büyüdükçe bu tekrar kodda gürültüye dönüşür; asıl niyet, yani dönüşümün kendisi, gürültünün arasında kaybolur. Bu deseni yüzlerce kez yazdıktan sonra insan soruyor: bunun kısası yok mu? Var.
Tek Satıra İnmek: Temel Sözdizimi
sayilar = [1, 2, 3, 4, 5]
kareler = [s ** 2 for s in sayilar] # ifade + for + eleman + in + iterable
print(kareler) # [1, 4, 9, 16, 25]
Sözdizimi şöyle okunur: [ifade for eleman in iterable]. Yani "sayilar'daki her s için s 2'yi al ve listeye koy." Okunuş yönüne dikkat et: matematiksel ifade başta**, döngü kısmı sonra gelir. İlk başta ters hissettiren de budur; insan beyni "for s in sayilar: kare al" diye düşünür, Python "kare al, for s in sayilar" diye yazar. Birkaç alıştırmadan sonra bu sıra doğallaşır.
Arkada olan şey basit: Python senin için geçici bir liste oluşturur, döngüyü döndürür, her adımda baştaki ifadeyi değerlendirip sonuca ekler ve listenin tamamını sana teslim eder. Yani append hâlâ çalışıyor; sadece görünürde değil. Üstelik bütün bu mekanizma C tarafında, daha sıkı bir döngüde işlediği için çoğu durumda elle yazılan döngüden de hafifçe hızlıdır.
Koşul Eklemek: if Filtresi
Listeden bazı elemanları alıp bazılarını elekten geçirmek istersen, sonda bir if filtresi kullanırsın.
sayilar = [1, 2, 3, 4, 5, 6, 7, 8]
ciftler = [s for s in sayilar if s % 2 == 0] # sondaki "if" = FİLTRE
print(ciftler) # [2, 4, 6, 8]
Sondaki if bir filtredir: koşulu sağlamayan eleman listeye hiç girmez. Bu yapıyı, az sonra göreceğimiz if-else'li ifadeyle karıştırma; filtrede else yoktur, çünkü "geçir ya da geçirme" dışında bir seçenek yoktur. Uzun yol karşılığı şu olurdu: boş liste, for, içinde if, altında append. Dört satırlık niyet, tek satıra iner.
if-else'li İfade Versiyonu
Bir de başka bir ihtiyaç var: elemanı atmak değil, değerine göre dönüştürmek. O zaman koşullu ifade başa taşınır.
sayilar = [1, 2, 3, 4, 5]
etiketler = ["çift" if s % 2 == 0 else "tek" for s in sayilar]
print(etiketler) # ["tek", "çift", "tek", "çift", "tek"]
Burada if-else baştaki ifadenin içinde: her eleman listeye giriyor, ama hangi değerin gireceği koşula bağlı. Sondaki filtre ile baştaki if-else arasındaki farkı bir cümleyle özetleyeyim: filtre eleman sayısını azaltır, if-else elemanların değerini değiştirir. İkisi aynı satırda bir araya da gelebilir; ama oraya girmeden önce sıradaki bölümü oku.
Okunabilirlik Sınırı: İç İçe Comprehension Yazma
Şimdi itiraf zamanı. Yıllar önce "bakın ne kadar kısa yazdım" diye şöyle bir satır kodlamıştım:
# İKİ KATMANLI comprehension — yazması kolay, okuması zor
matris = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
duzlestir = [sayi for satir in matris for sayi in satir if sayi % 2 == 0]
print(duzlestir) # [2, 4, 6, 8]
Tek satırda iki döngü ve bir filtre. Yazdığım gün kendimle gurur duyuyordum; kod incelemesinde de "kısacık, süper" diye geçti. Altı ay sonra o satırda bir bug çıktı ve ben kendi kodumu çözmek için yirmi dakika harcadım. İç içe comprehension'da for sıraları soldan sağa, dıştan içe ilerler; bunu bilmek bile cümleyi kafanda yeniden kurmayı gerektirir. En sonunda satırı silip düz for döngüsüyle yeniden yazdım; bug beş dakikada çözüldü.
O gün koyduğum kural hâlâ geçerli: comprehension tek bir niyeti anlatıyorsa kullan, birden fazla niyet varsa döngü yaz. Kod kısa olduğu için değil, yarın okunabildiği için iyidir. Ve tahmin et bakalım yarın okuyacak kişi çoğu zaman kim oluyor? Sen.
Karar anında şu kısa listeyi yanında bulundur:
- Kullan: tek döngü, tek dönüşüm; isteğe bağlı basit filtre. Nişan net.
- Dikkatli kullan: if-else'li dönüşüm; satır uzamaya başladıysa parantez içinde satırlara bölmeyi düşün.
- Kullanma: iç içe iki döngü, yan etkili fonksiyon çağrıları, değişken adları anlamını yitirdiyse. O noktada for döngüsü kibar bir dosttur, korkaklık değildir.
Gerçek Örnek: Veri Listesini Temizlemek
Gerçek dünyada comprehension en çok veri temizliğinde iş yapar. Ham veri pistir: baş-son boşlukları, boş stringler, karışık büyük-küçük harfler… Hepsini tek seferde toparlayalım.
# API'den geldiğini varsaydığımız ham veri: boşluklar, boş stringler, karışık harf
ham = [" İstanbul ", "ankara", "", " izmir", "İSTANBUL", "bursa "]
temiz = [
sehir.strip().lower() # baş-son boşluğu al, küçük harfe çevir
for sehir in ham # her ham kayıt için
if sehir.strip() # yalnızca boş olmayanları geçir
]
# Tekrarları da silmek istersen: list(dict.fromkeys(temiz)) — Ders 22'nin numarası
print(temiz) # ["istanbul", "ankara", "izmir", "istanbul", "bursa"]
Dikkat edersen Ders 22'deki temizlik fikri burada comprehension ile birleşti. Ham verinin boşlukları alındı, harfler küçültüldü, boş kayıtlar elendi. Son satırdaki yorum da zincirin devamını gösteriyor: temizle ve tekilleştir işlemleri art arda bağlanır; önce temizlik, sonra küme.
Bu noktada ikinci bir itiraf: if sehir.strip() gibi bir "doğruluk" filtresini yıllar önce bir sensör verisi projesinde yanlış kullanmıştım. Amaç boş okumaları temizlemekti; filtre olarak if okuma yazdım. Mantık hatası şuydu: 0.0 da Python'da "yanlış" sayılır, böylece gerçek ölçümler sessizce çöpe gitti. Hata günler sonra grafikte delikler olarak çıktı. Ders: filtre koşulunu veri tipine uygun yaz; if okuma is not None ile if okuma arasında dünyalar var.
map/filter ile Kısa Bir Karşılaştırma
Aynı işleri map ve filter ile de yapabilirsin. Kıyaslamayı yan yana koyayım:
sayilar = [1, 2, 3, 4, 5]
# map + filter zinciri: lambda yığınları gerekir, içten dışa okunur
sonuc_fonk = list(map(lambda s: s ** 2, filter(lambda s: s % 2 == 0, sayilar)))
# Aynı iş comprehension ile: tek satır, soldan sağa okunur
sonuc_comp = [s ** 2 for s in sayilar if s % 2 == 0]
print(sonuc_fonk) # [4, 16]
print(sonuc_comp) # [4, 16]
Çıktılar aynı; fark ifade biçiminde. map/filter fonksiyonel programlama geleneğinden gelir; elinde hazır fonksiyonlar varsa kimi zaman işe yarar. Ama çoğu Python kod tabanında comprehension tercih edilir, çünkü lambda yığınları yerine doğrudan okunur bir cümle kurar. Hangisini seçeceğin takımının alışkanlığına bağlı; bir projede ikisini de gelişigüzel karıştırmaman yeterli. Bu seride Ders 28'de map/filter konusuna ayrıca döneceğiz.
Birden Fazla Listeyi Birlikte İşlemek
İki listeyi eleman eleman eşleştirmen gereken anlar olur: fiyatlar ile adetler, isimler ile yaşlar. Bunun yolu zip'tir ve comprehension ile kusursuz uyum sağlar.
fiyatlar = [120, 45, 300]
adetler = [2, 5, 1]
toplamlar = [f * a for f, a in zip(fiyatlar, adetler)] # zip ikilileri üretir
print(toplamlar) # [240, 225, 300]
Arkada zip her iki listeden aynı konumdaki elemanları alıp ikililer üretir; comprehension da bu ikilileri açıp çarpar. Listelerden biri kısaysa zip kısa olanın boyunda durur; sessizce fazladan eleman düşürür, bu da kimi zaman başka bir sinsi bug kaynağıdır. Uzunlukların eşit olduğundan emin olmak istersen önce len() kontrolü ekle.
Sık Sorulan Sorular
Comprehension her zaman for döngüsünden hızlı mıdır?
Çoğu zaman evet; çünkü append çağrıları ve döngü yönetimi C tarafında, daha sıkı bir döngüde yürütülür. Ama fark genellikle küçüktür; önce okunabilirlik için düşün, performansı mikro düzeyde kovalama. Gerçek darboğazı merak ediyorsan timeit modülüyle ölç; tahmin değil, ölçüm konuşsun.
Döngü değişkeni dışarıya sızar mı?
Hayır. Python 3'te comprehension'ın döngü değişkeni kendi kapsamında kalır; dışarıdaki aynı isimli değişken etkilenmez. Python 2'de sızıyordu; o dönem artık tarihe karıştı.
Sadece liste için mi geçerli? Küme ve sözlük de üretebilir miyim?
Üretebilirsin. Aynı sözdizimiyle {s ** 2 for s in sayilar} küme, {s: s ** 2 for s in sayilar} sözlük üretir. Bunlara set ve dict comprehension denir; mantık birebir aynıdır, yalnızca kabuk değişir. Bir de generator ifadesi var: (s ** 2 for s in sayilar) parantezle yazılır ve listeyi bellekte tutmadan üretir; milyonluk veride bunu kullanacağız, jeneratörler dersinde detayına gireriz.
Sırada Ne Var?
Artık listeleri hem uzun hem kısa yoldan kuruyorsun. Ama bir soru havada asılı duruyor: hangi veri yapısını ne zaman seçeceksin? Liste mi, sözlük mü, küme mi, demet mi? Bir sonraki derste Veri Yapılarını Doğru Seçmek başlığıyla tam da bu soruyu masaya yatıracağız; orada dört yapıyı karşı karşıya koyup her senaryo için doğru tercihi yapmayı öğreneceksin. O zamana kadar bugünkü temizlik örneğini kendi verinle yeniden yaz; tekrar, senin öğretmenindir.







