Fonksiyon tasarımı ve doğrulama

Fonksiyon yazarken def satırını doğru yazmak yetmez. Fonksiyonun hangi girdileri beklediğini, hangi sonucu döndürdüğünü ve yanlış kullanıldığında ne olacağını da düşünmek gerekir.

Bu hafta her fonksiyon için ne alacağını ve ne döndüreceğini baştan yazacağız. Yerel ve küresel kapsamı, varsayılan parametreleri göreceğiz. Beklenen sonucu assert ile kontrol etmeyi ve sınır değerlerini atlamadan denemeyi öğreneceğiz. Son olarak kendini çağıran fonksiyonları, yani özyinelemeyi göreceğiz.

Bu sayfadaki kod hücreleri kendiliğinden çalışmaz. Her hücrede önce çıktıyı tahmin edin, sonra Run Code düğmesine basın. Kodu değiştirip yeniden çalıştırabilir, Start Over ile ilk hâline döndürebilirsiniz.

Bu bölümün kapsamı

NotSınavda sorulur
  • Fonksiyon sözleşmesi ve ön koşullar
  • Yerel değişkenin kapsamı ve dış bağımlılığı parametreye çevirme
  • Varsayılan parametrenin davranışı ve anahtar kelime argümanı
  • assert ile beklenen davranışı doğrulama
  • float sonuçlarda tam eşitlik yerine toleranslı karşılaştırma
  • Sınır ve uç durumların seçilerek sınanması
  • Saf fonksiyonun özellikleri ve global kullanırken neden temkinli olunduğu
  • Özyinelemeli fonksiyon: temel durum, özyinelemeli adım, çağrıların izlenmesi ve RecursionError
  • unittest ve pytest gibi test çerçeveleri
  • Tip ipuçları (type hints)
  • Çağrı yığınının (call stack) iç yapısı ve Python’ın özyineleme sınırının değeri

Bu başlıklar konunun devamıdır. İleride karşınıza çıkar, ama bu derste ezberlemeniz beklenmiyor.

Fonksiyon sözleşmesi

Bir fonksiyonu kullanacak kişinin gövdeyi okumadan üç şeyi bilmesi gerekir: fonksiyon ne alıyor, ne yapıyor ve ne döndürüyor. Bu üç bilginin yazılı hâline fonksiyonun sözleşmesi denir. Aşağıdaki fonksiyon bahşişsiz hesabı kişi sayısına bölüyor. Sözleşmesi şöyle yazılabilir:

Girdi:
- hesap: 0 ya da daha büyük sayı
- kisi: 0'dan büyük tam sayı

Davranış:
- hesap değerini kisi değerine böler

Dönüş değeri:
- kişi başına düşen pay

Sözleşmede “çıktı” yerine “dönüş değeri” yazdık, çünkü fonksiyon payı ekrana yazmıyor, return ile döndürüyor.

Hücre ne yazar? Sonra kisi_basi(400, 4) çağrısındaki 4’ü 0 yapıp yeniden çalıştırın.

Sözleşmedeki “kisi 0’dan büyük olmalı” şartı bir ön koşuldur, yani fonksiyon çağrılmadan önce girdinin sağlaması gereken bir şart. kisi 0 olursa bölme yapılamaz ve Python ZeroDivisionError hatası verir.

Not

Sözleşmeyi Python çalıştırmaz. Fonksiyonu yazan ve kullanan kişi için tutulan bir nottur: fonksiyon ne bekler, ne döndürür.

Python ön koşulu denetlemez

Ön koşulun sağlanmaması her zaman hata vermez. kisi_basi(400, -4) çağrısı hata vermeden -100.0 döndürür. Kişi sayısı eksi olamaz, ama Python bunu bilmez.

Aşağıdaki yüzde hesabında da oran 3 iken hücre hata verir mi?

Fonksiyon oran = 3 ile de hata vermeden çalışır ve 600 döndürür. Oran 0 ile 1 arasında olmalıysa bunu sözleşmeye ön koşul olarak yazarız:

Ön koşul:
- 0 <= oran <= 1

Dönüş değeri:
- tutar * oran

Ön koşulu ve dönüş değerini yazdığınızda fonksiyonu hangi girdilerle deneyeceğiniz de belli olur. Bu denemelere birazdan test diyeceğiz.

Kapsam (scope): yerel ve küresel ad

6. haftada fonksiyonun içinde oluşturulan değişkene yerel değişken dedik. Bir adın kullanılabildiği kod bölgesine kapsam (scope) denir. Şimdi dışarıdaki kod yerel değişkeni kullanmaya çalışırsa ne olacağını deneyelim.

Hücre ne yazar? Sonra son satırın başındaki # işaretini silip yeniden çalıştırın. Ne olur?

sonuc, fonksiyonun içinde oluşturulan yerel (local) bir değişkendir. Fonksiyonun dışındaki kod bu yerel adı kullanamaz. Python NameError verir, çünkü dışarıda sonuc diye bir ad hiç tanımlanmadı. Değer dışarıya yalnız return ile çıkar.

cevre_hesapla(5) çağrısının içinde kenar 5, sonuc 20 olur. return 20 değeri dışarıdaki print satırına gider. Çağrı bitince kenar ve sonuc kalmaz, dışarıdaki print(sonuc) satırı NameError verir.

Yerel kapsam

Fonksiyon dışında oluşturulan bir ad ise küresel (global) kapsamdadır ve fonksiyonun içinden okunabilir. Aşağıdaki hücrede kdv_hesapla(100) iki kez çağrılıyor. İki satır aynı mı yazar?

İlk çağrıda dışarıdaki oran 0.20’dir ve fonksiyon 20.0 döndürür. Sonra oran 0.10 yapılır. Aynı kdv_hesapla(100) çağrısı bu kez 10.0 döndürür. Fonksiyonun sonucu yalnız argümanına değil, dışarıdaki bir değişkene de bağlıdır.

Kod çalışır, fonksiyon dışarıdaki oran değerini okuyabilir. Ama fonksiyonun sonucunu anlamak için artık yalnızca parametrelerine değil, dışarıdaki bir değere de bakmamız gerekir. Aynı çağrı programın neresinde yapıldığına göre farklı sonuç verebilir.

Çoğu hesaplamada oran gibi dışarıdan gelen bir değeri parametreyle vermeyi tercih ederiz:

Bu sürümde fonksiyonun hangi bilgiye ihtiyaç duyduğu imzasından, yani def satırından okunur.

Aynı ad fonksiyonun içinde ve dışında kullanılabilir. Aşağıda parametrenin adı dışarıdaki değişkenle aynı. İki satır ne yazar?

Önce 20, sonra 10 yazılır. Fonksiyonun içindeki sayi parametredir, yani yerel bir ad. Çağrıda bu parametre dışarıdaki değeri, yani 10’u alır. İçerideki atama yalnız yerel sayi’yi 20 yapar, dışarıdaki sayi 10 kalır.

Önemli

Aynı adı taşıyan iki değişkenin aynı değişken olduğunu varsaymayın. Adın nerede oluşturulduğuna bakın: fonksiyonun içinde atanan ad ve parametreler yereldir.

Varsayılan parametreler

Bazen bir parametre çoğu çağrıda aynı değeri alır. Böyle bir parametreye tanımda varsayılan değer (default value) verebiliriz. Aşağıdaki fonksiyonda oran verilmezse 0.10 kullanılır. İki satır ne yazar?

İkinci argüman verilmezse varsayılan değer kullanılır. Çağrıda verilen argüman varsayılanın yerine geçer.

Varsayılan değer sözleşmeye de yazılır:

fiyat: indirim uygulanacak tutar
oran: indirim oranı, verilmezse 0.10
Not

Varsayılan değeri olan parametreler sona yazılır. def f(a, b=1): ... geçerlidir, def f(a=1, b): ... ise SyntaxError verir.

Argümanı parametrenin adıyla da verebilirsiniz: indirimli_fiyat(1000, oran=0.25). Buna anahtar kelime argümanı (keyword argument) denir. Şimdiye kadar kullandığımız, sırasına göre parametreye giden argümanlara da konumsal argüman (positional argument) denir. Adıyla verilen argümanda hangi değerin hangi parametreye gittiği çağrıdan okunur. Zorunlu parametreyi yine de vermeniz gerekir. Hücredeki iki satır ne yazar?

İlk satır 750.0 yazar: 1000 sırasıyla fiyat’a, 0.25 adıyla oran’a gider. İkinci satır TypeError verir, çünkü zorunlu fiyat parametresine değer verilmedi.

Varsayılan değeri, çağrıların çoğunda gerçekten o değer kullanılıyorsa verin. Değeri her çağrıda değişebilecek bir parametreye varsayılan vermeyin. Örneğin KDV oranı ürüne göre değişiyorsa çağıran onu her seferinde açıkça yazsın.

assert ile beklentiyi kontrol etmek

assert, doğru olmasını beklediğimiz bir koşulu kontrol eder. Bu hücre ekrana bir şey yazar mı? Sonra 5’i 6 yapıp yeniden çalıştırın.

Koşul True ise program hiçbir şey yazmadan devam eder. Koşul False ise program AssertionError hatasıyla durur.

Bir fonksiyonu seçilmiş girdilerle çalıştırıp sonucu önceden yazılmış beklenen değerle karşılaştırmaya test denir. assert ile küçük testler yazabiliriz:

Bu üç kontrol pozitif sayıyı, sıfırı ve negatif sayıyı ayrı ayrı dener.

assert fonksiyonun döndürdüğü değere bakar, ekranda görünen yazıya bakmaz. Aşağıdaki fonksiyon da kareyi hesaplıyor. Ekranda 9 görünür mü? assert geçer mi?

Önce ekrana 9 yazılır, sonra program AssertionError ile durur. Fonksiyonda return olmadığı için kare(3) çağrısı None döndürür ve None == 9 yanlıştır. Ekranda görünen 9, assert satırına ulaşmaz.

Önemli

Kullanıcının yanlış girdiği değerleri assert ile yakalamaya çalışmayın. Python -O seçeneğiyle çalıştırılınca assert satırları hiç çalışmaz, yani böyle bir denetim kendiliğinden kalkabilir. Burada assert’ü, programcı olarak “bu koşul doğru olmalı” dediğiniz yerleri denetlemek için kullanıyoruz. Program çalışırken geçersiz bir durumu bildirmek için istisna yükseltmeyi (raise) 13. haftada göreceğiz.

float sonuçlarını toleransla karşılaştırın

2. haftada bazı ondalık sayıların float olarak tam değil yaklaşık tutulduğunu görmüştük. İki satır ne yazar?

0.1 + 0.2 işleminin sonucu 0.30000000000000004 olur. Bu değer 0.3’e çok yakındır ama bellekte 0.3 ile aynı biçimde tutulmaz. Bu yüzden == karşılaştırması False verir ve assert 0.1 + 0.2 == 0.3 satırı başarısız olur.

Hesapta küçük bir fark kabul edilebiliyorsa sonuç ile beklenen değer arasındaki farkın, kabul ettiğimiz küçük bir sınırdan (tolerans) az olup olmadığına bakarız. abs() bir sayının mutlak değerini, yani işaretsiz büyüklüğünü döndürür:

abs() unutulursa denetim yanlış sonucu da geçirir. Sonuç 80, beklenen 100 olsun: 80 - 100 işlemi -20 verir ve -20 < 0.000001 doğrudur. Oysa iki değer birbirine hiç yakın değil. abs() farkın işaretini atar. Böylece yalnız farkın büyüklüğünü karşılaştırırız.

Örneğin parayla çalışırken bir kuruştan küçük farkları önemsemiyorsak toleransı 0.01 seçebiliriz:

assert abs(sonuc - beklenen) < 0.01
Uyarı

Tolerans için “her zaman 0.01 kullanın” gibi bir kural yok. Ne kadar farkın kabul edilebileceğine problemin kendisi karar verir. Sonucu ekranda kısaltarak göstermek de bellekteki değeri değiştirmez.

Tahmin et: hangi assert başarısız olur?

Aşağıdaki kodda hangi satır hata verir? Önce tahmin edin, sonra çalıştırın.

Şimdi return -sayi satırını return sayi yapın. Çalıştırmadan önce düşünün: hangi assert başarısız olur, hangileri yine geçer?

İlk sürümde üç kontrol de geçer ve son satır yazdırılır. Değişiklikten sonra yalnız ikinci kontrol başarısız olur: mutlak_deger(-3) artık -3 döndürür. 5 ve 0 kontrolleri yine geçer, çünkü bu girdilerde if gövdesi hiç çalışmaz. Hatayı yalnız negatif sayıyı deneyen test yakalar.

Sınır değerlerini fonksiyonlarda kullanmak

Koşul içeren fonksiyonlarda en çok sınır değerlerini, yani kararın değiştiği değerleri denemek gerekir.

Bir ücretsiz kargo fonksiyonu düşünelim. 100 ve 1000 gibi sınırdan uzak değerleri denemek yetmez. Sınırın hemen altını, kendisini ve hemen üstünü deneyin. Hücredeki üç kontrol geçer mi?

Karar tam 500 değerinde değişir. >= yerine > yazılsaydı yalnız ortadaki kontrol başarısız olurdu.

Alıştırma: sınır testini düzeltin

Aşağıdaki fonksiyonda geçme sınırı 60 olmalıdır. Şu anki kod sınır değerinde yanlış sonuç veriyor.

Fonksiyonu üç assert de geçecek biçimde düzeltin.

> yerine >= kullanmayı düşünün.

def gecti_mi(puan):
    return puan >= 60

assert gecti_mi(59) == False
assert gecti_mi(60) == True
assert gecti_mi(61) == True

print("Kontroller tamamlandı")

Tek test yalnız bir durumu sınar

Aşağıdaki fonksiyon 1000 TL ve üstündeki fiyatlara yüzde 10 indirim uygulamalı. Yazan kişi if satırını unutmuş, ama tek test bunu göstermiyor. Bu test geçer mi?

Bu test yalnız 1500 TL’lik fiyatı sınar. Fonksiyonun 1000’in altındaki ve tam 1000’deki davranışı hakkında bir şey söylemez.

Daha iyi bir test kümesi dört farklı durumu dener. Hangi assert başarısız olur?

Bu dört kontrol sırasıyla şunları dener:

  • Sıradan bir fiyat (500)
  • Sınırın hemen altı (999)
  • Sınırın kendisi (1000)
  • Sınırın üstü (1500)

İlk kontrol AssertionError verir: indirim(500) 450.0 döndürür, oysa 1000’in altındaki fiyata indirim yapılmamalı. Program ilk başarısız assert’te durduğu için alttaki satırlar çalışmaz. 999 de aynı nedenle başarısız olurdu.

Fonksiyonu if fiyat >= 1000: koşuluyla düzeltip yeniden çalıştırın. Dört test de geçmeli. Bu fiyatlarda çarpım tam çıktığı için == yetiyor. Sonucun tam çıkacağından emin olmadığınız hesapta toleransla karşılaştırın.

Uç durum (edge case)

Kararın değiştiği sayısal eşikler dışında da dikkat isteyen girdiler vardır. Fonksiyonun sıradan girdilerden farklı davranabileceği özel girdilere uç durum (edge case) denir.

len() bir metnin kaç karakterden oluştuğunu döndürür: len("Python") 6’dır, boş metin "" için len("") 0’dır. Aşağıdaki fonksiyon bir metindeki sesli harf sayısını metnin uzunluğuna bölüyor. İki satır da yazılır mı?

İlk satır 0.16666666666666666 yazar. İkinci çağrı ZeroDivisionError verir: boş metnin uzunluğu 0 olduğu için bölme yapılamaz. Sıradan girdide çalışan fonksiyon boş metinde bozuluyor. Bu yüzden boş metin bu fonksiyon için bir uç durumdur ve ayrıca denenir.

Bir liste fonksiyonunda boş liste, bir dosya işleminde boş dosya ya da bir arama probleminde hiç eşleşme bulunmaması da uç durum olabilir. Hesap paylaştıran bir fonksiyon için tek kişilik masa da bir uç durumdur.

Saf fonksiyon fikri

Aşağıdaki fonksiyon yalnızca argümanlarını kullanır ve bir değer döndürür:

Aynı argümanlarla çağrıldığında aynı sonucu verir. Dışarıdaki bir değeri değiştirmez, ekrana da bir şey yazmaz. Bu tür fonksiyonlara saf fonksiyon (pure function) denir. Saf fonksiyonları test etmek kolaydır: sonucu yalnız argümanlar belirler.

Şimdi şu fonksiyona bakın. ekle(5) iki kez çağrılıyor. Son satır ne yazar?

Bu fonksiyon dışarıdaki toplam değişkenini değiştirir. Fonksiyon değer döndürmenin yanında dışarıdaki bir şeyi değiştiriyorsa buna yan etki (side effect) denir. ekle(5) her çağrıda aynı işi yapar, ama toplam her çağrıda değişir: önce 5, sonra 10 olur. Ekrana yazmak da bir yan etkidir. İçinde print() olan fonksiyon bu yüzden saf sayılmaz.

global toplam satırı olmasaydı Python, fonksiyonun içinde atanan toplam adını yerel sayardı. Sağ taraftaki toplam o anda henüz değer almamış olacağı için de UnboundLocalError hatası verirdi. Hücrede global toplam satırını silip çalıştırarak bunu görebilirsiniz. global toplam satırı sayesinde atama dışarıdaki küresel toplam değişkenini değiştirir. Bu örnekte global’i önermek için değil, yan etkiyi göstermek için kullandık.

Uyarı

Hesaplama yapan fonksiyonlarda global’i ilk çözüm olarak kullanmayacağız. Fonksiyon bir bilgiye ihtiyaç duyuyorsa onu parametreyle alsın, bir sonuç hesaplıyorsa return ile döndürsün. Böylece fonksiyonun neye bağlı olduğu def satırından okunur ve fonksiyonu test etmek kolaylaşır.

Her fonksiyonu saf yazmak zorunda değiliz. Bu kural hesaplama yapan fonksiyonlar içindir.

İpucu

Bir fonksiyonun davranışını anlamak için programın başka yerlerindeki değişkenleri takip etmek zorunda kalıyorsanız fonksiyon dışarıdaki değişkenlere gereğinden fazla bağlı olabilir.

Alıştırma: saf hesaplama fonksiyonu

Aşağıdaki fonksiyon, kilometre cinsinden mesafeyi metreye çevirmelidir.

Fonksiyonu tamamlayın.

return km * 1000 yeterlidir.

def metreye_cevir(km):
    return km * 1000

assert metreye_cevir(1) == 1000
assert metreye_cevir(0) == 0
assert metreye_cevir(2.5) == 2500

print("Kontroller tamamlandı")

Hesaplamayı ekrana yazmaktan ayırmak

Aşağıdaki fonksiyon birbirinden farklı işleri bir arada yapıyor. Hücre kaç satır yazar?

Kod çalışır, ama hesaplama ile ekrana yazma iç içe geçmiştir. Fonksiyon None döndürür, kargo tutarı yalnız ekranda görünür. Bu yüzden kargo hesabını assert ile doğrudan sınayamazsınız.

Bunu daha küçük parçalara ayırabiliriz. Programın geri kalanı bu fonksiyonları çağırır:

Bu tasarımda iki hesaplamayı ayrı ayrı doğrulayabiliriz.

İncele ve düzelt: yanlış formül

Aşağıdaki fonksiyonun Celsius sıcaklığını Fahrenheit’a çevirmesi gerekiyor. Düzeltmeden önce çalıştırın: hangi assert önce başarısız olur?

Formülde eksik olan kısmı bulun ve düzeltin.

Formül: celsius * 9 / 5 + 32.

def fahrenheit(celsius):
    return celsius * 9 / 5 + 32

assert fahrenheit(0) == 32
assert fahrenheit(100) == 212

Kendini çağıran fonksiyon: özyineleme

Fonksiyonların gövdesinde print() ya da abs() gibi başka fonksiyonları çağırdık. Bir fonksiyon kendi gövdesinde kendini de çağırabilir. Buna özyineleme (recursion), kendini çağıran fonksiyona da özyinelemeli fonksiyon (recursive function) denir. Özyinelemeli fonksiyon bir problemi, aynı problemin daha küçük bir hâline indirger.

1’den 4’e kadar olan sayıların toplamını düşünün. 1’den 3’e kadar olanların toplamını biliyorsak ona 4 eklemek yeter. 1’den 3’e kadar olanların toplamı da 1’den 2’ye kadar olanların toplamına 3 eklenerek bulunur. Sayı her adımda bir küçülür. Toplanacak sayı kalmayınca toplam 0’dır. Aşağıdaki fonksiyon bu fikri Python’a çeviriyor. Hücre ne yazar?

Özyinelemeli bir fonksiyonun iki parçası vardır:

  • Temel durum (base case): Fonksiyonun kendini çağırmadan sonucu döndürdüğü durum. Burada n == 0 iken fonksiyon 0 döndürür.
  • Özyinelemeli adım (recursive step): Fonksiyonun kendini daha küçük bir argümanla çağırdığı satır. Bu fonksiyonda özyinelemeli adım return n + sayilari_topla(n - 1) satırıdır.

Her çağrıda n bir azalır ve sonunda 0 olur. Özyinelemeli adım, her çağrıda temel duruma biraz daha yaklaşmalıdır. Yaklaşmazsa ne olacağını birazdan göreceğiz.

Çağrıları izlemek

4. haftada döngüyü kod izleme tablosuyla izledik. Özyinelemeli fonksiyonu da bir tabloyla izleyebiliriz. Bu kez her satır bir çağrıdır. sayilari_topla(3) çağrısında temel duruma gelene kadar hiçbir çağrı bitmez, her çağrı bir sonrakinin sonucunu bekler. Tablonun boş hücrelerini doldurun.

Çağrı n Temel durum mu? Beklediği çağrı Döndürdüğü değer
sayilari_topla(3) 3 Hayır sayilari_topla(2) ?
sayilari_topla(2) 2 Hayır ? ?
sayilari_topla(1) ? ? ? ?
sayilari_topla(0) 0 Evet Yok 0
Çağrı n Temel durum mu? Beklediği çağrı Döndürdüğü değer
sayilari_topla(3) 3 Hayır sayilari_topla(2) 3 + 3 = 6
sayilari_topla(2) 2 Hayır sayilari_topla(1) 2 + 1 = 3
sayilari_topla(1) 1 Hayır sayilari_topla(0) 1 + 0 = 1
sayilari_topla(0) 0 Evet Yok 0

İlk dört sütun yukarıdan aşağı dolar, son sütun aşağıdan yukarı. Önce sayilari_topla(0) biter ve 0 döndürür. Onu bekleyen sayilari_topla(1) bu değere 1 ekler ve 1 döndürür. En son ilk çağrı biter: 3 + 3 = 6.

Çağrıların hangi sırayla başlayıp bittiğini ekrana yazdırarak da görebiliriz. Aşağıdaki sürüm her çağrının başında ve sonunda bir satır yazar. Başladı satırlarında n hangi sırayla görünür? Bitti satırlarında hangi sırayla?

Önce dört Başladı satırı görünür: 3, 2, 1, 0. sayilari_topla(3) Başladı: 3 yazar, sonra sayilari_topla(2) çağrısını yapar ve onun bitmesini bekler. Bu böyle 0’a kadar sürer. Bitti satırları ters sırayla gelir: 0 (sonuç 0), 1 (sonuç 1), 2 (sonuç 3), 3 (sonuç 6). Son satırda 6 yazar.

Her çağrının kendi yerel n değişkeni vardır. sayilari_topla(1) çalışırken onun n’i 1’dir, bekleyen sayilari_topla(3) çağrısının n’i ise hâlâ 3’tür. Kapsam başlığında gördüğünüz gibi yerel değişken yalnız kendi çağrısının içinde geçerlidir. Python bekleyen çağrıları üst üste koyar ve en son başlayan çağrıyı ilk bitirir. Üst üste konmuş tabaklarda da önce en üstteki alınır. Bitmeyi bekleyen çağrıların tutulduğu bu yapıya çağrı yığını (call stack) denir.

sayilari_topla(3) çağrısı 2, 1 ve 0 çağrılarını sırayla yapar ve bekler. Her çağrının kendi n değeri vardır. Temel durum olan 0 çağrısı 0 döndürür, değerler aşağıdan yukarı 0, 1, 3 ve 6 olarak döner.

Çağrı yığını

Her return yalnız bulunduğu çağrıyı bitirir. sayilari_topla(0) 0 döndürünce bütün çağrılar bitmez, yalnız o çağrı biter. Onu bekleyen çağrı bu değeri kullanır ve kendi sonucunu kendi return satırıyla döndürür. Aşağıdaki sürümde özyinelemeli adımın başındaki return unutulmuş. Hücre ne yazar?

Program TypeError ile durur. sayilari_topla(1) toplamı hesaplar ama döndürmez. 6. haftada gördüğümüz gibi return satırına ulaşmayan fonksiyon None döndürür. Onu bekleyen sayilari_topla(2) bu kez 2 + None hesaplamaya çalışır, sayıyla None toplanamaz. Özyinelemeli adımın başına return yazılınca hücre 6 yazar.

Temel duruma hiç gelinmezse

Fonksiyondan temel durumu silelim. Hücre ne yazar?

Ekrana bir sayı yazılmaz, program hatayla durur. Fonksiyon kendini 3, 2, 1, 0, -1, -2 diye durmadan çağırır ve hiçbir çağrı bitmez. Python bekleyen çağrıların sayısına bir sınır koyar. Sınır aşılınca hata mesajının son satırı şöyle olur:

RecursionError: maximum recursion depth exceeded

Temel durum yazılmış olsa bile özyinelemeli adım ona yaklaşmıyorsa aynı hata çıkar. Temel durumu olan ilk fonksiyonda sayilari_topla(-1) çağrısı -1, -2, -3 diye 0’dan uzaklaşır ve n == 0 koşulu hiç sağlanmaz. Bu yüzden fonksiyonun sözleşmesine bir ön koşul yazılır: n, 0 ya da daha büyük bir tam sayı olmalı.

Önemli

Özyinelemeli bir fonksiyon yazarken iki şeye bakın: temel durum var mı ve her çağrı ona yaklaşıyor mu? Test yazarken temel durumu da deneyin. sayilari_topla(0) bu fonksiyonun uç durumudur.

Aynı iş döngüyle

Bu toplamı 5. haftada for döngüsü ve biriktiriciyle de yazabilirdik. Aşağıdaki iki assert geçer mi? Son satır ne yazar?

Bu bölümdeki her özyinelemeli fonksiyon döngüyle de yazılabilir. Toplama ve sayma gibi işlerde döngü daha kolay okunur ve bekleyen çağrı sınırına takılmaz: sayilari_topla_dongu(5000) sonucu verir, sayilari_topla(5000) ise RecursionError verir. Özyineleme, klasör içinde klasör aramak gibi kendi içinde aynı yapıyı tekrarlayan işlerde kodu kısaltır.

Alıştırma: faktöriyeli özyinelemeyle yazın

Bir sayının faktöriyeli, 1’den o sayıya kadar bütün tam sayıların çarpımıdır: 4! = 4 × 3 × 2 × 1 = 24. 0! ise 1 kabul edilir. 4!, 4 × 3! diye de yazılabilir. Boşlukları doldurup faktoriyel fonksiyonunu özyinelemeyle tamamlayın. Döngü kullanmayın.

4!, 4 × 3! olduğuna göre faktoriyel(n) de n * faktoriyel(n - 1) olur.

def faktoriyel(n):
    if n == 0:
        return 1
    return n * faktoriyel(n - 1)

assert faktoriyel(0) == 1
assert faktoriyel(1) == 1
assert faktoriyel(4) == 24

print("Kontroller tamamlandı")

Hepsi bir arada: hesabı paylaştırmak

Arkadaş grubunuz yemekten sonra hesabı eşit paylaştırıyor. Tarif şöyle: hesaba yüzde 10 bahşiş ekle, sonucu kişi sayısına böl. Tarif bir telefon uygulamasında fonksiyon olarak çalışacak ve her masada kullanılacak. Bu haftanın konuları tarifte şu işlere karşılık geliyor:

Tarifte Python’da Dikkat
Masada en az bir kişi olmalı Sözleşmede ön koşul: kisi > 0 Python ön koşulu denetlemez. kisi 0 olursa ZeroDivisionError verir, eksi bir sayıysa hata vermeden yanlış pay döndürür
Bahşiş oranı söylenmezse yüzde 10 def kisi_basi_pay(hesap, kisi, bahsis=0.10): Oran fonksiyonun dışındaki bir değişkenden okunursa sonuç o değişkene bağlı kalır. Oranı parametreyle alın
Bahşiş bırakmayan masa kisi_basi_pay(100, 3, 0) ya da kisi_basi_pay(100, 3, bahsis=0) Verilen argüman varsayılanın yerine geçer
Payı denemeden önce yazmak Her masa için bir assert: sıradan masa (400 TL, dört kişi), tek kişilik masa (250 TL) Tek deneme yalnız o masayı sınar. Tek kişilik masa uç durumdur. Sıfır kişilik masaya test yazılmaz, o masa ön koşulun dışında kalır
Kuruşlu pay abs(pay - 33.33) < 0.01 Bahşişsiz 100 TL üç kişiye bölününce pay 33.333... çıkar, kuruşa yuvarlanmış 33.33 ile == tutmaz. Formül hesap * (1 + bahsis) / kisi diye yazılırsa 400 TL’lik dört kişilik masada da float yüzünden 110.00000000000001 çıkar. İki durumda da tolerans gerekir
Fonksiyon payı hesaplar, ekrana yazmaz Pay return ile döner, fonksiyonda print() yok Payı ekrana yazan fonksiyon None döndürür, assert payı göremez

Aşağıdaki şema sözleşmeye bakarak hangi testlerin seçildiğini gösteriyor:

kisi_basi_pay fonksiyonunun sözleşmesi: ön koşul kisi büyüktür 0, dönüş değeri kişi başına pay. Sözleşmeden üç test seçilir: sıradan masa 400 TL dört kişi, tek kişilik masa 250 TL ve kuruşlu pay 100 TL üç kişi bahşişsiz. Sıfır kişilik masa ön koşulun dışında kalır, ona test yazılmaz.

Fonksiyon sözleşmesi ve test

Üret: hesabı paylaştıran fonksiyon

Hesap paylaştırma tarifini fonksiyona çevirin. kisi_basi_pay(hesap, kisi, bahsis) adlı fonksiyon şu kurallara uymalı:

  • bahsis verilmezse 0.10 kullanılmalı.
  • Hesaba bahşiş eklenmeli, sonuç kişi sayısına bölünmeli.
  • Fonksiyon yalnızca hesaplama yapıp sonucu döndürmeli; içinde print() kullanılmamalı.
  • Fonksiyonun üstüne, yorum satırı olarak sözleşmesini ve ön koşulunu yazın.

Başlangıç kodundaki def satırında bahsis parametresi henüz yok. Onu siz ekleyeceksiniz. Testler payı toleransla karşılaştırıyor.

Bahşişli hesap hesap + hesap * bahsis olur. Bunu kisi değerine bölün.

# Girdi: hesap 0 ya da daha büyük sayı, kisi 0'dan büyük tam sayı,
#        bahsis 0 ile 1 arası oran (verilmezse 0.10)
# Dönüş değeri: bahşiş eklenmiş hesabın kişi başına düşen payı
# Ön koşul: kisi > 0
def kisi_basi_pay(hesap, kisi, bahsis=0.10):
    return (hesap + hesap * bahsis) / kisi

assert abs(kisi_basi_pay(400, 4) - 110) < 0.01
assert abs(kisi_basi_pay(400, 4, 0) - 100) < 0.01
assert abs(kisi_basi_pay(250, 1) - 275) < 0.01
assert abs(kisi_basi_pay(100, 3, 0) - 33.33) < 0.01

print("Kontroller tamamlandı")

Doğrulama için küçük bir kontrol listesi

Bir fonksiyonu bitirdiğinizde kendinize şunları sorun:

  • Fonksiyonun tek ve açık bir işi var mı?
  • Parametre adları neyi tuttuğunu söylüyor mu?
  • Varsayılan parametre varsa neden o değerin seçildiği açık mı?
  • Hangi girdilerin geçerli olduğu belli mi?
  • Dönüş değerinin anlamı açık mı?
  • Sıradan bir örnek denendi mi?
  • Sınır değeri denendi mi?
  • Uç durum varsa denendi mi?
  • float sonucu karşılaştırırken tam eşitlik gerçekten uygun mu?
  • Hesaplama fonksiyonu gereksiz print(), global ya da dış değişken kullanıyor mu?
  • Fonksiyon kendini çağırıyorsa temel durum var mı, her çağrı ona yaklaşıyor mu?

Her soru her fonksiyon için aynı ölçüde önemli olmayabilir. Yine de bir hata çıktığında rastgele değer denemek yerine bu listeyi sırayla izleyebilirsiniz.

Sınav provası

Önce kendi cevabınızı seçin, sonra cevap anahtarında her şıkkın neden doğru ya da yanlış olduğunu okuyun. Yanlış şıklar rastgele yazılmadı; bu konuda öğrencilerin gerçekten yaptığı hatalardan seçildi. Sınav soruları da aynı yolla hazırlanır.

1. Bir fonksiyonun sözleşmesi hangi üç bilgiyi yazar?

  • A. Hangi dosyada yer alır, kim yazmıştır ve ne zaman yazılmıştır
  • B. Ne kadar hızlı çalışır, ne kadar bellek kullanır ve kaç kez çağrılır
  • C. Hangi girdileri kabul eder, ne yapar ve ne döndürür
  • D. Hangi hataları verir, hangi sürümde çalışır ve hangi modülü kullanır
  • E. Kaç satır uzunluktadır, hangi döngüyü kullanır ve kaç değişken tanımlar

2. Ön koşul nedir?

  • A. Fonksiyondan önce çalıştırılması gereken başka bir fonksiyondur
  • B. Fonksiyonun kaç parametre alacağını belirleyen kuraldır
  • C. Fonksiyonun ilk satırında yazılması zorunlu bir açıklamadır
  • D. Fonksiyona verilen girdilerin sağlaması gereken şarttır
  • E. Fonksiyonun döndüreceği değerin türüdür

3. Aşağıdaki program neden hata verir?

def hesapla():
    sonuc = 42

hesapla()
print(sonuc)
  • A. sonuc ayrılmış bir sözcüktür, ad olarak kullanılamaz
  • B. sonuc yerel değişkendir, dışarıdan erişilemez
  • C. 42 sayısı bir değişkene atanamaz
  • D. Fonksiyon çağrılmadığı için sonuc hiç oluşmamıştır
  • E. print() fonksiyon dışında kullanılamaz

4. def indirim(fiyat, oran=0.10): tanımında indirim(200) çağrısında oran hangi değeri alır?

  • A. None
  • B. 200
  • C. 0
  • D. Hata verir; iki parametreli fonksiyon tek argümanla çağrılamaz
  • E. 0.10

5. def basarili_mi(puan, sinir=50): tanımında 55 puanı 60 sınırıyla denetlemek için hangisi doğrudur?

  • A. basarili_mi(60)
  • B. Önce sinir = 60 yazıp ardından basarili_mi(55) çağırmak
  • C. basarili_mi(sinir=60)
  • D. basarili_mi(55, 50, 60)
  • E. basarili_mi(55, sinir=60)

6. assert ortalama(60, 80) == 70 satırı ne yapar?

  • A. Fonksiyonun sonucunu ekrana yazar
  • B. Fonksiyonu iki kez çalıştırıp sonuçları karşılaştırır
  • C. Sonuç 70 değilse AssertionError verir
  • D. Yanlış sonuç veren fonksiyonu düzeltir
  • E. Fonksiyonun sonucunu 70 olarak zorlar

7. assert 0.1 + 0.7 == 0.8 satırı neden başarısız olur?

  • A. Python assert içinde toplama yapılmasına izin vermez
  • B. float toplam 0.8’e çok yakın ama ondan farklıdır
  • C. 0.8 bir float değil str olarak yorumlanır
  • D. Toplama işlemi yanlış yazılmıştır
  • E. assert ondalıklı sayılarla çalışmaz

8. Geçme sınırı 50 olan bir fonksiyon için 49, 50 ve 51 neden iyi bir test kümesidir?

  • A. Sınırın hemen altını, kendisini ve hemen üstünü kapsar
  • B. Fonksiyonun en sık göreceği puanlardır
  • C. Ardışık sayılar test sonuçlarını daha güvenilir yapar
  • D. Python sınır değerlerini kendiliğinden özel olarak işler
  • E. Küçük sayılarla test etmek daha hızlıdır

9. Boş metin bazı fonksiyonlarda neden uç durum sayılır?

  • A. Uzunluğu 0’dır, uzunluğa bölen kod hata verir
  • B. Boş metin bellekte hiç yer kaplamaz
  • C. len() boş metinde çalışmaz, uzunluk ölçülemez
  • D. Boş metin hangi işleme girerse girsin hata verir
  • E. Boş metin Python’da None ile aynıdır

10. Saf fonksiyonun iki temel özelliği nedir?

  • A. Sayılarla çalışır ve döngü içermez
  • B. Tek bir return satırından oluşur
  • C. Parametre almaz ve değer döndürmez
  • D. Yan etkisi yoktur, aynı girdiye aynı sonucu verir
  • E. Ekrana yazdırır ve küresel değişkenleri günceller

11. Aşağıdaki program ne yazdırır?

def ikinin_kuvveti(n):
    if n == 0:
        return 1
    return 2 * ikinin_kuvveti(n - 1)

print(ikinin_kuvveti(3))
  • A. RecursionError verir
  • B. 16
  • C. 6
  • D. 8
  • E. 1

1. Doğru: C. Sözleşme, fonksiyonu kullanacak kişinin gövdeyi okumadan bilmesi gereken üç şeydir.

  • A yanlış: “Sözleşme” sözcüğü imza, tarih ve taraf gibi resmî bilgileri çağrıştırır. Ama yazar, dosya ve tarih fonksiyonun ne yaptığını söylemez; sözleşme girdiyi, davranışı ve sonucu anlatır.
  • B yanlış: İyi bir fonksiyonun hızlı da olması beklendiği için bu ölçüler sözleşmeye girecekmiş gibi görünür. Ama hız ve bellek kullanımı başka bir konudur; sözleşme fonksiyonun ne aldığını, ne yaptığını ve ne döndürdüğünü anlatır.
  • D yanlış: Hatalar da fonksiyonun davranışına ait olduğu için bu seçenek eksiksiz görünebilir. Ama sürüm ve modül bilgisi fonksiyonun işini anlatmaz; sözleşmenin üç sorusu girdi, davranış ve sonuçtur.
  • E yanlış: Fonksiyonu anlatırken ilk göze çarpan şey kodun kendisi olduğu için satır, döngü ve değişken sayısı akla gelir. Ama bunlar gövdenin iç ayrıntılarıdır. Fonksiyonu çağıran kişi gövdeyi okumadan da onu kullanabilmelidir.

2. Doğru: D. Fonksiyon ancak bu şart sağlanırsa doğru çalışır. Örneğin hesabı kişi sayısına bölen bir fonksiyonun ön koşulu kişi sayısının 0’dan büyük olmasıdır.

  • A yanlış: “Ön” sözcüğü bir şeyin önce çalıştırılması gerektiğini çağrıştırır. Ama ön koşul başka bir fonksiyon değildir; girdinin taşıması gereken özelliktir, örneğin “kişi sayısı 0’dan büyük”.
  • B yanlış: Fonksiyonu yanlış sayıda argümanla çağırmak da hata verdiği için bu bir ön koşul gibi görünür. Ama parametre sayısı def satırında belirlenir; ön koşul, verilen değerlerin hangi şartı sağlaması gerektiğini söyler.
  • C yanlış: Ön koşul çoğu zaman fonksiyonun hemen üstüne yorum olarak yazıldığı için zorunlu bir açıklama satırı sanılabilir. Ama Python böyle bir satır istemez; ön koşul girdiye konan bir şarttır, nereye yazıldığı değil.
  • E yanlış: Sözleşmede dönüş değeri de yazıldığı için ön koşul onunla karıştırılabilir. Ama dönüş değeri sonuçla ilgilidir; ön koşul fonksiyon çağrılmadan önce girdinin sağlaması gereken şarttır.

3. Doğru: B. sonuc fonksiyonun içinde tanımlandığı için yereldir. Yerel adlar yalnızca kendi fonksiyonlarının içinde yaşar ve fonksiyon bitince yok olur. Değer dışarıya return ile taşınır.

  • A yanlış: Hata bir adla ilgili olduğu için adın kendisinden şüphelenilebilir. Ama sonuc ayrılmış sözcük değildir; hata onun fonksiyon dışında kullanılmasından çıkar.
  • C yanlış: Atama fonksiyonun içinde yapıldığı için orada bir sorun olduğu sanılabilir. Ama atama sorunsuzdur; hata print(sonuc) satırında çıkar.
  • D yanlış: Adın bulunamaması, onu oluşturan kodun hiç çalışmadığı izlenimini verir. Ama fonksiyon hesapla() satırında çağrılıyor; sorun adın kapsamı.
  • E yanlış: Hata print() satırında çıktığı için sorun o fonksiyonda aranabilir. Ama print() her yerde kullanılabilir; bulunamayan ad sonuctur.

4. Doğru: E. Argüman verilmediğinde tanımdaki varsayılan kullanılır.

  • A yanlış: return olmayan fonksiyonun None döndürdüğünü bilen öğrenci, verilmeyen argümanın da None olacağını düşünebilir. Ama parametrenin varsayılanı tanımlıysa None atanmaz; 0.10 kullanılır.
  • B yanlış: Çağrıda tek bir sayı göründüğü için iki parametrenin de o sayıyı alacağı sanılabilir. Ama argümanlar sırayla eşleşir: 200 ilk parametreye, yani fiyata gider.
  • C yanlış: Verilmeyen bir değerin “hiç” yani 0 sayılacağı düşünülebilir. Ama tanımda varsayılan açıkça 0.10 yazılmış; argüman verilmediğinde o kullanılır.
  • D yanlış: Önceki örneklerde her parametreye bir argüman verildiği için eksik argüman hata gibi görünür. Ama varsayılanı olan parametre isteğe bağlıdır; bu çağrı geçerlidir.

5. Doğru: E. Anahtar kelime argümanı değeri parametrenin adıyla verir. Varsayılanın yerine geçer ve hangi parametreyi değiştirdiğinizi çağrıda gösterir.

  • A yanlış: İstenen sayı 60 olduğu için onu tek argüman olarak vermek akla gelir. Ama argümanlar sırayla eşleşir; 60 puan olur, sınır yine 50 kalır.
  • B yanlış: Parametreyle aynı adı taşıyan bir değişken, fonksiyonun içindeki sinir’i değiştirecekmiş gibi görünür. Ama dışarıdaki bu ad ayrı bir değişkendir. Çağrıda sinir verilmediği için varsayılan 50 kullanılır.
  • C yanlış: Yalnız değiştirmek istenen parametreyi yazmak yeterli gibi görünür. Ama puan zorunlu bir parametredir; verilmezse TypeError çıkar.
  • D yanlış: Eski sınırı da yeni sınırı da yazmak açıklayıcı gibi görünür. Ama fonksiyonun iki parametresi var; üçüncü argüman TypeError verir.

6. Doğru: C. assert koşulu sınar. Koşul doğruysa hiçbir şey yapmadan geçer; yanlışsa AssertionError vererek programı durdurur. Beklenen davranışı hızlıca sınamak için kullanılır.

  • A yanlış: Bir satırın sonucunu görmeye alışan öğrenci çıktı bekler. Ama assert doğru geçtiğinde hiçbir şey yazmaz.
  • B yanlış: Satırda bir karşılaştırma bulunduğu için iki sonucun kıyaslandığı düşünülebilir. Ama fonksiyon bir kez çağrılır ve sonucu beklenen değerle karşılaştırılır.
  • D yanlış: assert hatayı bulmaya yardım ettiği için onu düzelttiği de sanılabilir. Ama düzeltme yapmaz; yalnızca beklentiyi sınar.
  • E yanlış: Satırda 70 sayısı ve eşittir işareti göründüğü için atama sanılabilir. Ama == atama yapmaz; yalnızca eşitliği sınar.

7. Doğru: B. float değerler yaklaşık tutulur; 0.1 + 0.7 sonucu 0.7999999999999999 olur. Bu yüzden float sonuçlarda tam eşitlik yerine probleme uygun bir tolerans kullanılır.

  • A yanlış: assert satırlarında çoğu zaman yalnızca bir fonksiyon çağrısı görüldüğü için akla gelir. Ama Python buna izin verir. assert’ün ardına toplama içeren herhangi bir karşılaştırma yazılabilir.
  • C yanlış: Tuhaf eşitsizliklerin nedeni çoğu zaman tür karışıklığı olduğu için akla gelir. Ama tırnak yok; 0.8 bir floattur.
  • D yanlış: Beklenmedik bir sonuçta ilk şüphe kodun yazımına gider. Ama yazımda sorun yok; fark değerlerin saklanma biçiminden geliyor.
  • E yanlış: Satır başarısız olunca sorun assert kullanımında aranabilir. Ama assert ondalıklı sayılarla da çalışır; sorun karşılaştırmanın kendisinde.

8. Doğru: A. > ile >= karışıklığı yalnızca sınırın çevresinde fark edilir. 49, 50 ve 51 bu hatayı yakalar; sınırdan uzak değerler göstermez.

  • B yanlış: Testlerin gerçek kullanıma benzemesi istendiği için akla gelebilir. Ama bu değerler sık görüldükleri için değil, sınıra yakın oldukları için seçildi.
  • C yanlış: Seçilen üç değer ardışık olduğu için kuralın ardışıklık olduğu sanılabilir. Ama önemli olan değerlerin sınırın çevresinde olması; 10, 11, 12 bu fonksiyonda sınırı hiç sınamaz.
  • D yanlış: Sınır değerlerinin özel bir adla anılması, Python’ın onları ayrıca işlediği izlenimini verebilir. Ama özel bir işlem yoktur; sınır davranışını programcı belirler.
  • E yanlış: Testlerin çabuk bitmesi istendiği için akla gelebilir. Ama hız bir ölçüt değildir; bu değerler sınıra yakın oldukları için seçildi.

9. Doğru: A. Boş metnin uzunluğu sıfırdır. Uzunluğa bölen bir hesap ZeroDivisionError verir; sıradan girdilerde çalışan fonksiyon burada farklı davranır. Bu yüzden boş değer ayrıca düşünülmelidir.

  • B yanlış: Boş metin “hiçbir şey” gibi düşünülünce yer kaplamayacağı sanılır. Ama bellek kullanımı uç durum olmasının nedeni değildir; sorun işlemlerin davranışında.
  • C yanlış: Ölçülecek bir karakter olmadığı için uzunluğun ölçülemeyeceği düşünülebilir. Ama len() boş metinde de çalışır: len("") sonucu 0’dır.
  • D yanlış: Boş metinle ilgili ilk görülen örnek çoğu zaman hata veren bir hesap olduğu için genelleme yapılabilir. Ama birçok işlemde sorunsuz çalışır; "" + "a" sonucu "a" olur. Sorun yalnızca belirli işlemlerde çıkar.
  • E yanlış: İkisi de “değer yok” gibi düşünüldüğü için karıştırılır. Ama aynı değildir; "" bir str, None ayrı bir değerdir.

10. Doğru: D. Saf fonksiyon yalnızca argümanlarını kullanır. Dışarıdaki hiçbir değişkeni değiştirmez, ekrana da yazmaz; yani yan etkisi yoktur. Aynı girdiyle her zaman aynı sonucu döndürür. Bu iki özellik sayesinde tek başına sınanabilir ve ne döndüreceği önceden bilinir.

  • A yanlış: Saf fonksiyon örnekleri çoğu zaman kısa sayı hesapları olduğu için akla gelir. Ama tür ve iç yapı saflıkla ilgili değildir; metin işleyen, döngü içeren bir fonksiyon da saf olabilir.
  • B yanlış: Kısa fonksiyonlar yan etkisiz göründüğü için akla gelir. Ama uzunlukla ilgisi yoktur; tek satırlık bir fonksiyon da print() yaparak saflığını yitirebilir.
  • C yanlış: Dışarıyla hiç ilişkisi olmayan bir fonksiyon “saf” gibi görünebilir. Ama tam tersi; saf fonksiyon girdisini parametreden alır ve sonucunu döndürür.
  • E yanlış: Ekrana yazmak ve küresel değişkeni güncellemek fonksiyonun yaptığı somut işler olduğu için özellik gibi görünebilir. Ama ikisi de yan etkidir: fonksiyonun dışını değiştirir. Saf fonksiyon bunları yapmaz.

11. Doğru: D. Çağrılar 3, 2, 1, 0 diye iner. ikinin_kuvveti(0) 1 döndürür. Bekleyen çağrılar bu değeri sırayla ikiyle çarpar: 2, 4, 8.

  • A yanlış: Fonksiyon kendini çağırdığı için hiç durmayacağı düşünülebilir. Ama n her çağrıda bir azalır ve n == 0 temel durumuna ulaşılır.
  • B yanlış: Temel durumda da bir çarpma yapılıyormuş gibi sayılırsa dört çarpma çıkar. Ama n == 0 iken fonksiyon kendini çağırmadan 1 döndürür. Çarpma yalnız 3, 2 ve 1 çağrılarında yapılır.
  • C yanlış: Gövdede 2 * ile argüman 3 yan yana görülünce 2 * 3 hesaplanabilir. Ama 2, 3 ile değil ikinin_kuvveti(2) çağrısının sonucuyla çarpılır.
  • E yanlış: Çağrılar temel durumda bittiği için onun döndürdüğü 1 sonuç sanılabilir. Ama 1 yalnız ikinin_kuvveti(0) çağrısının sonucudur. Bekleyen üç çağrı bu değeri ikiyle çarparak döndürür.

Tek sayfa özet

Bu hafta bir fonksiyonun ne alıp ne döndüreceğini yazmayı ve bunu assert ile sınamayı gördük.

  • Fonksiyon sözleşmesi fonksiyonun ne aldığını, ne yaptığını ve ne döndürdüğünü yazar.
  • Ön koşul, fonksiyonun hangi girdilerle doğru çalıştığını söyler.
  • Yerel değişken yalnızca kendi fonksiyonunun içinde kullanılabilir. Hesaplama fonksiyonu dışarıdan bir değere ihtiyaç duyuyorsa onu parametreyle almak kodu daha anlaşılır yapar.
  • Varsayılan parametre, argüman verilmediğinde hangi değerin kullanılacağını açıkça belirler. Anahtar kelime argümanı değeri parametrenin adıyla verir: indirimli_fiyat(1000, oran=0.25).
  • global, fonksiyonun dışarıdaki küresel bir değişkeni değiştirmesine izin verir; hesaplama fonksiyonlarında ilk çözüm olarak kullanılmaz.
  • assert, beklediğiniz bir sonucu hızlıca sınar. Koşul yanlışsa AssertionError verir. assert dönüş değerine bakar: sonucu yalnız ekrana yazan fonksiyon None döndürür.
  • float sonuçlarını karşılaştırırken == yerine probleme uygun bir tolerans gerekebilir: abs(sonuc - beklenen) < 0.01.
  • Koşullu fonksiyonlarda sınırın hemen altı, kendisi ve hemen üstü ayrı ayrı denenir.
  • Boş metin, boş liste ya da hiç eşleşme bulunmaması gibi durumlar uç durum olabilir.
  • Tek bir testin geçmesi yalnız o örneği sınar. Sıradan bir örnek, sınır değeri ve uç durum ayrı ayrı denenir.
  • Saf fonksiyon argümanlarını kullanır ve sonuç döndürür. Dışarıdaki hiçbir değeri değiştirmez, ekrana da yazmaz.
  • Tek iş yapan küçük fonksiyonları ayrı ayrı sınamak daha kolaydır.
  • Özyinelemeli fonksiyon kendini daha küçük bir argümanla çağırır. Temel durum çağrıları durdurur, özyinelemeli adım her çağrıda temel duruma yaklaşır. Temel duruma hiç gelinmezse Python RecursionError verir.
  • Bekleyen çağrılar ters sırayla biter: en son başlayan çağrı sonucunu ilk döndürür. Her return yalnız kendi çağrısını bitirir. Toplama ve sayma gibi işlerde aynı işi yapan döngü daha basittir.

Bir sonraki bölümde fonksiyonlarla birlikte sık kullanacağımız metin (str) değerlerini daha ayrıntılı inceleyeceğiz.

Bu bölümün kazanımları

Bu bölümü bitiren öğrenci:

  • Fonksiyon sözleşmesini ve ön koşulları açıklar.
  • Yerel değişkenin kapsamını açıklar ve dış bağımlılığı parametreye çevirmeyi gerekçelendirir.
  • Varsayılan parametreli bir çağrıda parametrenin hangi değeri aldığını belirler.
  • assert ile beklenen davranışı doğrular.
  • float sonuçlarda tam eşitlik yerine toleranslı karşılaştırma seçer.
  • Sınır ve uç durumları seçerek test eder.
  • Saf fonksiyonu yan etkili fonksiyondan ayırt eder ve global kullanımına neden temkinli yaklaşıldığını açıklar.
  • Özyinelemeli fonksiyonda temel durumu ve özyinelemeli adımı ayırt eder, çağrıları izleyerek sonucu belirler.
Başa dön