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 hangi sonucu verdiğine de bakacağız.

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; ileride karşınıza çıkar ama bu derste ezberlemeniz beklenmiyor.

Fonksiyon ekrana mı yazar, değer mi döndürür?

İkisinde de sonuç ekranda aynı görünebilir, ama ekrana yazılan bir sonucu programın geri kalanı kullanamaz. Bölüm boyunca şu soruya döneceğiz: hesabı kim yapıyor, sonuç ekrana mı gidiyor, programın geri kalanına mı?

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 = 8
yukseklik2 = 3
alan2 = genislik2 * yukseklik2

Aynı hesaplamayı tekrar etmek yerine ona bir ad verebiliriz:

def dikdortgen_alani(genislik, yukseklik):
    return genislik * yukseklik

Artık farklı değerlerle aynı işlemi çağırabiliriz:

alan1 = dikdortgen_alani(4, 6)
alan2 = dikdortgen_alani(8, 3)

print(alan1)
print(alan2)

Burada fonksiyonun iki yararı var:

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

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")

Bu kod fonksiyonu tanımlar, ama henüz çalıştırmaz. Fonksiyonu çalıştırmak için onu adıyla ve parantezle çağırırız:

selamla()

Aşağıdaki programın çıktısını çalıştırmadan önce tahmin edin:

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

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

Python dosyayı yukarıdan aşağıya satır satır çalıştırır. Bu yüzden bir fonksiyon çağrısına geldiğinde o fonksiyonun def bloğu daha önce çalışmış olmalıdır:

# selamla()   # Bu satır burada çalıştırılırsa NameError oluşur.

def selamla():
    print("Merhaba")

selamla()      # Bu çağrı geçerlidir.

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ğırırsak:

selamla("Deniz")

Çağrıda parantezin içine yazılan "Deniz" ise argümandır: parametreye o çağrıda verilen değer.

Bu ayrımı şöyle düşünebilirsiniz:

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

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

Bir fonksiyon birden fazla parametre alabilir:

def toplam_fiyat(birim_fiyat, adet):
    return birim_fiyat * adet

print(toplam_fiyat(25, 4))
print(toplam_fiyat(12.5, 3))

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

Yukarıdaki fonksiyon iki zorunlu parametre bekler. Eksik veya fazla argümanla çağrılırsa Python TypeError hatası verir:

# toplam_fiyat(25)
# TypeError: toplam_fiyat() missing 1 required positional argument: 'adet'

Üç argüman vermek de aynı hatayı verir. Hata mesajında “missing” (eksik) veya “takes … but … were given” (… argüman alır ama … verildi) gibi ifadeler görürseniz çağrıdaki argüman sayısını fonksiyon tanımıyla karşılaştı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

Fonksiyonun işi ekrana bir şey yazmakla sınırlı değildir. Çoğu zaman hesaplanan değeri programın başka bir yerinde kullanmak isteriz.

def kare(sayi):
    return sayi * sayi

sonuc = kare(5)
print(sonuc)

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 25’tir ve 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 görünüşte benzer olsa da aynı işi yapmaz:

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

def dondurerek_topla(a, b):
    return a + b

Birincisi sonucu yalnızca ekrana yazar. İkincisinin sonucunu başka bir hesapta kullanabiliriz:

ara_toplam = dondurerek_topla(10, 20)
genel_toplam = ara_toplam + 5
print(genel_toplam)

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 deger satırı çalışmadıysa fonksiyon yine de bir değer döndürür: None. Burada None, “bu fonksiyon işe yarar bir sonuç döndürmedi” demektir.

Şu örneği inceleyin:

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

sonuc = ortalama_yazdir(70, 90)
print("Dönen değer:", sonuc)

Çıktı:

80.0
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 hesaplamada 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:

def kdv_hesapla(tutar, oran):
    return tutar * oran

urun_tutari = 500
kdv = kdv_hesapla(urun_tutari, 0.20)
odenecek = urun_tutari + kdv

print(odenecek)

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 indirimi ve KDV’yi hesaplayalım:

def indirim_hesapla(tutar, oran):
    return tutar * oran

def kdv_hesapla(tutar, oran):
    return tutar * oran

urunler_toplami = 1000
indirim = indirim_hesapla(urunler_toplami, 0.10)
indirimli_tutar = urunler_toplami - indirim
kdv = kdv_hesapla(indirimli_tutar, 0.20)
odenecek = indirimli_tutar + kdv

print(odenecek)

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ılarını 7. haftada ele alacağız. Şimdilik şu ilke yeterlidir:

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

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.

Üret: indirimli fiyat fonksiyonu

Bir ürünün fiyatını ve indirim oranını alan, indirim sonrası fiyatı döndüren bir fonksiyon yazın.

Başlangıç:

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ı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ış: Tanımdaki adlar parametredir.
B yanlış: Çağrıda verilen değerler argümandır.
C yanlış: Parametreler fonksiyon çağrıldığında oluşan yerel değişkenlerdir.
D yanlış: Terimler ters yazılmış.

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ış: 80 >= 50 doğrudur; ilk return çalışır.
B yanlış: İlk return fonksiyonu sonlandırdığı için ikincisine sıra gelmez.
C yanlış: Fonksiyon açık bir değer döndürüyor.
D yanlış: 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 ifadenin değeri kendiliğinden dönmez; bu bazı başka dillerin davranışıdır.
C yanlış: Boş metin de kendiliğinden döndürülmez.
D yanlış: False bir bool değeridir ve varsayılan olarak döndürülmez.
E yanlış: Sayısal bir varsayılan yoktur.

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

A yanlış: Yalnızca iki çağrı var; değer iki kez katlanır, üç kez değil.
B yanlış: Fonksiyon açıkça bir değer döndürüyor.
D yanlış: Bu a değeridir; b ikinci çağrının sonucudur.
E yanlış: İlk ç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 yazmak güvenlidir.
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 değer döndürmeyen fonksiyon örtük olarak 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ı, test etmeyi ve hata ayıklamayı kolaylaştırı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ırır.
Parametre ile argümanı ayırır ve sayıları uyuşmadığında TypeError oluşacağını bilir.
print() ile return arasındaki farkı gösterir.
return çalıştığında fonksiyonun sona erdiğini belirler.
Değer döndürmeyen bir fonksiyonun None döndürdüğünü bilir.
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.