Giriş

Python'da fonksiyonlar, tekrar kullanılabilir kod blokları oluşturmanızı sağlar. Bu yazıda fonksiyon tanımı, konumsal ve anahtar kelime parametreleri, varsayılan değerler, *args/**kwargs, dönüş değerleri ve lambda ifadeleri gibi temel konuları pratik örneklerle ele alacağız. Örnekler hem yeni başlayanlara hem de temel uygulama bilgisi olanlara yönelik olup resmi belgeye dayanan açıklamalar ve kullanışlı ipuçları içerir.

Fonksiyon Tanımı: def ve temel sözdizimi

Python'da fonksiyon tanımlamak için def anahtar kelimesi kullanılır. Resmi Python belgelerinde fonksiyon tanımlarının sözdizimi ve kapsamı anlatılmıştır; örneğin tanım ve bileşik ifadelerle ilgili bölüm şu kaynağa bakılabilir: Python resmi dokümantasyonu — Compound statements (def ile ilgili kısım).

Basit bir örnek:

def selamla(isim):
return f"Merhaba, {isim}!"

print(selamla("Ali")) # Merhaba, Ali!

Bu örnekte selamla fonksiyonu bir parametre alır ve return ifadesiyle bir değer döndürür. Eğer bir fonksiyon return ifadesi içermezse, çağrıldığında None döner; bu davranış da Python belgelerinde yer almaktadır.

Parametre Türleri ve Geçiş Yöntemleri

Fonksiyonlara argüman geçişi birkaç şekilde yapılabilir. Temel tipler şunlardır:

• Konumsal (positional) argümanlar: Parametrelerin sırasına göre verilir.
• Anahtar kelime (keyword) argümanlar: Parametre adı belirtilerek verilir; böylece sıra önemi ortadan kalkar.
• Varsayılan (default) parametreler: Fonksiyon tanımında bir parametreye başlangıç değeri atanabilir; çağırırken bu değer atlanabilir.
• *args / **kwargs: Değişken sayıda konumsal veya anahtar kelime argümanı almak için kullanılır.

Konumsal ve Anahtar Kelime Örneği

def carp(a, b):
return a * b

print(carp(2, 3)) # konumsal: 6
print(carp(b=3, a=2)) # anahtar kelime: 6

Anahtar kelime argümanları, özellikle parametre sayısı arttığında kodun okunabilirliğini artırır.

Varsayılan Parametreler

Varsayılan değerler fonksiyon tanımında verilir ve çağırırken bu parametre atlanırsa varsayılan değer kullanılır:

def selamla(isim, mesaj="Merhaba"):
return f"{mesaj}, {isim}!"

print(selamla("Ayşe")) # Merhaba, Ayşe!
print(selamla("Mehmet", mesaj="Selam")) # Selam, Mehmet!

Ancak burada dikkat edilmesi gereken bir nokta vardır: mutable (değiştirilebilir) tiplerle varsayılan değer kullanımı istenmeyen sonuçlara yol açabilir. Örneğin:

def ekle(x, lst=[]):
lst.append(x)
return lst

print(ekle(1)) # [1]
print(ekle(2)) # [1, 2] — önceki çağrıdan kalan listeyi kullanır

Bu davranışın nedeni, varsayılan değerin fonksiyon tanımlandığında oluşturulması ve tüm çağrılarda aynı nesnenin paylaşılmasıdır. Bu durumu önlemek için yaygın çözüm şu şekildedir:

def ekle(x, lst=None):
if lst is None:
lst = []
lst.append(x)
return lst

Bu kalıp, fonksiyonun her çağrısında yeni bir liste oluşturulmasını sağlar. Mutability konusunda resmi türler belgesi ek bilgi için yararlıdır: Gömülü türler (stdtypes).

*args ve **kwargs

Fonksiyonların esnek argüman alması gerektiğinde *args konumsal, **kwargs ise anahtar kelime argümanlarını toplamak için kullanılır:

def ortalama(*sayılar):
return sum(sayılar) / len(sayılar) if sayılar else 0

print(ortalama(2, 4, 6)) # 4.0

def yazdir(**bilgiler):
for k, v in bilgiler.items():
print(k, v)

yazdir(ad="Ayşe", yas=30)

Bu kavramlar, fonksiyonların değişken sayıda veri ile çalışmasını kolaylaştırır.

Dönüş Değerleri

Bir fonksiyon tek bir değer döndürebilir; fakat Python'da birden fazla değer döndürmek istediğinizde genellikle bir tuple döndürürsünüz ve çağıran taraf bunu unpack edebilir.

def istatistik(nums):
return min(nums), max(nums), sum(nums)/len(nums)

mini, maxi, ort = istatistik([1, 2, 3, 4, 5])
print(mini, maxi, ort) # 1 5 3.0

Fonksiyon içinde açıkça return kullanılmadığında, fonksiyon None döndürür. Bu davranış resmi belgelerde belirtilir ve fonksiyon tasarımında açık dönüşler kullanmak kodun anlaşılmasını kolaylaştırır.

Lambda İfadeleri (Anonim Fonksiyonlar)

Lambda ifadeleri tek satırlık anonim fonksiyonlar tanımlamak için kullanılır. Resmi belgelerde lambda ve fonksiyonel kullanımın sözdizimi ile ilgili açıklamalar yer alır; yerel başvuru için Python'un fonksiyonlarla ilgili dokümanlarına göz atabilirsiniz: Gömülü Fonksiyonlar — Python belgeleri.

topla = lambda x, y=1: x + y
print(topla(3)) # 4
print(topla(3, 2)) # 5

Lambda ifadeleri kısa görevler için uygundur (ör. map, filter, sorted ile birlikte). Uzun veya karmaşık işlem yapan fonksiyonlar için normal def kullanmak okunabilirlik açısından genellikle daha iyidir.

İyi Uygulamalar — Hızlı Kontrol Listesi

• Her fonksiyona kısa ama açıklayıcı bir ad verin.
• Fonksiyonlar tek bir sorumluluk yapsın (single responsibility).
• Mutable tipleri varsayılan parametre olarak kullanmayın; None kalıbını tercih edin.
• Gerekli yerlerde tür ipuçları (type hints) ve docstring ekleyin.
• Karmaşık dönüşler için tuple yerine isimlendirilmiş veri yapılarını (örn. dataclass veya dict) değerlendirin.
• Unit test yazın; küçük yardımcı fonksiyonları ayrı test edin.

Küçük Uygulama Örneği: Basit Rapor Fonksiyonu

Aşağıda bir listenin özetini döndüren küçük bir fonksiyon örneği vardır. Hem zorunlu hem de opsiyonel parametreleri gösterir:

def ozet(numbers, round_digits=2, include_count=True):
"""numbers: sayılar listesi. round_digits: yuvarlama hassasiyeti."""
if not numbers:
return None
hasil = {
'min': min(numbers),
'max': max(numbers),
'avg': round(sum(numbers)/len(numbers), round_digits)
}
if include_count:
hasil['count'] = len(numbers)
return hasil

print(ozet([1, 2, 3, 4, 5]))

Bu örnek hem dönüş olarak dict kullanımı hem de opsiyonel parametre yönetimini gösterir.

Kaynaklar ve İleri Okuma

• Compound statements — Python resmi dokümantasyonu (def ve function statement açıklamaları).
• Gömülü Fonksiyonlar — Python kütüphane dokümantasyonu (lambda ve yerleşik fonksiyonlar hakkında bilgi).
• Gömülü Türler — stdtypes (liste, tuple, dict gibi tiplerin davranışları hakkında referans).

Sık Sorulan Sorular (SSS)

Fonksiyonlar nasıl test edilmelidir?

Her fonksiyon için küçük birim testleri yazın. pytest veya unittest kullanarak giriş-çıkış örneklerini otomatik testlere dönüştürün. Edge-case (boş liste, None, hata durumları) senaryolarını da test edin.

Mutable varsayılan parametre neden sorun yaratıyor?

Çünkü varsayılan değer fonksiyon tanımlanırken bir kez oluşturulur ve tüm çağrılarda paylaşılır; bu da beklenmeyen veri birikimine yol açabilir. Çözüm olarak varsayılan None kullanıp içte yeni bir liste/dict oluşturmak güvenlidir.

Lambda mı, def mi tercih etmeliyim?

Kısa, tek ifadeli fonksiyonlar için lambda uygundur; ancak fonksiyon karmaşıklaştığında veya docstring/type hint gerektiğinde def tercih edin.

Bir fonksiyondan birden fazla değer döndürebilir miyim?

Evet. Python'da bir kaç değeri virgülle ayırarak döndürebilirsiniz; çağıran taraf bunları tuple olarak alır ve isterseniz unpack edebilirsiniz.