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ı
- 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ı
assertile beklenen davranışı doğrulamafloatsonuç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
globalkullanırken neden temkinli olunduğu - Özyinelemeli fonksiyon: temel durum, özyinelemeli adım, çağrıların izlenmesi ve
RecursionError
unittestvepytestgibi 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.
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.
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.
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
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.
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.01Tolerans 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.
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.
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) == 212Kendini ç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 == 0iken fonksiyon0dö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.
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ı.
Ö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:
Üret: hesabı paylaştıran fonksiyon
Hesap paylaştırma tarifini fonksiyona çevirin. kisi_basi_pay(hesap, kisi, bahsis) adlı fonksiyon şu kurallara uymalı:
bahsisverilmezse0.10kullanı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?
floatsonucu karşılaştırırken tam eşitlik gerçekten uygun mu?- Hesaplama fonksiyonu gereksiz
print(),globalya 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.
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ışsaAssertionErrorverir.assertdönüş değerine bakar: sonucu yalnız ekrana yazan fonksiyonNonedöndürür.floatsonuç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
RecursionErrorverir. - Bekleyen çağrılar ters sırayla biter: en son başlayan çağrı sonucunu ilk döndürür. Her
returnyalnı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.
assertile beklenen davranışı doğrular.floatsonuç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
globalkullanı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.