---
baslik: Fonksiyon tanımlama
bolum: Fonksiyonlar
ozet: Bir işi adlandırıp istediğin kadar çağırmak
---

Aynı kodu programın üç yerinde yazıyorsan, bir yerde hata yaptığında üç yerde düzeltmen gerekir. Fonksiyon, bir işi yapan ve bir adı olan kod bloğudur: bir kez yazarsın, istediğin kadar çağırırsın.

## İlk fonksiyonun

Tanım `fonksiyon ad():` ile başlar; gövdesi girintilidir. Fonksiyon tanımlandığında çalışmaz, **çağrıldığında** çalışır.

```kbl
fonksiyon ayrac():
    yazdir("─".tekrarla(20))

ayrac()
yazdir("Günün menüsü")
ayrac()
```
```cikti
────────────────────
Günün menüsü
────────────────────
```

## Parametre almak

Parantez içine yazdığın ad bir **parametredir**. Çağırırken verdiğin değer onun yerine geçer.

```kbl
fonksiyon selamla(ad):
    yazdir(f"Merhaba {ad}, hoş geldin.")

selamla("Zeynep")
selamla("Mehmet")
```
```cikti
Merhaba Zeynep, hoş geldin.
Merhaba Mehmet, hoş geldin.
```

Birden çok parametre virgülle ayrılır; değerler aynı sırayla verilir.

```kbl
fonksiyon fis_satiri(urun, adet, fiyat):
    yazdir(f"{urun:<10}{adet:>3} x {fiyat:>6.2f}")

fis_satiri("Ekmek", 2, 12.5)
fis_satiri("Peynir", 1, 149.0)
```
```cikti
Ekmek       2 x  12.50
Peynir      1 x 149.00
```

## Değer döndürmek: don

`don` sonucu çağıran yere geri verir. Dönen değeri bir değişkene atayabilir ya da doğrudan kullanabilirsin.

```kbl
fonksiyon kare(x):
    don x * x

alan = kare(7)
yazdir(alan)
yazdir(kare(3) + kare(4))
```
```cikti
49
25
```

`don` fonksiyonu orada bitirir; altındaki satırlar çalışmaz. Cevap belli olduğu anda çıkmak kodu sadeleştirir.

```kbl
fonksiyon not_harfi(puan):
    eger puan >= 85:
        don "AA"
    eger puan >= 70:
        don "BA"
    eger puan >= 50:
        don "CC"
    don "FF"

yazdir(not_harfi(92))
yazdir(not_harfi(74))
yazdir(not_harfi(31))
```
```cikti
AA
BA
FF
```

## Fonksiyon fonksiyonu çağırabilir

```kbl
fonksiyon cift_mi(n):
    don n % 2 == 0

fonksiyon ciftleri_yaz(son):
    dongu i icinde 1..son:
        eger cift_mi(i):
            konsol.yaz(f"{i} ")
    yazdir()

ciftleri_yaz(12)
```
```cikti
2 4 6 8 10 12
```

## Dışarıdaki değişkenler: okumak serbest, değiştirmek bildirim ister

Fonksiyon, kendisinden önce dosyada tanımlanmış bir değişkeni **okuyabilir**:

```kbl
kdv_orani = 20

fonksiyon kdv(fiyat):
    don fiyat * kdv_orani // 100

yazdir(kdv(450))
```
```cikti
90
```

Ama fonksiyonun içinde ona yeni bir değer **atamak** derleme hatasıdır:

```kbl goster
sayac = 0

fonksiyon arttir():
    sayac = sayac + 1    # hata: 'sayac' fonksiyonun dışında tanımlı
```

Neden? Bir fonksiyonun dışarıdaki bir değeri sessizce değiştirmesi, programın bambaşka bir yerinde "bu değer neden değişti?" sorusunu doğurur. Gerçekten değiştirmek istiyorsan fonksiyonun **ilk satırına** `kuresel` yazarak bunu açıkça söylersin:

```kbl
sayac = 0

fonksiyon arttir():
    kuresel sayac
    sayac = sayac + 1

arttir()
arttir()
yazdir(sayac)
```
```cikti
2
```

Birden çok değişken için adları virgülle ayır: `kuresel toplam, adet`. Çoğu zaman daha temiz yol ise değeri parametre olarak alıp `don` ile geri vermektir; böylece neyin değiştiği çağrının olduğu satırda görünür:

```kbl
fonksiyon arttir(n):
    don n + 1

sayac = 0
sayac = arttir(sayac)
sayac = arttir(sayac)
yazdir(sayac)
```
```cikti
2
```

> **İpucu:** Fonksiyonlarını dosyanın başına yaz, programın asıl işini altlarına koy; fonksiyonun içinde de kendine özgü adlar seç.

## Gerçek bir örnek

```kbl
fonksiyon kdvli(fiyat):
    don fiyat * 1.20

fonksiyon fiyat_yaz(urun, fiyat):
    yazdir(f"{urun}: {fiyat:.2f} TL (KDV dahil {kdvli(fiyat):.2f} TL)")

fiyat_yaz("Kulaklık", 850.0)
fiyat_yaz("Kılıf", 120.0)
```
```cikti
Kulaklık: 850.00 TL (KDV dahil 1020.00 TL)
Kılıf: 120.00 TL (KDV dahil 144.00 TL)
```

## Alıştırma

```alistirma
`cevre(en, boy)` adında, bir dikdörtgenin çevresini döndüren bir fonksiyon yaz. Sonra `cevre(5, 3)` ve `cevre(10, 10)` sonuçlarını ayrı satırlarda yazdır.
%%%
# buraya yaz

yazdir(cevre(5, 3))
yazdir(cevre(10, 10))
%%%
fonksiyon cevre(en, boy):
    don 2 * (en + boy)

yazdir(cevre(5, 3))
yazdir(cevre(10, 10))
%%%
16
40
```

```alistirma
`buyuk_olan(a, b)` adında, iki sayıdan büyük olanı döndüren bir fonksiyon yaz. Sonra onu kullanarak üç sayının en büyüğünü bulup yazdır.
%%%
# buraya yaz

yazdir(buyuk_olan(buyuk_olan(14, 27), 9))
%%%
fonksiyon buyuk_olan(a, b):
    eger a > b:
        don a
    don b

yazdir(buyuk_olan(buyuk_olan(14, 27), 9))
%%%
27
```