Lambda, map, filter, reduce

Şimdiye kadar fonksiyonları def ile tanımladın — isim verdin, gövde yazdın, gerekirse docstring ekledin. Ama bazen sadece "şu sayıyı 2 ile çarp" gibi basit bir işlem için tam teşekküllü bir fonksiyon tanımlamak gereksiz hissedebilir. İşte lambda burada devreye girer.

Bu derste lambda fonksiyonlarını ve onların en çok kullanıldığı araçları — map(), filter(), reduce() ve sorted() — öğreneceksin.

Lambda Nedir?

Lambda, tek satırlık, anonim (isimsiz) bir fonksiyondur. "Anonim" çünkü def ile fonksiyona isim vermene gerek yok.

Bir post-it not gibi düşün: Tam teşekküllü bir mektup yazmak (def) yerine, küçük bir işlem için küçük bir not (lambda) yapıştırırsın. İşi bitince atarsın.

# def ile normal fonksiyon
def kare(x):
    return x ** 2

# Aynı şeyin lambda versiyonu
kare_lambda = lambda x: x ** 2

# İkisi de aynı şeyi yapar
print(kare(5))         # 25
print(kare_lambda(5))  # 25

Lambda Söz Dizimi

lambda parametreler: ifade

lambda → anahtar kelime
parametreler → virgülle ayrılmış parametreler (normal fonksiyon gibi)
: → iki nokta
ifade → tek bir ifade (expression). Bu ifadenin sonucu otomatik return edilir.

# Parametresiz
selam = lambda: "Merhaba!"
print(selam())  # Merhaba!

# Tek parametre
iki_kati = lambda x: x * 2
print(iki_kati(7))  # 14

# Birden fazla parametre
topla = lambda a, b: a + b
print(topla(3, 5))  # 8

# Default parametre
selamla = lambda isim, dil="tr": f"Merhaba {isim}!" if dil == "tr" else f"Hello {isim}!"
print(selamla("Ali"))            # Merhaba Ali!
print(selamla("Ali", dil="en"))  # Hello Ali!

# Koşullu ifade (ternary)
mutlak = lambda x: x if x >= 0 else -x
print(mutlak(-5))  # 5
print(mutlak(3))   # 3

Lambda'nın Sınırları

Lambda'lar sadece tek bir ifade (expression) alabilir. Statement (atama, if/else blokları, for döngüsü vb.) kullanamazsın:

# ❌ Bunlar lambda'da YAPILAMAZ
# lambda x: y = x + 1           # Atama yok
# lambda x: if x > 0: return x  # if bloğu yok
# lambda x: for i in x: print(i)  # for döngüsü yok
# lambda x: import math          # import yok

# ✅ Ama ternary expression kullanabilirsin
sinifla = lambda x: "pozitif" if x > 0 else ("negatif" if x < 0 else "sıfır")
print(sinifla(5))    # pozitif
print(sinifla(-3))   # negatif
print(sinifla(0))    # sıfır

Ne Zaman Lambda, Ne Zaman `def`?

Bu sorunun cevabı basit: çoğu zaman `def` kullan.

Lambda kullanmanın mantıklı olduğu yerler:

Basit, tek satırlık işlemler
sorted(), map(), filter() gibi fonksiyonlara geçici fonksiyon verirken
Fonksiyon çok kısa ve tekrar kullanılmayacaksa

def kullanman gereken yerler:

İşlem birden fazla satır gerektiriyorsa
Fonksiyona açıklayıcı bir isim vermek anlaşılırlığı artırıyorsa
Fonksiyona docstring eklemek istiyorsan
Fonksiyon birden fazla yerde kullanılacaksa
Hata ayıklama (debugging) yapman gerekiyorsa

# ✅ Lambda mantıklı: kısa, tek kullanımlık
students.sort(key=lambda s: s["grade"])

# ❌ Lambda anlamsız: neden değişkene atıyorsun ki?
kare = lambda x: x ** 2  # Bunun yerine def kare(x) yaz!

# ❌ Lambda okunaksız: çok karmaşık
transform = lambda x: (x ** 2 + 3 * x - 7) / (x + 1) if x != -1 else 0
# Bunun yerine def ile yaz, docstring ekle

💡 İpucu: PEP 8 (Python stil rehberi) diyor ki: "Lambda'yı bir değişkene atamak yerine def kullanın." Yani kare = lambda x: x ** 2 yazmak yerine def kare(x): return x ** 2 yazın. Lambda, doğrudan başka fonksiyonlara argüman olarak geçirilmek için tasarlanmıştır.

`map()`: Her Elemana Fonksiyon Uygula

map() bir fonksiyonu bir iterablenin her elemanına uygular ve sonuçları döndürür.

map(fonksiyon, iterable)

Temel Kullanım

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

# Her sayının karesini al
kareler = map(lambda x: x ** 2, sayilar)
print(list(kareler))  # [1, 4, 9, 16, 25]

# Her sayıyı string'e çevir
str_sayilar = map(str, sayilar)
print(list(str_sayilar))  # ['1', '2', '3', '4', '5']

map() bir iterator döndürür (tembel değerlendirme). Sonuçları görmek için list() ile listeye çeviriyoruz.

`map()` ile Pratik Örnekler

# Celsius → Fahrenheit dönüşümü
celsius = [0, 20, 37, 100]
fahrenheit = list(map(lambda c: c * 9/5 + 32, celsius))
print(fahrenheit)  # [32.0, 68.0, 98.6, 212.0]

# İsimleri büyük harfe çevir
isimler = ["ahmet", "ayşe", "mehmet"]
buyuk = list(map(str.upper, isimler))
print(buyuk)  # ['AHMET', 'AYŞE', 'MEHMET']

# Boşlukları temizle
kirli_veri = ["  ali  ", "veli   ", "  ayşe"]
temiz = list(map(str.strip, kirli_veri))
print(temiz)  # ['ali', 'veli', 'ayşe']

Birden Fazla Iterable ile `map()`

map() birden fazla iterable alabilir. Fonksiyon da o kadar parametre almalı:

# İki listeyi eleman eleman topla
liste1 = [1, 2, 3, 4]
liste2 = [10, 20, 30, 40]

toplam = list(map(lambda a, b: a + b, liste1, liste2))
print(toplam)  # [11, 22, 33, 44]

# Üç listeyle
a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]

sonuc = list(map(lambda x, y, z: x + y + z, a, b, c))
print(sonuc)  # [12, 15, 18]

`map()` vs List Comprehension

Aynı işi list comprehension ile de yapabilirsin ve genellikle daha Pythonic:

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

# map ile
kareler_map = list(map(lambda x: x ** 2, sayilar))

# Comprehension ile (daha okunaklı)
kareler_comp = [x ** 2 for x in sayilar]

# İkisi de aynı sonucu verir: [1, 4, 9, 16, 25]

Ne zaman hangisi?

Basit dönüşümler → comprehension tercih et
Zaten tanımlı bir fonksiyon varsa → map() temiz olabilir: map(int, str_list)
Fonksiyon karmaşıksa → comprehension daha okunur

`filter()`: Koşula Uyanları Filtrele

filter() bir fonksiyonu her elemana uygular ve True döndüren elemanları tutar.

filter(fonksiyon, iterable)

Temel Kullanım

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

# Çift sayıları filtrele
ciftler = list(filter(lambda x: x % 2 == 0, sayilar))
print(ciftler)  # [2, 4, 6, 8, 10]

# 5'ten büyük sayılar
buyukler = list(filter(lambda x: x > 5, sayilar))
print(buyukler)  # [6, 7, 8, 9, 10]

Pratik Örnekler

# Boş string'leri filtrele
kelimeler = ["merhaba", "", "dünya", "", "python", ""]
dolu = list(filter(None, kelimeler))  # None → truthy değerleri tutar
print(dolu)  # ['merhaba', 'dünya', 'python']

# Negatif sayıları at
sayilar = [3, -1, 4, -1, 5, -9, 2, -6]
pozitifler = list(filter(lambda x: x >= 0, sayilar))
print(pozitifler)  # [3, 4, 5, 2]

# Öğrenci listesinden başarılıları filtrele
ogrenciler = [
    {"ad": "Ahmet", "not": 85},
    {"ad": "Ayşe", "not": 92},
    {"ad": "Mehmet", "not": 45},
    {"ad": "Zeynep", "not": 78},
    {"ad": "Ali", "not": 33},
]

basariliar = list(filter(lambda o: o["not"] >= 60, ogrenciler))
for o in basariliar:
    print(f"  {o['ad']}: {o['not']}")
# Ahmet: 85
# Ayşe: 92
# Zeynep: 78

`filter()` vs List Comprehension

sayilar = range(1, 21)

# filter ile
ciftler_filter = list(filter(lambda x: x % 2 == 0, sayilar))

# Comprehension ile (daha Pythonic)
ciftler_comp = [x for x in sayilar if x % 2 == 0]

# İkisi de: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

`map()` + `filter()` Kombinasyonu

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

# Çift sayıların karelerini al
sonuc = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, sayilar)))
print(sonuc)  # [4, 16, 36, 64, 100]

# Aynı şey comprehension ile (ÇOOK daha okunaklı)
sonuc = [x ** 2 for x in sayilar if x % 2 == 0]
print(sonuc)  # [4, 16, 36, 64, 100]

İç içe map ve filter okunabilirliği çok bozar. Comprehension burada açık ara kazanıyor.

`reduce()`: Tüm Elemanları Birleştir

reduce() listedeki elemanları birikimli olarak birleştirir. İlk iki eleman işlenir, sonuç üçüncü elemanla işlenir, o sonuç dördüncü ile... ta ki tek bir değer kalana kadar.

reduce() built-in değil, functools modülünden import etmen gerekir:

from functools import reduce

reduce(fonksiyon, iterable, baslangic_degeri)

Temel Kullanım

from functools import reduce

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

# Toplama
toplam = reduce(lambda a, b: a + b, sayilar)
print(toplam)  # 15
# Adımlar: ((((1+2)+3)+4)+5) = 15

# Çarpma (faktöriyel gibi)
carpim = reduce(lambda a, b: a * b, sayilar)
print(carpim)  # 120
# Adımlar: ((((1*2)*3)*4)*5) = 120

Adım adım görselleştirelim:

from functools import reduce

def detayli_topla(a, b):
    sonuc = a + b
    print(f"  {a} + {b} = {sonuc}")
    return sonuc

sayilar = [1, 2, 3, 4, 5]
toplam = reduce(detayli_topla, sayilar)

Çıktı:

  1 + 2 = 3
  3 + 3 = 6
  6 + 4 = 10
  10 + 5 = 15

Başlangıç Değeri ile

from functools import reduce

# Başlangıç değeri: 100
sonuc = reduce(lambda a, b: a + b, [1, 2, 3], 100)
print(sonuc)  # 106  (100 + 1 + 2 + 3)

# Boş listeyle başlangıç değeri zorunlu
sonuc = reduce(lambda a, b: a + b, [], 0)
print(sonuc)  # 0

# Başlangıç değeri olmadan boş liste → HATA
# reduce(lambda a, b: a + b, [])  # TypeError!

Pratik Örnekler

from functools import reduce

# En büyük sayıyı bul
sayilar = [3, 7, 2, 9, 1, 5]
en_buyuk = reduce(lambda a, b: a if a > b else b, sayilar)
print(f"En büyük: {en_buyuk}")  # 9

# String birleştirme
kelimeler = ["Python", "çok", "güzel", "bir", "dil"]
cumle = reduce(lambda a, b: a + " " + b, kelimeler)
print(cumle)  # Python çok güzel bir dil

# İç içe listeleri düzleştir (flatten)
ic_ice = [[1, 2], [3, 4], [5, 6]]
duz = reduce(lambda a, b: a + b, ic_ice)
print(duz)  # [1, 2, 3, 4, 5, 6]

`reduce()` Ne Zaman Kullanılır?

Dürüst olmak gerekirse, reduce() Python'da nadiren gereklidir. Çoğu durumda daha iyi alternatifler var:

from functools import reduce

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

# Toplam
reduce(lambda a, b: a + b, sayilar)  # ❌ Gereksiz karmaşıklık
sum(sayilar)                          # ✅ Basit ve açık

# En büyük
reduce(lambda a, b: a if a > b else b, sayilar)  # ❌
max(sayilar)                                       # ✅

# En küçük
reduce(lambda a, b: a if a < b else b, sayilar)  # ❌
min(sayilar)                                       # ✅

# String birleştirme
reduce(lambda a, b: a + " " + b, kelimeler)  # ❌
" ".join(kelimeler)                            # ✅

Guido van Rossum (Python'un yaratıcısı) bile reduce()'ı Python 3'te built-in'den çıkardı çünkü çoğu kullanımı gereksiz yere karmaşık buluyordu.

reduce() gerçekten parlayan durumlar: karmaşık birikimli işlemler, pipeline oluşturma, fonksiyon kompozisyonu gibi ileri seviye senaryolar.

`sorted()` ile `key=lambda`

sorted() fonksiyonunun key parametresi, lambda'nın en yaygın kullanım alanı:

# Basit sıralama
sayilar = [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted(sayilar))  # [1, 1, 2, 3, 4, 5, 6, 9]

# Mutlak değere göre sırala
sayilar = [-5, 3, -2, 8, -1, 7]
print(sorted(sayilar, key=lambda x: abs(x)))
# [-1, -2, 3, -5, 7, 8]

String Sıralama

isimler = ["Zeynep", "ahmet", "Büşra", "can", "Ali"]

# Varsayılan: büyük harf önce (ASCII sırası)
print(sorted(isimler))
# ['Ali', 'Büşra', 'Zeynep', 'ahmet', 'can']

# Büyük-küçük harf duyarsız sıralama
print(sorted(isimler, key=lambda s: s.lower()))
# ['ahmet', 'Ali', 'Büşra', 'can', 'Zeynep']

# Son harfe göre sırala
print(sorted(isimler, key=lambda s: s[-1]))
# ['Büşra', 'Zeynep', 'ahmet', 'Ali', 'can']

Dictionary Listesi Sıralama

Bu, lambda + sorted'ın en yaygın kullanımı:

ogrenciler = [
    {"ad": "Zeynep", "not": 92},
    {"ad": "Ahmet", "not": 78},
    {"ad": "Ayşe", "not": 95},
    {"ad": "Mehmet", "not": 65},
    {"ad": "Can", "not": 88},
]

# Nota göre sırala (küçükten büyüğe)
nota_gore = sorted(ogrenciler, key=lambda o: o["not"])
for o in nota_gore:
    print(f"  {o['ad']}: {o['not']}")

print()

# Nota göre sırala (büyükten küçüğe)
nota_gore_ters = sorted(ogrenciler, key=lambda o: o["not"], reverse=True)
for o in nota_gore_ters:
    print(f"  {o['ad']}: {o['not']}")

Çoklu Kritere Göre Sıralama

urunler = [
    {"ad": "Laptop", "fiyat": 15000, "stok": 5},
    {"ad": "Mouse", "fiyat": 200, "stok": 50},
    {"ad": "Klavye", "fiyat": 500, "stok": 30},
    {"ad": "Monitor", "fiyat": 5000, "stok": 10},
    {"ad": "SSD", "fiyat": 500, "stok": 20},
]

# Önce fiyata göre, aynı fiyatta stok'a göre sırala
sirali = sorted(urunler, key=lambda u: (u["fiyat"], u["stok"]))
for u in sirali:
    print(f"  {u['ad']}: {u['fiyat']}₺ (stok: {u['stok']})")

Çıktı:

  Mouse: 200₺ (stok: 50)
  Klavye: 500₺ (stok: 30) ← Aynı fiyat, stok'a göre sıralı
  SSD: 500₺ (stok: 20)   ← Hmm, 20 < 30... ters oldu!

Tuple döndürdüğünde her eleman soldan sağa karşılaştırılır. Stokun azalandan sıralanmasını istersen:

# Fiyat artan, stok azalan
sirali = sorted(urunler, key=lambda u: (u["fiyat"], -u["stok"]))

`operator` Modülü Alternatifi

Basit attribute/key erişimi için operator modülü lambda'dan daha hızlı ve okunur:

from operator import itemgetter, attrgetter

# itemgetter: dict key'e göre
ogrenciler = [
    {"ad": "Zeynep", "not": 92},
    {"ad": "Ahmet", "not": 78},
]

# Lambda yerine:
sorted(ogrenciler, key=lambda o: o["not"])
# itemgetter ile:
sorted(ogrenciler, key=itemgetter("not"))

# Çoklu key:
sorted(ogrenciler, key=itemgetter("not", "ad"))

Lambda vs Comprehension Karşılaştırma

Python'da aynı işi yapmanın birden fazla yolu var. Hangisi ne zaman?

Dönüştürme (Transform)

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

# map + lambda
kareler = list(map(lambda x: x ** 2, sayilar))

# List comprehension ✅ (daha Pythonic)
kareler = [x ** 2 for x in sayilar]

Filtreleme

sayilar = range(1, 21)

# filter + lambda
ciftler = list(filter(lambda x: x % 2 == 0, sayilar))

# List comprehension ✅ (daha Pythonic)
ciftler = [x for x in sayilar if x % 2 == 0]

Filtre + Dönüşüm

sayilar = range(1, 21)

# map + filter + lambda (okunması zor)
sonuc = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, sayilar)))

# Comprehension ✅ (bir bakışta anlaşılır)
sonuc = [x ** 2 for x in sayilar if x % 2 == 0]

Genel Kural

Durum	Tercih
Basit dönüşüm	Comprehension
Basit filtreleme	Comprehension
Zaten tanımlı fonksiyon var	`map(fonksiyon, ...)` temiz
Sıralama key'i	`sorted(key=lambda ...)`
Callback fonksiyon	Lambda
Karmaşık mantık	`def` ile fonksiyon

⚠️ Aşırı Karmaşık Lambda Anti-Pattern

Lambda'nın en büyük düşmanı: "Acaba bunu tek satıra sığdırabilir miyim?" dürtüsü.

# ❌ ANTİ-PATTERN: Anlaşılmaz lambda
process = lambda data: dict(
    map(lambda x: (x[0], sum(x[1]) / len(x[1])),
        filter(lambda x: len(x[1]) > 2,
               data.items())))

# Bu ne yapıyor? Kim bilir! 🤷

# ✅ Aynı şey okunaklı şekilde
def hesapla_ortalamalar(data):
    """En az 3 değeri olan anahtarların ortalamalarını hesaplar."""
    sonuc = {}
    for anahtar, degerler in data.items():
        if len(degerler) > 2:
            sonuc[anahtar] = sum(degerler) / len(degerler)
    return sonuc

Başka bir örnek:

# ❌ Okunaksız
students_sorted = sorted(
    filter(lambda s: s["active"],
           map(lambda s: {**s, "avg": sum(s["grades"]) / len(s["grades"])},
               students)),
    key=lambda s: s["avg"],
    reverse=True
)

# ✅ Adım adım, anlaşılır
def ogrenci_ortalamasi(ogrenci):
    """Öğrenciye ortalama notu ekler."""
    return {
        **ogrenci,
        "avg": sum(ogrenci["grades"]) / len(ogrenci["grades"])
    }

def aktif_mi(ogrenci):
    """Aktif öğrencileri filtreler."""
    return ogrenci["active"]

ortalamaliar = map(ogrenci_ortalamasi, students)
aktifler = filter(aktif_mi, ortalamaliar)
sirali = sorted(aktifler, key=lambda s: s["avg"], reverse=True)

⚠️ Dikkat: Eğer bir lambda'yı okumak için 5 saniyeden fazla düşünmen gerekiyorsa, onu def ile yaz. Kod bir kere yazılır, yüzlerce kere okunur. Okunabilirlik her zaman zekayla yazılmış tek satırdan daha önemlidir.

Lambda'yı kullanma kuralı: Bir satırda anında anlaşılıyorsa lambda. 2 saniye bile duraksıyorsan def.

Fonksiyonel Programlama Araçları: Ekstra

`any()` ve `all()`

Lambda ile birlikte sık kullanılan built-in'ler:

sayilar = [2, 4, 6, 8, 10]

# Hepsi çift mi?
print(all(x % 2 == 0 for x in sayilar))  # True

# En az biri 10'dan büyük mü?
print(any(x > 10 for x in sayilar))  # False

# Öğrenci notları
notlar = [85, 72, 91, 45, 88]
hepsi_gecti = all(n >= 50 for n in notlar)
print(f"Herkes geçti mi? {hepsi_gecti}")  # False (45 var)

`zip()` + `map()`

isimler = ["Ahmet", "Ayşe", "Can"]
notlar = [85, 92, 78]

# İsimleri ve notları birleştir
ogrenciler = list(map(lambda pair: f"{pair[0]}: {pair[1]}", zip(isimler, notlar)))
print(ogrenciler)  # ['Ahmet: 85', 'Ayşe: 92', 'Can: 78']

# Daha temiz: comprehension ile
ogrenciler = [f"{isim}: {not_}" for isim, not_ in zip(isimler, notlar)]
print(ogrenciler)  # Aynı sonuç

`enumerate()` ile Lambda (Nadir Ama Bilinmeli)

meyveler = ["elma", "armut", "portakal", "muz"]

# İndeksli formatlama
numarali = list(map(lambda pair: f"{pair[0]+1}. {pair[1]}", enumerate(meyveler)))
print(numarali)
# ['1. elma', '2. armut', '3. portakal', '4. muz']

# Yine comprehension daha temiz
numarali = [f"{i+1}. {m}" for i, m in enumerate(meyveler)]

Gerçek Dünya Kullanım Senaryoları

Lambda ve fonksiyonel araçlar soyut görünebilir. Hadi gerçek dünyada nasıl kullanıldıklarını görelim.

Veri Temizleme Pipeline

Mesela bir CSV dosyasından gelen kirli veriyi temizlemen gerekiyor:

# Ham veri (CSV'den geldi diyelim)
ham_veri = [
    "  Ahmet YILMAZ  ",
    "",
    "  ayşe kaya",
    "   ",
    "MEHMET   DEMİR  ",
    None,
    "  zeynep Aksoy  ",
]

# Pipeline: None/boş temizle → strip → title case
temiz = list(
    map(
        lambda s: s.strip().title(),           # 3. Title case yap
        filter(
            lambda s: s and s.strip(),          # 2. Boş/None olanları at
            ham_veri                             # 1. Ham veri
        )
    )
)

print(temiz)
# ['Ahmet Yılmaz', 'Ayşe Kaya', 'Mehmet Demir', 'Zeynep Aksoy']

# Aynı şey comprehension ile (daha Pythonic):
temiz = [s.strip().title() for s in ham_veri if s and s.strip()]

E-Ticaret: Ürün Filtreleme ve Sıralama

urunler = [
    {"ad": "Laptop", "fiyat": 15000, "stok": 5, "kategori": "elektronik"},
    {"ad": "Kalem", "fiyat": 10, "stok": 500, "kategori": "kırtasiye"},
    {"ad": "Mouse", "fiyat": 250, "stok": 0, "kategori": "elektronik"},
    {"ad": "Defter", "fiyat": 25, "stok": 200, "kategori": "kırtasiye"},
    {"ad": "Monitor", "fiyat": 5000, "stok": 8, "kategori": "elektronik"},
    {"ad": "Silgi", "fiyat": 5, "stok": 1000, "kategori": "kırtasiye"},
    {"ad": "Klavye", "fiyat": 500, "stok": 15, "kategori": "elektronik"},
]

# Stokta olan elektronik ürünleri fiyata göre sırala
elektronik_stokta = sorted(
    filter(
        lambda u: u["kategori"] == "elektronik" and u["stok"] > 0,
        urunler
    ),
    key=lambda u: u["fiyat"]
)

for u in elektronik_stokta:
    print(f"  {u['ad']}: {u['fiyat']}₺ (stok: {u['stok']})")
# Mouse: 250₺ (stok: 0) ← filtrelendi, görünmez
# Klavye: 500₺ (stok: 15)
# Monitor: 5000₺ (stok: 8)
# Laptop: 15000₺ (stok: 5)

Gruplama ve Özetleme

from functools import reduce

# Satış verisi
satislar = [
    {"ay": "Ocak", "tutar": 15000},
    {"ay": "Şubat", "tutar": 22000},
    {"ay": "Mart", "tutar": 18000},
    {"ay": "Nisan", "tutar": 25000},
    {"ay": "Mayıs", "tutar": 30000},
    {"ay": "Haziran", "tutar": 28000},
]

# Toplam ciro
toplam = reduce(lambda a, b: a + b["tutar"], satislar, 0)
print(f"Toplam ciro: {toplam:,}₺")  # 138,000₺

# En yüksek satışlı ay
en_iyi = max(satislar, key=lambda s: s["tutar"])
print(f"En iyi ay: {en_iyi['ay']} ({en_iyi['tutar']:,}₺)")
# En iyi ay: Mayıs (30,000₺)

# Ortalamanın üstündeki aylar
ortalama = toplam / len(satislar)
iyi_aylar = list(filter(lambda s: s["tutar"] > ortalama, satislar))
print(f"Ortalamanın ({ortalama:,.0f}₺) üstündeki aylar:")
for s in iyi_aylar:
    print(f"  {s['ay']}: {s['tutar']:,}₺")

Performans Notları

import timeit

sayilar = list(range(10000))

# map + lambda
t1 = timeit.timeit(lambda: list(map(lambda x: x ** 2, sayilar)), number=1000)

# Comprehension
t2 = timeit.timeit(lambda: [x ** 2 for x in sayilar], number=1000)

# For döngüsü
def for_dongusu():
    sonuc = []
    for x in sayilar:
        sonuc.append(x ** 2)
    return sonuc

t3 = timeit.timeit(for_dongusu, number=1000)

print(f"map + lambda:   {t1:.3f}s")
print(f"Comprehension:  {t2:.3f}s")
print(f"For döngüsü:    {t3:.3f}s")

Genel sonuç:

Comprehension genelde en hızlı (C seviyesinde optimize)
map() yakın ikinci (özellikle built-in fonksiyonlarla: map(str, ...))
For döngüsü en yavaş (ama fark çok büyük değil)

Performans farkı küçük. Okunabilirlik her zaman öncelikli olmalı.

Lazy Evaluation (Tembel Değerlendirme)

map() ve filter() iterator döndürür — sonuçları anında hesaplamaz, ihtiyaç oldukça üretir. Büyük veri setlerinde bu çok önemli:

# 10 milyon sayı — ama hepsini belleğe almıyoruz!
buyuk_veri = range(10_000_000)

# Bu ANINDA çalışır (henüz hiçbir şey hesaplanmadı)
sonuc = map(lambda x: x ** 2, buyuk_veri)

# Sadece ilk 5 elemanı al — sadece 5 hesaplama yapıldı
from itertools import islice
ilk_5 = list(islice(sonuc, 5))
print(ilk_5)  # [0, 1, 4, 9, 16]

# Comprehension ile aynı şey:
# [x ** 2 for x in range(10_000_000)]  ← 10M elemanı ANINDA hesaplar!
# Generator expression ile lazy:
# (x ** 2 for x in range(10_000_000))  ← Bu da lazy!

Bu yüzden büyük veri setlerinde map() ve filter() bazen comprehension'dan avantajlı olabilir — ya da generator expression (x for x in ...) kullan.

Özet

Lambda, tek satırlık anonim fonksiyondur. lambda x: x * 2 formatında yazılır ve otomatik return eder.
`map()` bir fonksiyonu iterablenin her elemanına uygular. map(lambda x: x**2, liste) → kareler listesi.
`filter()` koşula uyan elemanları süzer. filter(lambda x: x > 0, liste) → pozitifler.
`reduce()` elemanları birikimli olarak birleştirir. Çoğu durumda sum(), max(), join() gibi built-in'ler daha iyi alternatiflerdir.
`sorted(key=lambda ...)` lambda'nın en yaygın ve en faydalı kullanım alanıdır. Karmaşık sıralama kriterlerini tek satırda ifade edebilirsin.
Comprehension, çoğu durumda map() + filter() kombinasyonundan daha okunabilir ve daha Pythonic'tir. Lambda'yı bir değişkene atamak yerine def kullan; lambda sadece geçici, tek satırlık callback'ler için.

Lambda Nedir?

Lambda Söz Dizimi

Lambda'nın Sınırları

Ne Zaman Lambda, Ne Zaman def?

map(): Her Elemana Fonksiyon Uygula

Temel Kullanım

map() ile Pratik Örnekler

Birden Fazla Iterable ile map()

map() vs List Comprehension

filter(): Koşula Uyanları Filtrele

Temel Kullanım

Pratik Örnekler

filter() vs List Comprehension

map() + filter() Kombinasyonu

reduce(): Tüm Elemanları Birleştir

Temel Kullanım

Başlangıç Değeri ile

Pratik Örnekler

reduce() Ne Zaman Kullanılır?

sorted() ile key=lambda

String Sıralama

Dictionary Listesi Sıralama

Çoklu Kritere Göre Sıralama

operator Modülü Alternatifi

Lambda vs Comprehension Karşılaştırma

Dönüştürme (Transform)

Filtreleme

Filtre + Dönüşüm

Genel Kural

⚠️ Aşırı Karmaşık Lambda Anti-Pattern

Fonksiyonel Programlama Araçları: Ekstra

any() ve all()

zip() + map()

enumerate() ile Lambda (Nadir Ama Bilinmeli)

Gerçek Dünya Kullanım Senaryoları

Veri Temizleme Pipeline

E-Ticaret: Ürün Filtreleme ve Sıralama

Gruplama ve Özetleme

Performans Notları

Lazy Evaluation (Tembel Değerlendirme)

Özet

Ne Zaman Lambda, Ne Zaman `def`?

`map()`: Her Elemana Fonksiyon Uygula

`map()` ile Pratik Örnekler

Birden Fazla Iterable ile `map()`

`map()` vs List Comprehension

`filter()`: Koşula Uyanları Filtrele

`filter()` vs List Comprehension

`map()` + `filter()` Kombinasyonu

`reduce()`: Tüm Elemanları Birleştir

`reduce()` Ne Zaman Kullanılır?

`sorted()` ile `key=lambda`

`operator` Modülü Alternatifi

`any()` ve `all()`

`zip()` + `map()`

`enumerate()` ile Lambda (Nadir Ama Bilinmeli)