Fonksiyonlara giriş

İlk beş haftada programlarımız giderek büyüdü: değişkenler kullandık, koşullar kurduk ve döngüler yazdık. Kod büyüdükçe aynı işlemi tekrar tekrar yazmaya başlarız. Bir hatayı birden fazla yerde düzeltmek gerekir, programın hangi parçasının hangi işi yaptığını anlamak da zorlaşır.

print() ve input() gibi Python’ın hazır fonksiyonlarını zaten kullanıyorsunuz. Fonksiyon, bir işi yapan ve adıyla çalıştırılan kod parçasıdır. Bu hafta kendi fonksiyonlarımızı yazıp problemi küçük, adlandırılmış parçalara ayıracağız. def söz dizimini öğrenirken bir fonksiyonun hangi bilgiyi aldığına, hangi işi yaptığına ve sonucu kime verdiğine de bakacağız.

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ı

Sınavda sorulur

Fonksiyon tanımı ile çağrısının ayrımı
Parametre ile argüman ayrımı ve argüman sayısı uyuşmazlığı
print() ile return farkı
return çalıştığında fonksiyonun sona ermesi
Değer döndürmeyen fonksiyonun örtük None döndürmesi
Dönüş değerini başka ifadelerde kullanma
Problemi küçük fonksiyonlara ayırmanın gerekçesi

Sınav dışı (bilgi amaçlı)

Değişken sayıda argüman (*args, **kwargs)
Fonksiyon içinde fonksiyon tanımlama

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

Kasadaki indirim kartını nasıl yazardınız?

Bir mağazada kasiyerler indirimli fiyatı her seferinde elle hesaplıyor ve arada bir yanlış yapıyor. Müdür bu hesabı bir kez yazıp bir karta koymaya karar veriyor. Kartın üstünde bir ad ve iki boş kutu var: ürünün fiyatı ve indirim oranı. Kasiyer bir üründe kartı açacak, iki kutuyu dolduracak, kartın adımlarını izleyecek ve çıkan sonucu müşterinin fişine ekleyecek.

Kartı siz yazın. 1. bölümde gördüğümüz sözde kodla, Türkçe ve madde madde yazın: kartın adı ne, hangi kutuları var, adımları neler, sonuç kasiyere nasıl ulaşıyor? Sonra kartınızı beş durumla deneyin:

Müdür kartı sabah yazdı, gün boyunca hiç müşteri gelmedi. Kartın adımları o gün kaç kez izlendi?
Kasiyer kartı açtı, fiyat kutusuna 800 yazdı, indirim oranı kutusunu boş bıraktı. Kartınız ne yapıyor?
Müşteri iki ürün aldı. Kasiyer kartı iki kez izleyip iki indirimli fiyatı toplayacak. Kartınızın son adımı “sonucu söyle” ise kasiyer neyi toplar?
Kampanyada bazı ürünler hediye, fiyatları 0 olmalı. Kartınıza bu kuralı ekleyin. Sonra 800 TL’lik, %25 indirimli hediye bir ürünle kartı baştan sona izleyin: sonuç kaç çıkıyor?
Fişe indirimden sonra KDV de eklenecek. KDV adımlarını aynı karta mı yazarsınız, ayrı bir karta mı?

Python bilmeniz gerekmiyor: “Hediyeyse sonuç 0” da bir adım. Kartınızı bir kenara yazın. Bölümde her parçanın Python’da nasıl yazıldığını göreceğiz. Alıştırmalardan önce kartınıza döneceğiz.

Fonksiyon neden kullanılır?

Bir dikdörtgenin alanını birkaç yerde hesapladığımızı düşünelim:

genislik1 = 4
yukseklik1 = 6
alan1 = genislik1 * yukseklik1

genislik2 = 7
yukseklik2 = 3
alan2 = genislik2 * yukseklik2

Aynı hesabı tekrar yazmak yerine ona bir ad verip bir fonksiyon yapabiliriz. Sonra aynı hesabı farklı değerlerle çalıştırırız. Hücre hangi iki satırı yazar?

Burada fonksiyonun iki yararı var:

Hesaba ne yaptığını anlatan bir ad verir.
Aynı hesap, yeniden yazılmadan farklı değerlerle kullanılabilir.

def, return ve parantezin içindeki adları bölümün geri kalanında tek tek göreceğiz.

Tip

Bir kod parçasını fonksiyona dönüştürüp dönüştürmeyeceğinize karar verirken yalnızca “bu kod tekrar ediyor mu?” diye sormayın. “Bu parçanın tek ve açık bir işi var mı?” diye de sorun.

Fonksiyon tanımı ve çağrısı

Bir fonksiyonun tanımı def ile başlar:

def selamla():
    print("Merhaba")

def satırının altındaki girintili satırlara fonksiyonun gövdesi denir. Bu kod fonksiyonu tanımlar, yani selamla adını bu gövdeye bağlar, ama gövdeyi henüz çalıştırmaz. Gövdeyi çalıştırmak için fonksiyonu adıyla ve parantezle çağırırız:

selamla()

Aşağıdaki program kaç satır yazar, satırların sırası ne olur?

Fonksiyon tanımı programın başında yer alsa da gövdesi yalnızca mesaj_yaz() çağrısı yapıldığında çalışır.

Çağrı yapılırken fonksiyon tanımlı olmalıdır

Bu kez çağrı tanımdan önce yazılmış. Hücre çalışır mı?

Python dosyayı yukarıdan aşağıya satır satır çalıştırır. İlk satıra geldiğinde def satırı henüz çalışmadığı için selamla adı tanımlı değildir. Python bu durumda NameError hatası verir. Çağrıyı tanımın altına taşıyıp yeniden deneyin.

Fonksiyonun dosyanın herhangi bir yerinde yazılı olması yetmez; program çağrı satırına geldiği anda ad tanımlı olmalıdır. Bu yüzden şimdilik fonksiyon tanımlarını onları kullanan ana koddan önce yazın. Bu düzen kodu okumayı da kolaylaştırır.

Parametre ve argüman

Fonksiyonun farklı değerlerle çalışabilmesi için tanımdaki parantezin içine bir ad yazarız. Bu ada parametre denir:

def selamla(ad):
    print("Merhaba", ad)

Burada ad, fonksiyon tanımındaki parametredir. Fonksiyonu şöyle çağırabiliriz:

selamla("Deniz")

Çağrıda parantezin içine yazılan "Deniz" ise argümandır: parametreye o çağrıda verilen değer. Açılıştaki kartta boş kutular parametredir, kasiyerin kutulara yazdığı değerler argümandır.

Tanım:  def selamla(ad):
                     ↑
                 parametre

Çağrı: selamla("Deniz")
               ↑
            argüman

Bir fonksiyon birden fazla parametre alabilir. Argümanlar parametrelere sırayla eşlenir: ilk argüman ilk parametreye, ikinci argüman ikinci parametreye gider. Hücre hangi iki satırı yazar?

Argüman sayısı parametrelerle uyuşmalıdır

toplam_fiyat iki parametre bekliyor. Bu çağrıda yalnız bir argüman var. Hücre ne yazar?

Python eksik argümanı kendiliğinden tamamlamaz, boş kutuyu 0 da saymaz. Eksik ya da fazla argümanla yapılan çağrı TypeError hatası verir. Eksik argümanda mesajda “missing” (eksik) sözcüğü geçer. Fazla argümanda mesaj “takes 2 positional arguments but 3 were given” (iki argüman alır ama üç verildi) gibi bir cümledir. Hücredeki çağrıya üçüncü bir argüman ekleyip bu mesajı da görün.

Tip

Bir fonksiyon çağrısında TypeError gördüğünüzde önce şunu kontrol edin: Fonksiyon kaç parametre tanımlıyor, ben kaç argüman verdim?

`return`: fonksiyonun döndürdüğü değer

Çoğu zaman fonksiyonun hesapladığı değeri ekrana yazmak yerine programın başka bir yerinde kullanmak isteriz. Hücre ne yazar?

return, hesaplanan değeri fonksiyonun çağrıldığı yere geri gönderir. Bu değere fonksiyonun dönüş değeri denir. Burada kare(5) çağrısının dönüş değeri sonuc değişkenine atanır.

Fonksiyon tanımı, çağrı, parametre, argüman ve dönüş değeri arasındaki ilişki. — Fonksiyon çağrı akışı

Aşağıdaki iki fonksiyon aynı toplamı hesaplıyor. Biri sonucu ekrana yazıyor, öteki döndürüyor. Hücre ne yazar? Sonra dondurerek_topla yerine yazdirarak_topla yazıp yeniden çalıştırın.

Çıktının açıklaması

dondurerek_topla(10, 20) çağrısı 30 döndürür. ara_toplam 30 olur, genel_toplam 35 olur ve 35 yazılır.

yazdirarak_topla ile önce 30 yazılır: bu, fonksiyonun içindeki print()’in işidir. Fonksiyonda return olmadığı için ara_toplam None olur ve None + 5 satırı TypeError verir. Ekranda görünen 30, programın geri kalanının eline geçmedi.

Important

print() değeri ekranda kullanıcıya gösterir. return ise değeri fonksiyonu çağıran koda geri verir; o kod değeri bir değişkende tutabilir ya da başka bir hesapta kullanabilir.

`return` yoksa ne döner? `None`

Python’da fonksiyonun sonuna gelindiğinde hiçbir return satırı çalışmadıysa fonksiyon yine de bir değer döndürür: None. Kodda yazılmadığı hâlde Python’ın kendiliğinden döndürdüğü bu değere örtük dönüş değeri denir. None, “bu fonksiyon işe yarar bir sonuç döndürmedi” demektir.

Hücre kaç satır yazar, ikinci satırda ne görünür?

Çıktının açıklaması

İki satır yazılır: 80.0 ve Dönen değer: None. İlk satırı fonksiyonun içindeki print() yazdırır. İkinci satırdaki None ise fonksiyonun dönüş değeridir.

Bu yüzden ekrana yazan fonksiyonla değer döndüren fonksiyonu birbirinden ayırın:

def ortalama_yazdir(a, b):
    print((a + b) / 2)

def ortalama_hesapla(a, b):
    return (a + b) / 2

İkinci fonksiyonun sonucu başka bir hesapta güvenle kullanılabilir.

Note

None ile ilerleyen haftalarda yine karşılaşacağız: 10. haftadaki sözlüklerde get(), bulunmayan bir anahtar için None verebilir; 13. ve 14. haftalarda da bazı geçersiz dönüşümleri açıkça işaretlemek için None kullanacağız. Yani None “ekrana hiçbir şey yazılmadı” demek değildir; Python’da kendi başına bir değerdir.

print ile ekrana yazdırma ve return ile çağırana değer döndürme arasındaki fark. — print ve return farkı

Tahmin et: `return` sonrasında ne olur?

Aşağıdaki programın çıktısını ve fonksiyonun dönüş değerini tahmin edin:

return çalıştığında fonksiyon sona erer. Bu nedenle return satırından sonraki print() çağrısına ulaşılmaz.

Alıştırma: eksik dönüş değerini tamamlayın

Aşağıdaki fonksiyon iki sınav notunun ortalamasını hesaplamalı, ama şu anda sonucu döndürmüyor.

Fonksiyonun 80.0 değerini döndürmesini sağlayın.

Fonksiyonun sonucunu başka bir ifadede kullanmak

Dönüş değerini herhangi bir değer gibi kullanabilirsiniz. Hücre ne yazar?

Fonksiyon çağrısı doğrudan bir ifadenin içinde de yer alabilir:

odenecek = urun_tutari + kdv_hesapla(urun_tutari, 0.20)

Ara değerin bir anlamı varsa (buradaki kdv gibi) onu ayrı bir değişkende tutmak kodu çoğu zaman daha okunur yapar.

Alıştırma: alan fonksiyonunu yazın

Bir dikdörtgenin alanını hesaplayan dikdortgen_alani fonksiyonunu tamamlayın.

Beklenen sonuç 40’tır.

Bir problemi küçük fonksiyonlara ayırmak

Fonksiyonlarla tekrarı azaltmanın yanında büyük bir problemi anlamlı alt problemlere de bölebiliriz. Örneğin bir alışveriş tutarı için önce indirimi, sonra KDV’yi hesaplayalım. Hücre ne yazar?

Burada her fonksiyonun işi tek cümleyle açıklanabilir:

indirim_hesapla: verilen tutarın indirim miktarını bulur.
kdv_hesapla: verilen tutarın KDV miktarını bulur.

Sonuç yanlış çıkarsa sorunun hangi adımda olduğunu bulmak da kolaylaşır: indirim ve KDV fonksiyonlarını ayrı ayrı deneyebilirsiniz.

Yerel değişkenler

Fonksiyonun içinde oluşturulan bir değişken genellikle yalnızca o fonksiyonun içinde kullanılır. Böyle değişkenlere yerel değişken denir:

def cevre_hesapla(kenar):
    sonuc = kenar * 4
    return sonuc

Fonksiyon dışındaki kodun buradaki sonuc değişkenine doğrudan erişmesi gerekmez. Dışarıya verilmesi gereken değer return ile açıkça döndürülür.

Bir adın programın hangi bölümünde geçerli olduğuna kapsam (scope) denir. Ayrıntısını 7. bölümde göreceğiz. Şimdilik şunu aklınızda tutun:

Fonksiyonun ara hesapları mümkün olduğunca fonksiyonun içinde kalmalı; dışarıya yalnızca gereken sonuç verilmelidir.

Soruya dönelim: indirim kartı Python’da

Bölümün başında kasadaki indirim kartını yazıp beş durumla denemiştiniz. Python’daki karşılıkları şöyle:

Durum	Sözde kodda	Python’da	Dikkat
Kart yazıldı, müşteri gelmedi	“İNDİRİMLİ FİYAT kartı: …” ve altındaki adımlar	`def indirimli_fiyat(fiyat, indirim_orani):` ve girintili gövde	`def` gövdeyi çalıştırmaz. Gövde yalnız `indirimli_fiyat(800, 0.25)` gibi bir çağrıda çalışır
Oran kutusu boş	“Kutular: fiyat, indirim oranı”	`fiyat` ve `indirim_orani` parametre, çağrıdaki `800` ve `0.25` argüman	`indirimli_fiyat(800)` `TypeError` verir. Python boş kutuyu `0` saymaz
İki ürünü toplamak	“Sonucu kasiyere ver”	`return fiyat - indirim`, sonra `indirimli_fiyat(800, 0.25) + indirimli_fiyat(200, 0.10)`	“Sonucu söyle” `print()` olur: sonuç ekranda görünür ama çağıran kodun eline `None` geçer ve toplama yapılamaz
Hediye ürün	“Hediyeyse 0 ver ve dur”	`if hediye_mi:` altında `return 0`	`return` fonksiyonu bitirir. “Dur” yazılmazsa, yani `return 0` yerine `sonuc = 0` yazılırsa sonraki adım sonucu `600` yapar
İndirimden sonra KDV	“KDV için ayrı kart”	`indirimli_fiyat` ve `kdv_hesapla` ayrı fonksiyonlar	Her fonksiyonun tek işi olursa ikisi ayrı ayrı denenir, yanlış sonucun hangi kartta çıktığı bulunur

Kartınızı tabloyla karşılaştırın. Kartın son adımı “sonucu söyle” ise kasiyer ancak duyduğunu yeniden yazarak toplayabilir. Python’da bu yeniden yazma yoktur: değer return ile verilmezse çağıran kodun eline geçmez. Hediye kuralını “Hediyeyse sonuç 0” diye yazıp altına hesabı eklediyseniz kartınız hediye ürüne 600 TL yazar. Kurala “ve dur” eklemek, Python’da return yazmaktır.

Değiştir: kargo hesabını fonksiyona dönüştürün

Aşağıdaki programda kargo ücreti doğrudan hesaplanıyor:

Bu hesabı şöyle bir fonksiyona dönüştürün:

def kargo_ucreti(sepet_tutari):
    ...

Fonksiyon şu değerleri döndürmelidir:

500 TL ve üzeri için 0
Daha düşük tutarlar için 39.90

Fonksiyonu 650, 500 ve 499 ile çağırıp sonuçları yazdırın.

Bir çözüm

def kargo_ucreti(sepet_tutari):
    if sepet_tutari >= 500:
        return 0
    return 39.90

print(kargo_ucreti(650))
print(kargo_ucreti(500))
print(kargo_ucreti(499))

İlk return çalışırsa fonksiyon orada biter, bu yüzden else yazmak gerekmez. else ile yazılmış bir çözüm de doğrudur.

Üret: indirimli fiyat fonksiyonu

Bölümün başındaki indirim kartını Python’a çevirin: bir ürünün fiyatını ve indirim oranını alan, indirim sonrası fiyatı döndüren bir fonksiyon yazın.

Başlangıç:

pass, “burada şimdilik hiçbir şey yapma” diyen boş bir satırdır. Kodunuzu yazınca silin. Beklenen sonuç 600.0’dır.

Kabul kriterleri:

Fonksiyonun adı indirimli_fiyat olmalı.
İki parametre kullanılmalı.
İndirim miktarı fiyat * indirim_orani ilişkisiyle hesaplanmalı.
Sonuç return ile döndürülmeli.
Fonksiyon farklı fiyat ve oranlarla da çalışabilmeli.

Sıra sizde: hediye ürün ve fiş toplamı

Fonksiyona üçüncü bir parametre ekleyin: hediye_mi. Ürün hediyeyse fonksiyon 0 döndürsün ve hesaba hiç geçmesin. Sonra fonksiyonu iki kez çağırıp müşterinin fişini toplayın: 800 TL’lik %25 indirimli ürün ile 200 TL’lik %10 indirimli ürün.

Beklenen çıktı:

Satır	Beklenen
`indirimli_fiyat(800, 0.25, True)`	`0`
Fiş toplamı (iki ürün de hediye değil)	`780.0`

def indirimli_fiyat(fiyat, indirim_orani, hediye_mi):
    if hediye_mi:
        return 0
    indirim = fiyat * indirim_orani
    return fiyat - indirim

print(indirimli_fiyat(800, 0.25, True))
fis_toplami = indirimli_fiyat(800, 0.25, False) + indirimli_fiyat(200, 0.10, False)
print(fis_toplami)

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.

Madde 1. Fonksiyon tanımı ile fonksiyon çağrısı arasındaki fark nedir?

A. Tanım fonksiyonu kaydeder, çağrı onu çalıştırır
B. Tanım fonksiyonu bir kez çalıştırır, çağrı ise tekrar çalıştırır
C. Tanım parantezli, çağrı parantezsiz yazılır
D. İkisi aynı şeydir; def yazımı isteğe bağlıdır
E. Tanım dosyanın sonunda, çağrı başında yer alır

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

print(selamla())

def selamla():
    return "Merhaba"

A. Bir fonksiyon print() içinde çağrılamaz
B. Parametresi olmayan bir fonksiyon çağrılamaz
C. Fonksiyon adı selamla gibi bir fiil olduğu için
D. Çağrı anında selamla henüz tanımlı değildir
E. return yerine print() kullanılmalıydı

Madde 3. def toplam(a, b): tanımındaki a ve b ile toplam(4, 7) çağrısındaki 4 ve 7 sırasıyla nedir?

A. Dördü de argümandır
B. Dördü de parametredir
C. a ve b yerel değişken değildir; yalnızca birer etikettir
D. a ve b argümandır; 4 ve 7 parametredir
E. a ve b parametredir; 4 ve 7 argümandır

Madde 4. Aşağıdaki çağrı hangi hatayı verir?

def alan(en, boy):
    return en * boy

print(alan(5))

A. Hata vermez; eksik parametre 0 sayılır
B. TypeError; boy için argüman verilmemiştir
C. NameError; boy adı hiçbir yerde tanımlı değildir
D. Hata vermez; 5 ikisine birden atanır
E. ValueError; 5 geçersiz bir değerdir

Madde 5. print() ile return arasındaki temel fark nedir?

A. return kullanılan bir fonksiyon ekrana hiçbir şey yazamaz
B. print() değeri gösterir, return çağıran koda geri verir
C. İkisi de aynı işi yapar; return yalnızca fonksiyon içinde yazılır
D. print() yalnızca metin, return yalnızca sayı taşıyabilir
E. return ekrana yazar, print() değeri saklar

Madde 6. Aşağıdaki program neden Toplam: None yazdırır?

def topla(a, b):
    print(a + b)

sonuc = topla(2, 3)
print("Toplam:", sonuc)

A. İki argüman verildiği için fonksiyon iki değer döndürmeye çalışıyor
B. print() çağrısı toplamı bozduğu için
C. sonuc değişkeni yanlış adlandırıldığı için
D. Fonksiyon sonucu yazdırıyor ama döndürmüyor
E. a + b işlemi fonksiyon içinde yapılamaz

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

def kontrol(puan):
    if puan >= 50:
        return "Geçti"
    return "Kaldı"
    print("Bu satır")

print(kontrol(80))

A. Kaldı
B. Geçti ve Kaldı
C. None
D. Geçti ve Bu satır
E. Geçti

Madde 8. İçinde hiç return bulunmayan bir fonksiyonun dönüş değeri nedir?

A. None
B. Fonksiyonun son satırındaki değer
C. Boş metin ("")
D. False
E. 0

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

def iki_kat(x):
    return x * 2

a = iki_kat(3)
b = iki_kat(a)
print(b)

A. 24
B. None
C. 12
D. 6
E. 3

Madde 10. Bir fonksiyon yalnızca kod tekrarını azaltmak için değil, başka hangi nedenle de yararlıdır?

A. Programın bellek kullanımını her zaman azaltır
B. Değişkenlerin tür dönüşümünü kendiliğinden yapar
C. Problemi ayrı ayrı denenebilen parçalara böler
D. Fonksiyon içindeki söz dizimi hatalarını engeller
E. Kodun satır sayısını mutlaka düşürür

Cevaplar ve gerekçeler

Madde 1. Doğru: A. def satırı yalnızca adı ve gövdeyi kaydeder; gövdeyi çalıştırmaz. Gövde ancak fonksiyon adı parantezle çağrıldığında, o anda çalışır.

B yanlış: def satırı da yürütülen bir satır olduğu için gövdenin o anda çalıştığı sanılabilir. Ama tanım gövdeyi hiç çalıştırmaz; gövde ilk kez ilk çağrıda çalışır.
C yanlış: İki satırın yazımı farklı olduğu için parantezin yalnızca birinde bulunduğu sanılabilir. Ama ikisinde de parantez vardır; tanımda parametreler, çağrıda argümanlar bulunur.
D yanlış: print() gibi yerleşik fonksiyonları def yazmadan kullandığımız için def gereksiz görünebilir. Ama kendi fonksiyonunuz def olmadan oluşmaz; tanım ve çağrı ayrı adımlardır.
E yanlış: Programın asıl işi çağrıda yapıldığı için onun başa konacağı düşünülebilir. Ama sıra tam tersi olmalıdır: ad kullanılmadan önce tanımlanır.

Madde 2. Doğru: D. Python satırları sırayla yürütür. İlk satır çalıştığında def satırına henüz gelinmemiştir; ad var olmadığı için NameError oluşur.

A yanlış: İç içe iki çağrı ilk bakışta karışık göründüğü için hatalı sanılabilir. Ama çağrılabilir; dönüş değeri doğrudan print()e verilir.
B yanlış: Fonksiyon örneklerinin çoğu parametre aldığı için boş parantez eksik görünebilir. Ama parametresiz fonksiyonlar boş parantezle çağrılır ve bu geçerlidir.
C yanlış: Adlandırma kurallarını yeni öğrenen öğrenci adın kendisinden şüphelenebilir. Ama ad seçimi hataya yol açmaz; fonksiyona fiil adı vermek yaygın ve önerilen bir alışkanlıktır.
E yanlış: print() ile return sık karıştırıldığı için sorun orada aranabilir. Ama return doğru kullanılmış; sorun çağrının tanımdan önce gelmesi.

Madde 3. Doğru: E. Parametre tanımdaki addır; argüman çağrıda o ada verilen değerdir.

A yanlış: Günlük dilde “fonksiyona verilenler” diye hepsine tek ad verilebilir. Ama tanımdaki a ve b henüz bir değer değil, değer bekleyen addır; bunlar parametredir.
B yanlış: Dördü de parantezin içinde durduğu için aynı adı taşıdıkları sanılabilir. Ama çağrıda verilen 4 ve 7 argümandır.
C yanlış: a ve b gövdede hiç atama yapılmadan kullanıldığı için değişken gibi görünmeyebilir. Ama fonksiyon çağrıldığında argümanların değerini alan yerel değişkenlerdir.
D yanlış: İki terim hep birlikte geçtiği için hangisinin tanımda, hangisinin çağrıda olduğu kolayca karışır. Terimler ters yazılmış: tanımdaki ad parametre, çağrıdaki değer argümandır.

Madde 4. Doğru: B. alan iki zorunlu parametre bekler, çağrıda yalnızca 5 verilmiş. Python eksik argümanı kendiliğinden tamamlamaz; fonksiyonun gövdesi daha çalışmadan çağrı hata verir.

A yanlış: Hesaplarda eksik değer çoğu zaman sıfır sayıldığı için akla yatkındır. Ama böyle bir varsayılan yoktur; varsayılan istenirse tanımda yazılır.
C yanlış: Gövdede boy kullanılıyor ama bir değeri yok; bu tanımsız ad gibi görünür. Ama boy tanımda yer alan bir parametredir; sorun, ona değer verilmemesi.
D yanlış: Karede en ile boyun eşit olduğunu düşünen öğrenci bunu bekleyebilir. Ama bir argüman yalnızca bir parametreye karşılık gelir.
E yanlış: Hatalı bir değer verildiği hissi ValueErrorı akla getirir. Ama 5 geçerli bir sayıdır; sorun argüman sayısında.

Madde 5. Doğru: B. Ekranda görünen bir değer programın geri kalanında kullanılamaz. return değeri çağıran koda geri verir; o değer bir değişkene atanıp sonradan kullanılabilir.

A yanlış: return ile ekrana yazmanın ayrı işler olduğunu öğrenen öğrenci ikisinin bir arada bulunamayacağını düşünebilir. Ama aynı fonksiyon hem yazdırıp hem değer döndürebilir.
C yanlış: İkisi de fonksiyonun sonucunu dışarı çıkarıyor gibi göründüğü için aynı sanılır. Ama aynı işi yapmazlar; biri değeri gösterir, öteki geri verir.
D yanlış: print() çoğu örnekte metin yazdırdığı, return ise hesap sonucu döndürdüğü için böyle bir ayrım sezilebilir. Ama ikisi de her türle çalışır.
E yanlış: İkisinin ayrı işler yaptığını bilen ama hangisinin ne yaptığını karıştıran öğrenci bunu seçer. Görevler ters yazılmış.

Madde 6. Doğru: D. Ekrandaki 5 fonksiyonun içindeki print() çıktısıdır. Fonksiyonda return olmadığı için çağrı None döndürür ve sonuc None olur. Çağıran koda değer ancak return ile gider.

A yanlış: İki değer verip tek bir None almak, bir şeylerin karıştığı hissini verir. Ama argüman sayısıyla dönüş değeri arasında böyle bir ilişki yoktur.
B yanlış: Fonksiyonda return yerine duran tek satır print() olduğu için şüphe ona gider. Ama print() değeri değiştirmez, yalnızca gösterir; eksik olan returndur.
C yanlış: Beklenmeyen bir değer görünce değişkenin yanlış yazıldığı düşünülebilir. Ama ad seçimi değeri etkilemez; hangi ad verilse None yazılırdı.
E yanlış: Toplamın dışarı çıkmaması işlemin hiç yapılmadığı izlenimini verir. Ama işlem yapılabilir ve zaten yapılıyor; ekranda 5 görünüyor.

Madde 7. Doğru: E. return çalıştığı anda fonksiyon biter; sonrasındaki hiçbir satıra ulaşılmaz.

A yanlış: return "Kaldı" satırı girintisiz ve fonksiyonun sonunda durduğu için son sözü o söylüyormuş gibi okunur. Ama 80 >= 50 doğrudur ve fonksiyon ilk return’de biter.
B yanlış: İki return alt alta durduğu için ikisinin de sırayla çalıştığı sanılabilir. Ama ilk return fonksiyonu sonlandırır, ikincisine sıra gelmez.
C yanlış: return’den sonra erişilemeyen bir satır görünce fonksiyonun bozulduğu ve değer döndürmediği sanılabilir. Ama fonksiyon "Geçti" değerini açıkça döndürüyor.
D yanlış: Kodda print("Bu satır") açıkça yazılı olduğu için bir yerde çalışacağı düşünülür. Ama return satırından sonraki satırlara hiç ulaşılmaz.

Madde 8. Doğru: A. Python açıkça bir değer döndürülmediğinde örtük olarak None döndürür.

B yanlış: Son satırdaki hesap en son yapılan iş olduğu için sonucun o olduğu sanılabilir. Ama son satırın değeri kendiliğinden dönmez; değer ancak return ile çağıran koda gider.
C yanlış: Fonksiyon ekrana bir şey yazmadığında “boş” bir sonuç verdiği düşünülebilir. Ama boş metin de bir değerdir ve kendiliğinden döndürülmez.
D yanlış: None da False da “yok” ya da “olmadı” anlamına yakın durduğu için karıştırılır. Ama False bir bool değeridir ve varsayılan olarak döndürülmez.
E yanlış: Toplam ya da sayaç gibi değişkenlere 0 ile başladığımız için “hiçbir şey” sıfır gibi düşünülebilir. Ama Python sayısal bir varsayılan döndürmez.

Madde 9. Doğru: C. a 6 olur, sonra 6’nın iki katı olan 12 bye atanır.

A yanlış: Kodda iki_kat adı üç kez geçtiği (tanım ve iki çağrı) için değerin üç kez katlandığı sanılabilir. Ama tanım fonksiyonu çalıştırmaz; yalnızca iki çağrı var.
B yanlış: None bu bölümde sık geçtiği için dönüş değeri olan her soruda akla gelebilir. Ama iki_kat değeri return ile açıkça döndürüyor.
D yanlış: iki_kat(3) çağrısı yalnız bir kez düşünülürse sonuç 6 bulunur. Ama bu a’nın değeridir; b, a’yı yeniden ikiye katlayan ikinci çağrının sonucudur.
E yanlış: b = iki_kat(a) satırında a yerine ilk argüman olan 3 düşünülürse çağrılar hiç etki etmiyormuş gibi görünür. Ama ilk çağrı değeri zaten ikiye katlıyor.

Madde 10. Doğru: C. Her parça ayrı ayrı okunabilir, denenebilir ve düzeltilebilir. Küçük bir fonksiyonun doğruluğu tek başına sınanabilir; hata da tek bir yerde aranır.

A yanlış: Tekrar eden kod azalınca programın da hafifleyeceği düşünülebilir. Ama fonksiyon çağrısı kendi başına bellek kazandırmaz.
B yanlış: int() gibi dönüşümler de birer fonksiyon olduğu için her fonksiyonun dönüşüm yaptığı sanılabilir. Ama tür dönüşümünü yine int() gibi fonksiyonlarla açıkça yazmanız gerekir.
D yanlış: Düzenli yazılmış kodun daha az hata vereceği düşünülebilir. Ama söz dizimi hataları fonksiyon içinde de çıkar.
E yanlış: Kod tekrarı azaldığı için satır sayısının da düşeceği beklenir. Ama def satırları eklendiği için toplam satır sayısı artabilir; fonksiyonun yararı kodu daha kolay okunur yapmasıdır.

Tek sayfa özet

Bu hafta programı adlandırılmış ve yeniden kullanılabilir parçalara ayırmaya başladık.

Fonksiyon def ile tanımlanır, adı ve parantezleriyle çağrılır.
Çağrı satırı çalıştığında fonksiyon henüz tanımlanmamışsa NameError oluşur. Bu yüzden tanımları onları kullanan koddan önce yazın.
Parametre fonksiyon tanımındaki addır; argüman çağrıda verilen değerdir.
Zorunlu parametre sayısı ile verilen argüman sayısı uyuşmazsa TypeError oluşabilir.
print() değeri ekrana yazar; return fonksiyonun sonucunu çağıran koda gönderir.
Hiçbir return satırı çalışmayan fonksiyon örtük olarak, yani kodda yazılmadan None döndürür.
return çalıştığında fonksiyon sona erer.
Fonksiyonun dönüş değeri başka değişkenlerde ve ifadelerde kullanılabilir.
İyi yazılmış küçük bir fonksiyonun işi çoğu zaman tek cümleyle anlatılabilir.
Problemi küçük fonksiyonlara ayırmak kodu okumayı, denemeyi ve hatayı bulmayı kolaylaştırır.
Açılıştaki indirim kartı bir fonksiyondur: boş kutular parametre, kasiyerin yazdığı değerler argüman, kasiyerin eline verilen sonuç dönüş değeridir. “Hediyeyse 0 ver ve dur” kuralı return 0 satırıdır.

Bir sonraki bölümde fonksiyon tasarlarken “çalışıyor mu?” sorusunun yanında şunları da soracağız: Hangi girdileri kabul etmeli, hangi sonucu döndürmeli, bunu nasıl doğrularız?

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

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

Fonksiyon tanımı ile fonksiyon çağrısını birbirinden ayırt eder.
Parametre ile argümanı ayırt eder ve sayıları uyuşmadığında oluşan TypeError hatasını açıklar.
print() ile return arasındaki farkı açıklar.
return çalıştığında fonksiyonun sona erdiğini belirler.
Değer döndürmeyen bir fonksiyonun None döndürdüğünü açıklar.
Fonksiyonun dönüş değerini başka ifadelerde ve çağrılarda kullanır.
Problemi küçük fonksiyonlara ayırmanın gerekçesini açıklar.