---
baslik: Parametreler ve dönüş değeri
bolum: Fonksiyonlar
ozet: Tür belirtmek, varsayılan değer, adlı argüman, birden çok değer döndürmek
---

Fonksiyonlar büyüdükçe "bu parametreye ne vermeliyim?" sorusu önem kazanır. Türleri yazmak, varsayılan değer vermek ve adlı argüman kullanmak fonksiyonunu hem güvenli hem rahat kullanılır yapar.

## Türleri yazmak

Parametrenin türünü `ad: tur`, dönüş türünü `-> tur` ile yazarsın. Zorunlu değil ama yazarsan derleyici denetler.

```kbl
fonksiyon dikdortgen_alani(en: sayi, boy: sayi) -> sayi:
    don en * boy

fonksiyon ortalama(a: ondalik, b: ondalik) -> ondalik:
    don (a + b) / 2.0

yazdir(dikdortgen_alani(3, 4))
yazdir(ortalama(72.0, 85.0))
```
```cikti
12
78.5
```

Yanlış türde değer verirsen program çalışmadan uyarılırsın:

```kbl goster
fonksiyon kare(x: sayi) -> sayi:
    don x * x

yazdir(kare("üç"))   # hata: 'x' parametresi 'sayi' bekler, 'metin' verildi
```

## Varsayılan değer

Bir parametreye `= değer` ile varsayılan verirsen, çağıran o değeri yazmadığında varsayılan kullanılır. Varsayılanlı parametreler en sona yazılır.

```kbl
fonksiyon kdvli_fiyat(fiyat: ondalik, oran: sayi = 20) -> ondalik:
    don fiyat * (1.0 + ondalik(oran) / 100.0)

yazdir(f"{kdvli_fiyat(100.0):.2f}")
yazdir(f"{kdvli_fiyat(100.0, 10):.2f}")
```
```cikti
120.00
110.00
```

## Adlı argüman

Çağırırken parametrenin adını yazarsan kod daha okunur olur, sıra karışmaz.

```kbl
fonksiyon selamla(ad: metin, unvan: metin = "") -> metin:
    eger unvan.bos_mu():
        don f"Merhaba {ad}"
    don f"Merhaba {unvan} {ad}"

yazdir(selamla("Ayşe"))
yazdir(selamla("Kaya", "Dr."))
yazdir(selamla(ad="Can", unvan="Av."))
```
```cikti
Merhaba Ayşe
Merhaba Dr. Kaya
Merhaba Av. Can
```

## Mantık döndüren fonksiyon

Adı `_mi` ile biten, `dogru`/`yanlis` döndüren fonksiyonlar `eger` içinde çok doğal okunur.

```kbl
fonksiyon asal_mi(n: sayi) -> mantik:
    eger n < 2:
        don yanlis
    bolen = 2
    iken bolen * bolen <= n:
        eger n % bolen == 0:
            don yanlis
        bolen += 1
    don dogru

dongu aday icinde [2, 9, 17, 21]:
    eger asal_mi(aday):
        yazdir(f"{aday} asaldır")
    degilse:
        yazdir(f"{aday} asal değildir")
```
```cikti
2 asaldır
9 asal değildir
17 asaldır
21 asal değildir
```

## Liste döndürmek

Fonksiyon bir liste de döndürebilir.

```kbl
fonksiyon bolenler(n: sayi) -> liste<sayi>:
    bulunan = []
    dongu i icinde 1..n:
        eger n % i == 0:
            bulunan.ekle(i)
    don bulunan

yazdir(bolenler(36))
```
```cikti
[1, 2, 3, 4, 6, 9, 12, 18, 36]
```

## Birden çok değer döndürmek

`don a, b` iki değer döndürür; çağıran taraf `x, y = ...` ile ikisini birden alır.

```kbl
fonksiyon bol_ve_kalan(a: sayi, b: sayi):
    don a // b, a % b

bolum, kalan = bol_ve_kalan(17, 5)
yazdir(f"17 = 5 x {bolum} + {kalan}")
```
```cikti
17 = 5 x 3 + 2
```

## Fonksiyona verilen liste kopyalanır

Fonksiyona bir liste verdiğinde fonksiyon onun **kopyasıyla** çalışır. İçeride yapılan değişiklik dışarıdaki listeyi etkilemez. Değişikliği görmek istiyorsan sonucu döndürüp yeniden atarsın.

```kbl
fonksiyon sifir_ekle(l: liste<sayi>) -> liste<sayi>:
    l.ekle(0)
    don l

sayilar = [5, 6]
yeni = sifir_ekle(sayilar)
yazdir(sayilar)
yazdir(yeni)
sayilar = sifir_ekle(sayilar)
yazdir(sayilar)
```
```cikti
[5, 6]
[5, 6, 0]
[5, 6, 0]
```

> **Dikkat:** Bir fonksiyonun bütün `don` dalları aynı türü döndürmeli. Bir dalda `don 0`, başka dalda `don toplam / adet` (ondalık) yazarsan derleme hatası alırsın; o dalda `don 0.0` yaz.

## Alıştırma

```alistirma
`indirimli(fiyat: ondalik, yuzde: sayi = 10) -> ondalik` fonksiyonunu yaz: fiyattan yüzde kadar indirim düşsün. `indirimli(200.0)` ve `indirimli(200.0, 25)` sonuçlarını 2 basamakla yazdır.
%%%
# buraya yaz

yazdir(f"{indirimli(200.0):.2f}")
yazdir(f"{indirimli(200.0, 25):.2f}")
%%%
fonksiyon indirimli(fiyat: ondalik, yuzde: sayi = 10) -> ondalik:
    don fiyat - fiyat * ondalik(yuzde) / 100.0

yazdir(f"{indirimli(200.0):.2f}")
yazdir(f"{indirimli(200.0, 25):.2f}")
%%%
180.00
150.00
```

```alistirma
`en_kucuk_en_buyuk(l: liste<sayi>)` fonksiyonu listedeki en küçük ve en büyük değeri birlikte döndürsün. Sonucu iki değişkene alıp `3 - 41` biçiminde yazdır.
%%%
# buraya yaz

kucuk, buyuk = en_kucuk_en_buyuk([17, 3, 41, 8])
yazdir(f"{kucuk} - {buyuk}")
%%%
fonksiyon en_kucuk_en_buyuk(l: liste<sayi>):
    enk = l[0]
    enb = l[0]
    dongu x icinde l:
        eger x < enk:
            enk = x
        eger x > enb:
            enb = x
    don enk, enb

kucuk, buyuk = en_kucuk_en_buyuk([17, 3, 41, 8])
yazdir(f"{kucuk} - {buyuk}")
%%%
3 - 41
```