Python Fonksiyon Tanımlama ve Parametreler
Ders 24'te Veri Yapılarını Doğru Seçmek konusunu işledik; artık veriyi doğru yapıda tutuyorsun. Ama koda bakınca başka bir sorun göze çarpıyor: aynı iş farklı yerlerde tekrar tekrar yazılıyor. Modül 5: Fonksiyonlar ve Kod Organizasyonu tam da bu dağınıklığı bitirmek için açılıyor.
Neden Fonksiyon: Tekrar Eden Kodu Tek Yere Taşımak
Programlamanın en eski kısaltmalarından biri DRY'dır: Don't Repeat Yourself. Kendini tekrar etme. Bu ilke yalnızca satır tasarrufu değildir; bir mantığın sistemde tek bir doğru kopyasının bulunması demektir. İki kopya varsa, hangisinin doğru olduğuna her seferinde yeniden karar vermek zorunda kalırsın. Şu koda bak:
# Aynı KDV hesabı üç yerde tekrarlanmış
fiyat1 = 100
kdv1 = fiyat1 * 0.18 # oran değişirse bu satırı tek tek bulmak gerekir
fiyat2 = 250
kdv2 = fiyat2 * 0.18
fiyat3 = 80
kdv3 = fiyat3 * 0.18
Görünüşte masum. Üç satır, ne olabilir ki? Yarın vergi oranı değiştiğinde kodun her kopyasını tek tek bulup değiştirmen gerekir; birini unutursan raporlar birbirini tutmaz hale gelir. Aynı mantığı fonksiyona taşıyalım:
# Aynı mantık artık tek yerde; oran değişince yalnızca bu satır güncellenir
def kdv_yaz(fiyat):
print(fiyat * 0.18) # vergi oranının tek doğru kopyası
kdv_yaz(100) # 18.0
kdv_yaz(250) # 45.0
kdv_yaz(80) # 14.4
Fonksiyon, çağrıldığı her yerde aynı gövdeyi çalıştırır; oran yarın değişirse düzelteceğin tek satır vardır. Sonucu geri verme işi (return) bir sonraki dersin konusu; şimdilik hesaplanan değeri ekrana yazdırmakla yetiniyoruz.
Acı tecrübemi anlatayım. 2012 yılında bir fatura entegrasyonu yazıyordum; komisyon hesaplama mantığını dört farklı modüle kopyala-yapıştır yapmıştım, toplamda üç yüz satırı aşan tekrar. Aylar sonra oranlar değişti. İlk modüldeki oranı güncelledim, diğer üçünü unuttum. Sonuç: bir ay boyunca modüller farklı oranlarla fatura üretti; farkı muhasebe buldu, ben bir gün boyunca dosyaları karşılaştırdım. O gün öğrendim: tekrar eden kod, er ya da geç birbirinden sapar. Çözüm, mantığı tek yere koymaktır; o yer fonksiyondur.
İyi bir fonksiyon adı da işin yarısıdır. kdv_hesapla, dosya_oku, eposta_gonder gibi adlar içini okumadan ne yaptığını söyler; islem, fonk, x1 gibi adlar hiçbir şey söylemez. Ad bulmakta zorlanıyorsan fonksiyon muhtemelen birden fazla iş yapıyordur; böl onu, adlar kendiliğinden gelir. Bir de okunurluk boyutu var: kdv_yaz(250) satırını okuyan biri ne olduğunu anında bilir, formülü her seferinde zihninde yeniden kurması gerekmez. Fonksiyon, koduna astığın bir tabeladır. Bir bonusu daha var: fonksiyonlar test etmeyi mümkün kılar. Tek parça mantığı ayrı ayrı çağırıp sonucunu kontrol edebilirsin; araya karışmış yüz satırlık bir akış içinde bunu yapamazsın. Kod kalitesi, ölçülebilir hale gelir.
def Sözdizimi ve Çağırma
En sade fonksiyon parametresizdir: selamla(). Parametre eklemek istediğinde parantezin içine isim yazarsın, o kadar; şimdilik parametresiz haliyle başlayalım. Python'da fonksiyon def anahtar kelimesiyle tanımlanır:
def selamla():
print("Merhaba, Python!")
selamla() # Fonksiyon çağrısı: gövdedeki satırlar burada çalışır
Tanım anında hiçbir şey çalışmaz; def satırı fonksiyonu yalnızca belleğe kaydeder. Gövde, selamla() satırı çalıştığında devreye girer. Parantezsiz selamla yazarsan fonksiyonu çağırmaz, sadece ona referans verirsin; bu ayrım, fonksiyonları değişken gibi dolaştıracağın ileriki derslerde işine yarayacak. İstersen bir deneme yap: selamla yazıp Enter'a bas. Python fonksiyonun adresini gösterecek ama hiçbir çıktı üretmeyecek; parantez, "çalıştır" düğmesidir.
Gövde dört boşlukla girintilenir. Girinti süs değildir; hangi satırın fonksiyona ait olduğunu belirleyen tek şeydir. Bir satır eksik girintilenirse o satır sessizce fonksiyonun dışına taşar, üstelik hata bile vermeyebilir. PEP 8'e göre fonksiyon adları küçük harf ve alt çizgiyle yazılır: kullanici_ekle gibi. KullaniciEkle tarzını Python topluluğu sınıf isimlerine saklar; sen şimdilik alt çizgi kuralına bağlı kal.
Bir de sıra kuralı var: fonksiyon, çağrıldığı satır çalışmadan önce tanımlanmış olmalıdır. Python dosyayı yukarıdan aşağı okur; selamla() çağrısı def bloğunun üzerindeyse NameError ile karşılaşırsın. Gelenek, fonksiyonları dosyanın üstüne, ana akışı en alta koymaktır.
Parametre mi, Argüman mı?
İki terim sürekli karıştırılır; oysa ayrım nettir:
- Parametre: Fonksiyon tanımında yazan yer tutucu isim. Bir kalıp, bir değişken adresi.
- Argüman: Çağrı sırasında gönderilen gerçek değer.
def selamla(isim): # "isim" PARAMETRE: tanımda duran yer tutucu
print(f"Merhaba, {isim}!")
selamla("Ada") # "Ada" ARGÜMAN: çağrıda yerine konan gerçek değer
Çağrı anında Python, "Ada" değerini isim parametresine bağlar; gövdedeki isim artık "Ada" demektir. Bu ayrım hata mesajlarını okurken de hızlandırır: mesajda "parameter" geçiyorsa sorun tanımdadır, "argument" geçiyorsa çağrıdadır. Mülakatlarda sık sorulduğu için değil, zihninde net bir model kurduğu için bu ayrımı yerli yerine oturt.
Parametre sayısıyla argüman sayısı da tutmalı. selamla() yazarsan Python "missing 1 required positional argument" diye yakınır; mesajın çevirisi nettir: tanım bir isim bekliyor, çağrı hiçbir değer göndermemiş. Parametreler ayrıca fonksiyonun içinde yerel değişken gibi davranır; dışarıdaki aynı isimli değişkenle karışmazlar.
Pozisyonel ve Anahtarlı Argümanlar
Argümanları iki biçimde gönderebilirsin:
def yolculuk(sehir, gun):
print(f"{gun} gün boyunca {sehir} şehrindeyiz.")
yolculuk("İzmir", 3) # pozisyonel: sıra belirler, "İzmir"->sehir, 3->gun
yolculuk(gun=3, sehir="İzmir") # anahtarlı: isimle eşleşir, sıra önemsiz
yolculuk("İzmir", gun=3) # karışık: önce pozisyonel, sonra anahtarlı yazılır
Pozisyonel çağrıda değerler tanımdaki sıraya göre eşleşir; anahtarlı çağrıda parametre=deger yazarak eşleşmeyi kendin belirlersin. Karışık kullanımda pozisyonel argümanlar önce gelmek zorundadır; yolculuk(sehir="İzmir", 3) yazarsan SyntaxError alırsın. Pratik kuralım şu: bir-iki argüman varsa ve anlam sıradan belliyse pozisyonel yaz; üç ve üzeri argüman ya da belirsiz anlam varsa anahtarlı yaz.
Anahtarlı çağrının bir güzelliği daha var: kodu okuyan, gun=3 ifadesinden değerin ne anlama geldiğini anında görür. Altı parametreli bir fonksiyona üç ay sonra dönen sen, o sıralı sayıların hangisinin ne olduğunu çoktan unutmuş olacaksın; ucret=95, vade=12 ise kendini açıklar. Bu stil açık kaynak kütüphanelerde standarttır; requests ve pandas gibi kütüphanelerin çağrılarında sık sık parametre=deger çiftleri görürsün. Artık gördüğünde yabancılık çekmeyeceksin.
Ve ikinci acı tecrübem. Kariyerimin ilk yılında bir hız hesaplama aracı yazıyordum; mesafe_hiz(km, saat) fonksiyonunu bizzat mesafe_hiz(3, 210) diye çağırdım. Yani üç kilometreyi 210 saatte gidilen bir yolculuk hesaplattım. Sonuç saçma çıktı; iki saat boyunca formülün içinde hata aradım, yan masadaki stajyer arkadaşım bile kodumu satır satır taradı. Formül kusursuzdu. Kusur, argümanları hangi sırayla verdiğimdeydi. Parametre sayısı arttıkça bu tür hatalar çoğalır; anlam belirsizleştiği anda anahtarlı çağrıya geç. mesafe_hiz(km=3, saat=2) hem hatayı engeller hem de kodu okuyanın kafasında soru işareti bırakmaz.
Sıra kuralının ihlali ise daha çalışmadan yakalanır:
yolculuk(sehir="İzmir", 3)
# SyntaxError: positional argument follows keyword argument
Python, anahtarlı argümandan sonra pozisyonel argüman gelmesine izin vermez; hata daha yazım aşamasında patlar. Mesajı okumayı öğren: hatalar seni azarlamaz, sana eşleşme kuralını hatırlatır.
Docstring: Fonksiyona Kısa Not Bırakmak
Fonksiyonun ilk satırına üç tırnaklı bir açıklama koyabilirsin. Buna docstring denir:
def selamla(isim):
"""Verilen isimle ekrana selamlama mesajı yazar.
isim (str): selamlanacak kişinin adı
"""
print(f"Merhaba, {isim}!")
help(selamla) # docstring, belge olarak burada karşına çıkar
Docstring, fonksiyon gövdesindeki ilk ifade olmak zorundadır; help() fonksiyonu ve editörlerin ipucu balonları onu okur. Ne yazacağını bilemezsen üçlüyü yaz: ne yapar, ne alır, ne anlama gelir. Altı ay sonra kendi koduna döndüğünde docstring, o anki niyetini sana fısıldar; "bu fonksiyon neden böyle davranıyor?" sorusunun cevabı koda gömülmüş olur. Dönüş değerleri konusuna bir sonraki derste gireceğiz; şimdilik fonksiyonlarımız sonucu ekrana yazsın, yeter. Docstring tek satır da olabilir, çok satırlı da; önemli olan gövdenin ilk ifadesi olması. Python'un resmi stil rehberi PEP 257, ne yaptığını emir kipiyle yazmayı önerir: "yazar", "hesaplar" gibi. Zamanla kendi kısalığını bulursun.
Örnek: selamla(isim) Uygulaması
Öğrendiklerimizi tek parçada birleştirelim:
def selamla(isim):
"""İsme göre selamlama mesajı yazar."""
print(f"Merhaba, {isim}!")
def karsila():
# Kullanıcıdan isim alır, işi selamla fonksiyonuna devreder
isim = input("Adınız: ")
selamla(isim) # "isim" değişkeni, parametreye argüman olarak gidiyor
karsila()
Burada iki fonksiyon iç içe konuşuyor: karsila veriyi topluyor, selamla sunumu yapıyor. Görev ayrımı budur; her fonksiyon tek bir işin sahibi olur ve kod büyüdüğünde hangi dosyaya bakacağını bilirsin. selamla("Ada") ve selamla(isim="Bora") gibi farklı çağrı biçimlerini de deneyerek pozisyonel ve anahtarlı kullanımı içselleştirebilirsin.
Bu minik programı kendi bilgisayarında çalıştır; input() satırı beklerken adını yaz, selamlama gelsin. Ardından selamla fonksiyonuna ikinci bir parametre eklemeyi dene: soyad. Program bozulmadan nereyi değiştirmen gerektiğini görmek, parametre kavramını bin cümleden iyi öğretir.
Sık Sorulan Sorular
Fonksiyon yazmadan da kod çalışıyor; fonksiyon şart mı?
Küçük betiklerde şart değil. Ama kod yüz satırı geçip aynı mantık üçüncü kez tekrarlandığında, fonksiyonsuz kodu yönetmek imkânsızlaşır. Fonksiyon yalnızca tekrarı azaltmaz; koda isim vererek okunurluğu da artırır.
Parametre adıyla argüman adı aynı olmak zorunda mı?
Hayır. Tanımdaki isim parametresine, çağrı tarafındaki bambaşka bir değişkenin değerini gönderebilirsin; önemli olan değerin doğru parametreye bağlanmasıdır. selamla(kullanici_adi) yazdığında kullanici_adinın değeri fonksiyon içindeki isime kopyalanır; isimler birbirinden bağımsız kalır. Anahtarlı çağrıda da kural aynıdır: selamla(isim="Ada") dediğinde "Ada" değeri isim parametresine bağlanır, dışarıdaki değişken adları bu eşleşmeyi hiç etkilemez.
Bir fonksiyon başka bir fonksiyonun içinde tanımlanabilir mi?
Teknik olarak evet; Python iç içe fonksiyon tanımına izin verir ve bu özellik ileri konularda (closure, decorator) işe yarar. Ama öğrenme aşamasında fonksiyonları dosyanın üst seviyesinde yan yana tanımlamak kodu çok daha okunur tutar. Ayrıca iç içe tanımlanan fonksiyon her çağrıda yeniden oluşturulur; sık çağrılan kodda gereksiz maliyet demektir.
Sırada Ne Var?
Artık kod tekrarını fonksiyona taşıyabiliyor ve ona parametrelerle veri verebiliyorsun. Ama bir eksik var: fonksiyonlarımız sonucu yalnızca ekrana yazıyor, geri vermiyor. Hesaplanan değeri başka yerde kullanmak için return devreye girmeli. Bir sonraki derste Return, Varsayılan Değerler, *args ve kwargs** konusunu işleyeceğiz; fonksiyonların asıl gücü orada ortaya çıkacak.







