Python Lambda, map, filter
Ders 27: Değişken Kapsamı (Scope) dersinde değişkenlerin nerede yaşadığını ve fonksiyonların isim alanlarını çözmüştük. O dersin sonunda elimizde hep "adı olan" fonksiyonlar vardı; bugün işin bambaşka bir tarafına bakıyoruz: adı bile olmayan fonksiyonlar. Evet, Python'da öyle bir şey var ve sandığından çok daha sık karşına çıkacak.
Yıllardır kod yazan biri olarak şunu net söyleyeyim: lambda'yı ilk gördüğünde "buna ne gerek var?" demen normal. Sonra map ve filter geldiğinde kafan iyice karışabilir. Bugün üçünü birden, gerçek bir veri temizleme örneğine kadar işleyeceğiz.
Lambda: İsimsiz Tek Satırlık Fonksiyon
Lambda, tek bir ifadeden oluşan isimsiz fonksiyondur. def ile yazdığın fonksiyonlar gibi çağrılır, parametre alır, değer döndürür; tek farkı, bir adının olmaması ve gövdesinin tek satırla sınırlı olmasıdır.
Sözdizimi şöyle:
# Lambda sözdizimi: lambda parametreler: ifade
# Sonuç, return yazmaya gerek kalmadan otomatik döndürülür
iki_kat = lambda x: x * 2
print(iki_kat(5)) # Ekrana 10 yazar
print(iki_kat(21)) # Ekrana 42 yazar
Arka planda Python, lambda x: x * 2 ifadesini küçük bir fonksiyon nesnesine çevirir ve onu iki_kat değişkenine bağlar. Dikkat et: return kelimesi yok, çünkü lambda gövdesindeki ifade değerlendirilip doğrudan geri döndürülür. Yani iki_kat(5) çağrısı, aslında o isimsiz fonksiyonun x parametresine 5 koyup x * 2 ifadesini çalıştırmasından ibarettir.
Lambda'nın asıl gücü, kısa ömürlü işlerde kendini gösterir. sorted() fonksiyonuna key verirken, bir butonun tıklama olayına küçük bir tepki bağlarken ve en çok da az sonra göreceğin map ile filter'a fonksiyon geçirirken kullanılır. Sıralama örneğine bakalım:
# Sıralamada anahtar (key) olarak lambda: öğrencileri nota göre sırala
ogrenciler = [
{"ad": "Ece", "not": 92},
{"ad": "Mert", "not": 78},
{"ad": "Zeynep", "not": 85},
]
sirali = sorted(ogrenciler, key=lambda o: o["not"], reverse=True)
print(sirali[0]["ad"]) # Ece — en yüksek notun sahibi
Arka planda sorted, her sözlüğü sırayla lambda o: o["not"] fonksiyonuna sokup dönen sayıya göre sıralama yapar. Sıralama anahtarı dediğimiz şey tam olarak budur: her öğeden türetilen bir karşılaştırma değeri. Bu tür tek satırlık anahtar fonksiyonları, lambda'nın en meşru kullanım alanıdır; her seferinde üç satırlık bir def yazmak hem dosyayı şişirir hem okuru yorar.
map: Bir İşlemi Her Öğeye Uygula
map(fonksiyon, iterable), verdiğin iterable içindeki her öğeye aynı fonksiyonu uygular. Liste, tuple, hatta dosya satırları; ne verirsen ver, tek tek işler.
# map: listenin her öğesine aynı fonksiyonu uygular
sayilar = [1, 2, 3, 4, 5]
kareler = map(lambda x: x ** 2, sayilar)
print(kareler) # <map object at 0x...> gibi bir çıktı görürsün
print(list(kareler)) # [1, 4, 9, 16, 25]
Buradaki kritik nokta, map'in sana liste değil tembel (lazy) bir map nesnesi vermesi. Yani öğeler henüz hesaplanmamıştır; sen onları tüketmeye başlayınca tek tek üretilir. İlk print bu yüzden garip bir nesne adresi gösterdi. list() çağrısı ise o nesnenin içindeki her şeyi tüketip gerçek bir listeye çevirdi.
İşte tam burada bir acı tecrübem var. Yıllar önce, henüz map'in tembel olduğunu bilmediğim günlerde, bir veri akışını map ile işleyip iki kez döngüye sokmuştum. İlk döngü tıkır tıkır çalıştı, ikincisi bomboş döndü. Saatlerce "verilerim nereye kayboldu?" diye aradım. Meğer map nesnesi tek kullanımlıkmış; ilk döngü tüm öğeleri tüketmiş, ikinciye hiçbir şey kalmamış. O günden beri bir map nesnesini birden fazla kez kullanacaksam önce list() ile sarmalarım; en azından neyle çalıştığımı gözümle görürüm.
Bir diğer az bilinen özellik: map'e birden fazla iterable verebilirsin. O zaman lambda, her turda iki ayrı listeden birer öğe alır:
# İki listeyi öğe öğe toplar: map(fonksiyon, iterable1, iterable2)
a = [1, 2, 3]
b = [10, 20, 30]
toplamlar = map(lambda x, y: x + y, a, b)
print(list(toplamlar)) # [11, 22, 33]
Burada Python her iki listeyi paralel yürütür ve lambda x, y: x + y çağrısına sırayla (1, 10), (2, 20), (3, 30) çiftlerini geçer. Listelerden biri daha kısaysa, sonuç da kısa olanın uzunluğu kadar üretilir; fazladan öğeler sessizce yok sayılır. Bu davranışı bilmek, zip kullanmadan eleman bazlı işlem yapmanın kestirme yoludur.
filter: Koşulu Sağlayanları Ayıkla
filter(kosul, iterable), her öğeyi koşul fonksiyonundan geçirir ve True dönenleri saklar.
# filter: koşulu sağlayan öğeleri geri döndürür
sayilar = [12, 5, 8, 30, 9]
buyukler = filter(lambda x: x > 10, sayilar)
print(list(buyukler)) # [12, 30] — sadece 10'dan büyükler kaldı
Arka planda olan şey aslında çok basit: Python her öğeyi sırayla lambda x: x > 10 fonksiyonuna sokar, sonuç True ise öğeyi bir sonraki aşamaya taşır, False ise sessizce atar. filter de tıpkı map gibi tembeldir; o yüzden gerçek sonucu görmek istediğinde list() sarmayı unutma.
Bir bonus bilgi: filter(None, iterable) yazarsan, Python koşul fonksiyonu yerine öğenin kendisini doğruluk testine sokar ve sadece "doğru" kabul edilenleri bırakır. Boş listeleri, None değerleri ve sıfırları tek hamlede temizlemenin pratik bir yoludur bu. Uygulaması da şöyle:
# filter(None, ...) ile çöp değerleri tek hamlede ayıkla
kayitlar = ["Ankara", None, "", "İzmir", 0, "Bursa"]
dolu = filter(None, kayitlar)
print(list(dolu)) # ['Ankara', 'İzmir', 'Bursa'] — boşlar ve sıfır atıldı
Arka planda koşul fonksiyonu yerine None verildiğinde Python, "öğe doğru mu?" sorusunu kendisi sorar; None, boş string ve 0 doğruluk testinden False döndüğü için listeden atılır. Veri temizliğinde sık kullandığım bu kestirme, birazdan göreceğin gerçek örnekteki çalışmanın minyatür bir provası sayılır.
Gerçek Örnek: Veri Listesini Temizleme
Şimdi teoriyi bir kenara bırakıp gerçekçi bir senaryo kuralım. Elinde bir dosyadan ya da API'den gelen ham veriler var: virgüllü ondalık sayılar, çöp metinler, bozuk kayıtlar. Bu veriyi hem dönüştürmen hem de ayıklaman gerekiyor. map ve filter tam da bu iş için var.
# Dış kaynaktan gelen ham veri; temizlik şart
ham_veri = ["12,5", "8", "abc", "3.14", "-", "42", "0"]
def donustur(deger: str):
"""Virgüllü sayıyı float'a çevirir; çeviremezse None döndürür."""
try:
return float(deger.replace(",", "."))
except ValueError:
return None
# map ile dönüştür, filter ile çöpü ve sıfırları ayıkla
sonuc = filter(lambda x: x is not None and x > 0, map(donustur, ham_veri))
print(list(sonuc)) # [12.5, 8.0, 3.14, 42.0]
Burada iki aşama iç içe çalışıyor. Önce map(donustur, ham_veri) her metni alıp virgülü noktaya çeviriyor ve float'a dönüştürmeyi deniyor; "abc" ve "-" gibi kayıtlar dönüşemediği için None oluyor. Ardından filter devreye girip hem None'ları hem sıfırı eliyor. Sonuç: tek satırda temizlenmiş, yalnızca pozitif sayılardan oluşan bir liste. list() sarmasını da unutmadık; yoksa ekranda yine o gizemli nesne adresiyle karşılaşırdık.
Okunabilirlik: Karmaşık Lambda Yerine def
Şimdi gelelim işin en sevdiğim uyarısına. Lambda güzeldir ama bir yere kadar. PEP 8'in resmi tavsiyesi şudur: lambda'yı bir isme bağlayacaksan, onun yerine def yaz. Yani iki_kat = lambda x: x * 2 gibi satırlar, Python topluluğunun gözünde kötü pratiktir.
Burada da bir acı tecrübem var; hem de bizzat stajyerimle yaşadığım. Stajyer, bir raporlama kodunda şöyle bir satır yazmıştı:
# KÖTÜ: lambda içinde iç içe koşullar — okunamaz, adım adım izlenemez
etiket = lambda x: "düşük" if x < 5 else ("orta" if x < 10 else "yüksek")
Kod ilk bakışta çalışıyordu; ama veri setinde bir sınır değeri beklenenden farklı etiketlenince işler karıştı. Hata nerede? Lambda'nın içinde olduğu için üzerine breakpoint koyup adım adım izleyemiyorduk; her denemede satırı yeniden yazmak gerekiyordu. Saatler gitti. En sonunda aynı mantığı def ile yazdık ve sorun beş dakikada çözüldü:
# İYİ: aynı mantık def ile — adı var, satır satır izlenebilir
def etiketle(x):
if x < 5:
return "düşük"
if x < 10:
return "orta"
return "yüksek"
Arka planda iki sürüm de aşağı yukarı aynı işi yapıyor; fark performansta değil, insan tarafında. def ile yazılan fonksiyonun bir adı, dokümantasyonu ve debug araçlarının izleyebileceği bir gövdesi var. Lambda'nın satır numarasına print ekleyip hata kovalayamazsın. O yüzden kuralım şu: lambda yalnızca tek bir basit ifade için; mantık dallanmaya başladığı an def'e geç.
Bir de şu var: lambda hataları bazen hiç de nazik davranmaz. İsimsiz olduğu için hata izi sana "şu satırdaki <lambda> patladı" der; hangi fonksiyonun patladığını değil. Def ile yazılan fonksiyonlarda hata izi fonksiyonun adını taşır; log dosyasına bakan biri sorunun nerede olduğunu saniyeler içinde anlar. Üç satırdan uzun hiçbir iş lambda'ya ait değildir; bu cümleyi monitörünün kenarına yapıştır, pişman olmazsın.
Sık Sorulan Sorular
Lambda ne zaman kullanılmalı?
Kısa ömürlü, tek ifadelik işler için: sorted'a key verirken, map ve filter'a fonksiyon geçirirken, bir callback bekleyen küçük API'lerde. Fonksiyon bir ismi ve birden fazla satırı hak ediyorsa lambda doğru araç değildir; PEP 8 de tam olarak bunu söyler. Kısa bir test şu: bu fonksiyona isim versem kod daha mı anlaşılır olur? Cevap evetse lambda kullanma.
map ve filter yerine liste kavrayışı kullanmalı mıyım?
Çoğu Python geliştiricisi evet der. [x ** 2 for x in sayilar] ile list(map(lambda x: x ** 2, sayilar)) aynı işi yapar; ilki genellikle daha okunaklı bulunur. Ama map'i öğrenmek yine de şart, çünkü gerçek kod tabanlarında ve başka dillerden gelen ekiplerin yazdığı projelerde sık sık karşına çıkar.
Lambda'ya birden fazla satır yazabilir miyim?
Hayır. Lambda gövdesi tek bir ifadeyle sınırlıdır; atama, print, çok satırlı koşullar giremezsin. Noktalı virgülle bir şeyler sıkıştıranlar görürsün ama o yol okunamaz koda çıkar. İkinci satıra ihtiyaç duyduğun an, def zamanı gelmiş demektir.
Sırada Ne Var?
Lambda, map ve filter ile fonksiyonel tarafın bu kısmını tamamladık. Bir sonraki derste yazdığın kodları tekrar tekrar yazmaktan kurtaran asıl mekanizmaya geçiyoruz: Modüller ve import. Orada kendi dosyalarını birbirine nasıl bağlayacağını, standart kütüphaneden nasıl yararlanacağını ve bu işin inceliklerini göreceksin.







