Python Return, Varsayılan Değerler, *args ve **kwargs
Ders 25: Fonksiyon Tanımlama (def) bölümünde fonksiyon yazmayı ve çağırmayı öğrenmiştik. Ancak bir fonksiyonun gerçek gücü, ürettiği sonucu çağırana geri verebilmesinde saklı. Bu derste return ifadesinden varsayılan parametre değerlerine, oradan args ve *kwargs'a kadar uzanan yolu birlikte yürüyeceğiz.
return Ne Yapar?
return iki işi birden yapar: fonksiyonu anında sonlandırır ve yanındaki değeri çağıran koda teslim eder. Kulağa basit geliyor, değil mi? Bu basitliğin arkasında yeni başlayan herkesin en az bir kez takıldığı detaylar var.
def kare_al(sayi):
# sonucu hesapla ve çağırana geri ver
sonuc = sayi * sayi
return sonuc
deger = kare_al(7)
print(deger) # 49
Arkada olan şey şu: kare_al(7) çağrısı çalıştı, sonuc değişkeninde 49'u hesapladı ve return ile bu değeri çağrının yapıldığı satıra bıraktı. deger artık 49 değerini taşıyor. Fonksiyon içindeki sonuc değişkeni ise fonksiyon bittiği anda bellekten silindi; dışarıya yalnızca değer taşındı.
Dönen değeri değişkene atamak zorunda bile değilsiniz:
def kare_al(sayi):
return sayi * sayi # kısa ve net bir return
print(kare_al(3) + kare_al(4)) # 9 + 16 = 25
Python önce kare_al(3)'ü bitirip 9'u aldı, ardından kare_al(4)'ü bitirip 16'yı aldı ve ikisini topladı. Yani fonksiyon çağrısı, döndürdüğü değerin birebir yerine geçer. Bunu kavradığınız an, fonksiyonları ifadelerin içinde özgürce kullanmaya başlarsınız.
return Yoksa Fonksiyon None Döner
return yazmadığınız fonksiyonlar da aslında bir değer döndürür: None. Python bunu sizin için sessizce ekler.
def selam_ver(isim):
print(f"Merhaba {isim}") # ekrana yazıyoruz ama return yok
sonuc = selam_ver("Ayşe")
print(sonuc) # None
Arka planda Python, return satırına hiç ulaşmayan her fonksiyonun sonuna görünmez bir return None ekler. Bu yüzden sonuc değişkeni None oldu. Ekrandaki "Merhaba Ayşe" yazısı ile fonksiyonun döndürdüğü değer bambaşka şeylerdir; print değer üretmez, sadece görüntüler.
Şimdi bir itiraf. İlk işimde fatura hesaplayan bir fonksiyon yazmıştım. Ekranda tutarlar mükemmel görünüyordu, ama toplamı veritabanına yazmaya kalktığımızda sürekli None kaydediliyordu. İki saatimi aldı: fonksiyon tutarı hesaplayıp print ediyordu, return etmiyordu. O gün öğrendim ki ekrana yazdırmakla sonuç üretmek aynı şey değil. Bir fonksiyonun çıktısını başka yerde kullanacaksanız mutlaka return etmeli.
Kendinize şu iki kuralı not edin:
- print ekrana yazar, değer üretmez.
- return değer üretir, ekrana yazmaz; dönen değeri görmek isterseniz onu siz yazdırırsınız.
def topla(a, b):
return a + b
deneme = print(topla(5, 3)) # print'in kendisi None döndürür
print(deneme) # None
Burada önce topla(5, 3) çalışıp 8 üretti, print bunu ekrana yazdırdı ve None döndürdü. deneme'ye atanan şey 8 değil, print'in dönüş değeri olan None oldu. Ekrandaki 8 ile değişkendeki None arasındaki fark, bu işin en can alıcı ayrımıdır.
return'den Sonraki Satırlar Çalışmaz
return çalıştığı anda fonksiyon biter. Altındaki satırlar ölü koddur:
def seviye_belirle(puan):
if puan < 50:
return "Başlangıç" # fonksiyon burada sonlanır
print("Bu satır asla çalışmaz") # ölü kod
return "İleri"
print(seviye_belirle(30)) # Başlangıç
puan 50'den küçük olduğu için ilk return devreye girdi ve fonksiyon anında bitti. Alttaki print satırı Python tarafından hiç değerlendirilmedi. IDE'niz de o satırı büyük ihtimalle "unreachable" diye griye boyar; ona inanın.
Bu davranış aslında bir nimettir. Erken return deseniyle geçersiz durumları fonksiyonun başında eleyip derin if yuvalarından kurtulursunuz:
def bolme(a, b):
if b == 0:
return "Sıfıra bölme hatası!" # sorunu hemen ele al
return a / b
print(bolme(10, 2)) # 5.0
print(bolme(10, 0)) # Sıfıra bölme hatası!
İlk çağrıda b sıfır değildi, if atlandı ve bölme sonucu döndü. İkincisinde fonksiyon bölme işlemine hiç ulaşmadan mesajla döndü. Kod böylece tek bir derin else bloğu yerine düz bir akışla okunuyor.
Birden Fazla Değer Döndürmek
return ile birden çok değeri virgülle ayırarak dönebilirsiniz; Python bunları bir demete sarar:
def bolumlu_bolme(a, b):
bolum = a // b # tam bölüm
kalan = a % b # kalan
return bolum, kalan # iki değer, tek return
sonuc = bolumlu_bolme(17, 5)
print(sonuc) # (3, 2)
bolum, kalan = sonuc # demeti iki değişkene aç
print(bolum, kalan) # 3 2
Arkada Python, bolum ve kalan değerlerini (3, 2) demetine paketleyip çağırana verdi. Çağıran tarafta bu demeti aynı satırda iki değişkene açtık. Bu, Python'ın tuple unpacking denilen gücünün fonksiyon dönüşlerine taşınmasından başka bir şey değil.
Varsayılan Parametre Değerleri
Parametreye varsayılan değer vermek için tanımda = kullanırsınız:
def selamla(isim, dil="tr"):
if dil == "tr":
return f"Merhaba, {isim}"
return f"Hello, {isim}"
print(selamla("Murat")) # Merhaba, Murat
print(selamla("Murat", "en")) # Hello, Murat
İlk çağrıda dil verilmediği için "tr" varsayılanı devreye girdi. İkincide açıkça "en" geçildi ve varsayılan ezildi. Varsayılan değerler, çağrı yerlerinde aynı argümanı defalarca tekrar etmekten kurtarır; kod hem kısalır hem netleşir.
Bir de sıralama kuralı var: varsayılanlı parametreler tanımda hep en sona yazılır. Aksi hâlde SyntaxError alırsınız.
def kayit(isim, sehir="İstanbul", yas=30):
# isim zorunlu; sehir ve yas isteğe bağlı
return f"{isim}, {sehir}, {yas} yaşında"
print(kayit("Elif")) # Elif, İstanbul, 30 yaşında
print(kayit("Elif", "Ankara", 28)) # Elif, Ankara, 28 yaşında
print(kayit("Elif", yas=25)) # Elif, İstanbul, 25 yaşında
Python argümanları soldan sağa eşleştirdi: yalnızca isim gelince diğerleri varsayılandan geldi; üç değer gelince sırayla dolduruldu; isimli argümanla çağırınca da yalnızca yas ezildi. Üçüncü çağrıda sehir'i atlayıp doğrudan yas'ı vermek, isimli argüman sayesinde mümkün oldu.
Mutable Default Tuzağı
Python'un en ünlü tuzaklarından birine geldik. Varsayılan değer olarak liste, sözlük gibi mutable nesneler kullanırsanız, o nesne fonksiyon tanımlandığı anda bir kez oluşturulur ve tüm çağrılar onu paylaşır:
def ekle(isim, liste=[]):
# TEHLİKE: bu liste tüm çağrılarda aynı nesne!
liste.append(isim)
return liste
print(ekle("Ali")) # ['Ali']
print(ekle("Veli")) # ['Ali', 'Veli'] <- Ali hâlâ listede!
İkinci çağrıda liste neden sıfırdan başlamadı? Çünkü [] ifadesi fonksiyon tanımlandığı anda değerlendirildi ve bellekte tek bir liste nesnesi yarattı; sonraki her çağrı o aynı nesneye yazdı. append ile eklenen her isim ortak listede birikti.
Bunu yaşayanlardanım. Beş yıl önce bir raporlama servisinde log kayıtlarını biriktiren bir fonksiyon yazmıştım; her müşteri raporu, kendisinden önceki müşterilerin kayıtlarını da içeriyordu. Test ortamında hep tek müşteriyle denediğim için sorunu fark etmedim; canlıda iki müşteri aynı anda rapor alınca patladı. Listeye kimin, nereden veri eklediğini hata ayıklayıcıda çözmek tam üç saatimi aldı. O günden beri varsayılan değer olarak asla mutable nesne kullanmam.
Doğrusu şudur:
def ekle(isim, liste=None):
# varsayılanı None yap; listeyi her çağrıda yeniden kur
if liste is None:
liste = []
liste.append(isim)
return liste
print(ekle("Ali")) # ['Ali']
print(ekle("Veli")) # ['Veli'] <- tertemiz!
Burada varsayılan değer None gibi değiştirilemez bir nesne olduğu için paylaşım riski kalmadı; liste yalnızca ihtiyaç anında, fonksiyonun içinde taze taze kuruldu. Aynı desen sözlük ve küme için de geçerlidir: varsayılanı None yap, nesneyi gövdede oluştur.
*args: Değişken Sayıda Pozisyonel Argüman
Kaç argüman geleceğini önceden bilmediğinizde imdadınıza *args yetişir:
def topla(*args):
# args bir demet (tuple); gelen her sayı burada toplanır
toplam = 0
for sayi in args:
toplam += sayi
return toplam
print(topla(1, 2)) # 3
print(topla(1, 2, 3, 4, 5)) # 15
print(topla()) # 0
Tanımdaki yıldız, gelen tüm pozisyonel argümanları bir demete sarıp args değişkenine koydu; for döngüsü o demetin üzerinde döndü. Son çağrıda hiç argüman gelmedi, demet boş kaldı ve döngü hiç çalışmadan toplam 0 döndü. Esneklik buradan geliyor: aynı fonksiyon iki sayıyı da, beş sayıyı da, hiç sayıyı da kabul ediyor.
İsimdeki "args" yalnızca bir gelenek; asıl işi yıldız görüyor. Yine de herkes *args yazdığı için siz de öyle yazın, kodunuz her Python geliştiricisine tanıdık gelsin. Normal parametrelerle karıştırmak da serbest:
def rapor_bas(baslik, *satirlar):
# baslik zorunlu; satirlar değişken sayıda
print(f"== {baslik} ==")
for satir in satirlar:
print(f"- {satir}")
rapor_bas("Günlük Rapor", "Satış: 120", "İade: 3", "Net: 117")
Python ilk argümanı baslik'a bağladı, kalan üçünü satirlar demetine doldurdu. Böylece zorunlu bir değerle birlikte değişken sayıda ek değeri aynı fonksiyonda taşıyabildik. Döngü de her satırı başına tire koyarak yazdırdı.
**kwargs: Değişken Sayıda Anahtarlı Argüman
İki yıldızlı **kwargs ise anahtar=değer çiftlerini yakalar ve size bir sözlük olarak sunar:
def profil(**kwargs):
# kwargs bir sözlük; isimli tüm argümanlar burada
for anahtar, deger in kwargs.items():
print(f"{anahtar}: {deger}")
profil(ad="Zeynep", sehir="İzmir", yas=34)
Python, ad, sehir ve yas çiftlerini anahtar-değer olarak bir sözlüğe koydu ve kwargs'a bağladı. items() ile bu çiftlerin üzerinde döndük. Python 3.7'den beri sözlükler ekleme sırasını koruduğu için çıktı da yazdığımız sırayla geldi.
Gerçek hayattaki kullanım yeri nettir: isteğe bağlı bir sürü ayarı bir fonksiyona geçmek istediğinizde, her birini ayrı ayrı parametre tanımlamak yerine kwargs toplarsınız:
def istek_gonder(url, **ayarlar):
# ayarlar sözlüğü isteğe bağlı tüm seçenekleri taşır
zaman_asimi = ayarlar.get("zaman_asimi", 10) # yoksa 10
yeniden_deneme = ayarlar.get("yeniden_deneme", 3) # yoksa 3
return f"{url} -> {zaman_asimi}s, {yeniden_deneme} deneme"
print(istek_gonder("/api/veri"))
print(istek_gonder("/api/veri", zaman_asimi=30, yeniden_deneme=5))
İlk çağrıda ayarlar boş geldi ve get() metodu varsayılanları kullandı. İkincide iki isimli argüman sözlüğe doldu, get() onları buldu. Çağıran kişi böylece yalnızca değiştirmek istediği ayarları geçer; gerisi sizin varsayılanlarınızla hallolur.
İkisini Birlikte Kullanmak
args ile **kwargs'ı aynı tanımda kullanabilirsiniz. Sıralama sabittir: normal parametreler, ardından args, en sonda **kwargs.
def kayit_tut(tablo, *kayitlar, **secenekler):
# tablo zorunlu; kayitlar demet, secenekler sözlük
print(f"Tablo: {tablo}")
print(f"Kayıtlar: {kayitlar}")
print(f"Seçenekler: {secenekler}")
kayit_tut("kullanicilar", 1, 2, 3, hizli=True, log=True)
Python argümanları üç kümeye ayırdı: ilk değer tablo'ya, kalan pozisyoneller kayitlar demetine, isimliler secenekler sözlüğüne. Bu sıra Python'ın parametre ayrıştırma kurallarının doğal sonucu; bozduğunuz anda sözdizimi hatasıyla karşılaşırsınız.
Yıldızların bir de ayna görüntüsü var: çağırırken açma. Bu, args ve *kwargs'ın ters yönüdür:
def tanit(ad, sehir, yas):
return f"{ad}, {sehir}, {yas}"
veri = ("Kaan", "Bursa", 29)
print(tanit(*veri)) # demeti üç argümana açar
bilgi = {"ad": "Selin", "sehir": "Antalya", "yas": 41}
print(tanit(**bilgi)) # sözlüğü isimli argümanlara açar
İlk örnekte *veri, üç elemanlı demeti fonksiyonun beklediği üç ayrı pozisyonel argümana çevirdi. İkincide **bilgi, sözlük anahtarlarını parametre adlarıyla eşleştirip değerleri onlara bağladı. Bu teknik, veri yapılarından fonksiyonlara esnek geçişin anahtarıdır ve gerçek projelerde sandığınızdan sık kullanılır.
Sık Sorulan Sorular
return olmadan yazdırılan değer neden kullanılamıyor?
Çünkü print yalnızca ekrana görüntü üretir; fonksiyonun çağırana verdiği değeri return belirler. return olmayan fonksiyon sessizce None döndürür ve o None ile hesap yapmaya kalktığınızda TypeError gibi hatalarla karşılaşırsınız.
Varsayılan değer olarak neden liste kullanmamalıyım?
Liste gibi değiştirilebilir nesneler tanım anında bir kez yaratılır ve tüm çağrılar aynı nesneyi paylaşır; veriler çağrılar arasında birikir. Çözüm, varsayılanı None yapıp listeyi fonksiyon gövdesinde yeniden oluşturmaktır.
args ile *kwargs'ı ne zaman tercih etmeliyim?
Argüman sayısı veya isimli seçenekler önceden bilinmediğinde, örneğin genel amaçlı sarmalayıcı fonksiyonlarda. Küçük ve belirli fonksiyonlarda açık parametreler yazmak hem daha okunur hem de daha güvenlidir.
Sırada Ne Var?
return, varsayılan değerler ve yıldızlı parametreler artık cebinizde. Peki bir fonksiyonun içinde tanımladığınız değişkenle dışarıdaki aynı isimli değişkenin ilişkisini hiç merak ettiniz mi? Bir sonraki derste Değişken Kapsamı (Scope) konusunu açıyoruz: local ve global değişkenlerin sınırlarını, UnboundLocalError'ı ve LEGB kuralını orada konuşacağız.







