Dersler ve Temeller; web örnekleri PORT ortam değişkenini okur

- dersler/: 29 kısa ders (açıklama, çalıştırılabilir örnek, alıştırma). Her örneğin ve alıştırma çözümünün çıktısı Online IDE'nin hazırlık adımında gerçekten koşulup dosyadakiyle karşılaştırılır; biçim dersler/BICIM.md. - temeller/: tek konulu 12 başlangıç programı. - web/anket, web/kisalt, web/pano: port PORT ortam değişkeninden okunur (Online IDE önizlemesi 8080 verir), yoksa eski sabit port. - README: öğrenme bölümü, Online IDE bağlantısı.
2026-10-17 22:07:47 +03:00
parent c5468f5d0a
commit 494781e84f
47 changed files with 5942 additions and 4 deletions
@@ -13,8 +13,21 @@ kabalang calistir konsol/fraktal/fraktal.kbl

 ![KabaLang Kcode içinde](medya/kcode.png)

+**Tarayıcıda dene:** bütün örnekler ve dersler [ide.kabaforce.com](https://ide.kabaforce.com)
+adresindeki Online IDE'de kurulumsuz çalışır.
+
 ---

+## KabaLang'ı öğren
+
+- [**Dersler**](dersler): sıfırdan 29 kısa ders: giriş, temeller, akış denetimi, veri
+  yapıları, fonksiyonlar, kendi türlerin, hatalar ve dosyalar. Her derste açıklama,
+  çalıştırılabilir örnekler ve alıştırmalar var; örneklerin çıktısı yayından önce gerçekten
+  koşulup doğrulanır (biçim: [dersler/BICIM.md](dersler/BICIM.md)).
+- [**Temeller**](temeller): her biri tek konuyu baştan sona gösteren 12 küçük program
+  (merhaba, değişkenler, girdi, koşullar, döngüler, fonksiyonlar, listeler, sözlükler,
+  metinler, yapılar, hatalar, dosyalar).
+
 ## Konsol

 | | Proje | Ne gösteriyor |
@@ -39,10 +52,10 @@ kabalang calistir konsol/fraktal/fraktal.kbl
 | ![](medya/kisalt-istatistik.png) | [**Kısalt**](web/kisalt) | Bağlantı kısaltıcı: gerçek 302 yönlendirme, tıklama sayacı, sunucuda çizilen SVG grafik |
 | ![](medya/anket.png) | [**Anket**](web/anket) | Canlı anket: adres başına tek oy, POST → 303 → GET, sonuç grafiği KabaLang'da üretilir |

-Web uygulamaları yalnız `127.0.0.1`'i dinler. Kullanıcıdan gelen her değer
+Web uygulamaları yalnız `127.0.0.1`'i dinler; port `PORT` ortam değişkeniyle değiştirilebilir. Kullanıcıdan gelen her değer
 SQL'e **parametre olarak** bağlanır, HTML'e girerken `web.kacir` ile kaçırılır.

-## Çekirdek
+## Sistem programlama (çekirdek)

 | | Proje | Ne gösteriyor |
 |---|---|---|
@@ -0,0 +1,107 @@
+---
+baslik: KabaLang'a giriş
+bolum: Giriş
+ozet: İlk programın, yazdir ve örnekleri IDE'de çalıştırmak
+---
+
+KabaLang, anahtar sözcükleri Türkçe olan bir programlama dilidir. `eger`, `dongu`, `fonksiyon` gibi sözcüklerle yazarsın; derleyici programını hızlı çalışan bir makine koduna çevirir.
+
+Bu derslerde her konuyu küçük örneklerle öğreneceksin. Her örneğin altında programın gerçek çıktısı var. **Dene** düğmesine basınca örnek düzenleyicide açılır; değiştirip yeniden çalıştırabilirsin.
+
+## İlk programın
+
+Ekrana bir şey yazdırmak için `yazdir(...)` kullanılır. Parantez içindeki metin ekrana basılır ve satır biter.
+
+```kbl
+yazdir("Merhaba, dünya!")
+```
+```cikti
+Merhaba, dünya!
+```
+
+Metinler çift tırnak arasına yazılır. Türkçe harfler olduğu gibi çalışır.
+
+## Birden çok satır
+
+Program yukarıdan aşağıya, satır satır çalışır. Her `yazdir` yeni bir satıra yazar.
+
+```kbl
+yazdir("Günaydın İstanbul!")
+yazdir("Bugün hava güneşli.")
+yazdir("Çay demlendi.")
+```
+```cikti
+Günaydın İstanbul!
+Bugün hava güneşli.
+Çay demlendi.
+```
+
+## Sayı yazdırmak ve hesap yapmak
+
+`yazdir` yalnız metin değil, sayı da yazar. Parantez içine bir hesap koyarsan önce hesaplanır, sonra sonucu yazılır.
+
+```kbl
+yazdir(42)
+yazdir(7 * 6)
+yazdir(100 - 58)
+```
+```cikti
+42
+42
+42
+```
+
+## Virgülle birden çok değer
+
+`yazdir`'a virgülle ayırarak birden çok değer verebilirsin. Aralarına birer boşluk konur.
+
+```kbl
+yazdir("Bir yılda", 12, "ay var.")
+yazdir("Bir günde", 24 * 60, "dakika var.")
+```
+```cikti
+Bir yılda 12 ay var.
+Bir günde 1440 dakika var.
+```
+
+Boş bir `yazdir()` araya boş bir satır koyar.
+
+```kbl
+yazdir("Birinci bölüm")
+yazdir()
+yazdir("İkinci bölüm")
+```
+```cikti
+Birinci bölüm
+
+İkinci bölüm
+```
+
+> **Dikkat:** `yazdir` küçük harfle yazılır. `Yazdir("x")` yazarsan derleyici "'Yazdir' adında bir değişken veya fonksiyon tanımlanmamış" der. KabaLang büyük ve küçük harfi ayırır.
+
+> **İpucu:** Örnekleri yalnız okuma; **Dene**'ye basıp metni değiştir, kendi adını yazdır. En hızlı böyle öğrenirsin.
+
+## Alıştırma
+
+```alistirma
+Ekrana iki satır yazdır: önce `Merhaba KabaLang`, sonra `Programlamaya başladım.`
+%%%
+yazdir("Merhaba KabaLang")
+# buraya yaz
+%%%
+yazdir("Merhaba KabaLang")
+yazdir("Programlamaya başladım.")
+%%%
+Merhaba KabaLang
+Programlamaya başladım.
+```
+
+```alistirma
+Bir haftada kaç saat olduğunu hesaplatıp `Bir haftada 168 saat var.` biçiminde yazdır. Sayıyı kendin yazma, `7 * 24` hesabını kullan.
+%%%
+# buraya yaz
+%%%
+yazdir("Bir haftada", 7 * 24, "saat var.")
+%%%
+Bir haftada 168 saat var.
+```
@@ -0,0 +1,118 @@
+---
+baslik: Sözdizimi ve girinti
+bolum: Giriş
+ozet: Satırlar, iki nokta, girintili bloklar ve büyük/küçük harf
+---
+
+Her dilin bir yazım kuralı vardır. KabaLang'de kurallar az ve sade: her komut kendi satırında durur, bloklar süslü parantezle değil **girintiyle** belirtilir.
+
+## Her satır bir komut
+
+Satır sonuna noktalı virgül koymazsın. Satır bitince komut da biter.
+
+```kbl
+yazdir("Ankara")
+yazdir("İzmir")
+```
+```cikti
+Ankara
+İzmir
+```
+
+## Bloklar: iki nokta ve girinti
+
+Bazı satırlar bir **blok** açar: `eger`, `dongu`, `fonksiyon` gibi. Bu satırlar `:` ile biter. Altındaki satırlar 4 boşluk içeriden başlar; o satırlar bloğa aittir.
+
+```kbl
+sicaklik = 32
+eger sicaklik > 30:
+    yazdir("Hava çok sıcak.")
+    yazdir("Bol su iç.")
+yazdir("Bu satır her zaman çalışır.")
+```
+```cikti
+Hava çok sıcak.
+Bol su iç.
+Bu satır her zaman çalışır.
+```
+
+Girintisi biten satır, bloğun dışına çıkmış olur. Yukarıdaki son satır `eger`'e bağlı değildir.
+
+Sıcaklığı 20 yapıp **Dene** ile çalıştır: ilk iki satır kaybolur, son satır yine görünür.
+
+## İç içe bloklar
+
+Bir bloğun içinde başka bir blok açabilirsin. Her düzey 4 boşluk daha içeride başlar.
+
+```kbl
+sicaklik = 32
+yagmur = yanlis
+eger sicaklik > 25:
+    yazdir("Hava sıcak.")
+    eger degil yagmur:
+        yazdir("Pikniğe gidebilirsin.")
+```
+```cikti
+Hava sıcak.
+Pikniğe gidebilirsin.
+```
+
+> **Dikkat:** `:`'dan sonraki satırı girintisiz yazmak hatadır. Aşağıdaki kod derlenmez; derleyici "blok gövdesi boş — ':' sonrasındaki satırlar girintili olmalı" der.
+
+```kbl goster
+eger dogru:
+yazdir("girinti unutuldu")
+```
+
+Sebepsiz girinti de hatadır: blok açmayan bir satırın altını içeriden başlatamazsın. Bir de `:`'yı unutursan derleyici "':' bekleniyordu" der.
+
+## Büyük ve küçük harf
+
+KabaLang büyük/küçük harfi ayırır. `sehir`, `Sehir` ve `SEHIR` üç ayrı addır. Anahtar sözcükler (`eger`, `dongu`, `dogru`) ve hazır fonksiyonlar (`yazdir`) hep küçük harfle yazılır.
+
+```kbl
+sehir = "Bursa"
+Sehir = "Konya"
+yazdir(sehir)
+yazdir(Sehir)
+```
+```cikti
+Bursa
+Konya
+```
+
+> **İpucu:** Kodda Türkçe karakterli ad kullanmak yerine ASCII harfler yeğle: `sehir`, `ogrenci`, `dogru`. Anahtar sözcükler de böyle yazılır (`degilse`, `iken`). Metinlerin içinde ise ç, ğ, ı, ö, ş, ü'yü serbestçe kullan.
+
+## Uzun satırı bölmek
+
+Parantez açıkken satırı bölebilirsin; parantez kapanana kadar tek satır sayılır.
+
+```kbl
+toplam = (120 +
+    75 +
+    300)
+yazdir(toplam)
+```
+```cikti
+495
+```
+
+## Alıştırma
+
+```alistirma
+`puan` 50'den büyükse önce `Geçtin.` sonra `Tebrikler!` yazdır. Bu iki satır bloğun içinde olsun. En sonda, bloğun dışında `Sınav bitti.` yazdır.
+%%%
+puan = 72
+eger puan > 50:
+    # buraya yaz
+%%%
+puan = 72
+eger puan > 50:
+    yazdir("Geçtin.")
+    yazdir("Tebrikler!")
+yazdir("Sınav bitti.")
+%%%
+Geçtin.
+Tebrikler!
+Sınav bitti.
+```
@@ -0,0 +1,94 @@
+---
+baslik: Yorumlar
+bolum: Giriş
+ozet: Kodun içine kendine ve başkalarına not bırakmak
+---
+
+Yorum, derleyicinin okumadığı, yalnız insanlar için yazılmış nottur. Bir hafta sonra kendi koduna baktığında "bunu neden yazmıştım?" diye sormamak için yorum yazarsın.
+
+## Tek satırlık yorum
+
+`#` işaretinden sonra satırın sonuna kadar her şey yorumdur.
+
+```kbl
+# Bu program bir selam yazar.
+yazdir("Merhaba!")
+```
+```cikti
+Merhaba!
+```
+
+## Satır sonunda yorum
+
+Kodun yanına da yorum yazabilirsin. `#`'den öncesi çalışır, sonrası yok sayılır.
+
+```kbl
+fiyat = 250        # TL cinsinden
+adet = 3           # sepetteki ürün sayısı
+yazdir(fiyat * adet)
+```
+```cikti
+750
+```
+
+## Kodu geçici olarak kapatmak
+
+Bir satırın başına `#` koyarsan o satır çalışmaz. Silmeden denemek için çok işe yarar.
+
+```kbl
+yazdir("Birinci satır")
+# yazdir("Bu satır şimdilik kapalı")
+yazdir("Üçüncü satır")
+```
+```cikti
+Birinci satır
+Üçüncü satır
+```
+
+## Metnin içindeki # yorum değildir
+
+Tırnak içindeki `#` sıradan bir karakterdir.
+
+```kbl
+yazdir("Sıra numaran: #12")   # bu kısım ise yorum
+```
+```cikti
+Sıra numaran: #12
+```
+
+> **İpucu:** İyi yorum kodun *ne* yaptığını değil *neden* yaptığını anlatır. `x = x + 1  # x'i bir artır` gereksizdir; `misafir += 1  # kapıdaki kişiyi de sayıyoruz` işe yarar.
+
+## Birden çok satırlık açıklama
+
+Uzun bir açıklama için her satırın başına `#` koyarsın.
+
+```kbl
+# Kargo ücreti hesabı:
+#   500 TL ve üstü siparişte kargo ücretsiz,
+#   altında 60 TL.
+sepet = 420
+kargo = 60
+eger sepet >= 500:
+    kargo = 0
+yazdir("Kargo:", kargo, "TL")
+```
+```cikti
+Kargo: 60 TL
+```
+
+## Alıştırma
+
+```alistirma
+Aşağıdaki programda ikinci satır hatalı bir duyuru yazıyor. O satırı **silmeden**, başına `#` koyarak kapat. Çıktıda yalnız iki doğru satır kalsın.
+%%%
+yazdir("Kütüphane 09:00'da açılır.")
+yazdir("Kütüphane pazar günü de açıktır.")
+yazdir("Kütüphane 18:00'de kapanır.")
+%%%
+yazdir("Kütüphane 09:00'da açılır.")
+# yazdir("Kütüphane pazar günü de açıktır.")
+yazdir("Kütüphane 18:00'de kapanır.")
+%%%
+Kütüphane 09:00'da açılır.
+Kütüphane 18:00'de kapanır.
+```
@@ -0,0 +1,156 @@
+---
+baslik: Değişkenler
+bolum: Temeller
+ozet: Değerlere ad vermek, yeniden atamak ve değişmezler
+---
+
+Program çalışırken bilgileri bir yerde tutman gerekir: bir öğrencinin adı, sepetteki ürün sayısı, bugünkü sıcaklık. Değişken, bir değere verdiğin addır.
+
+## Değişken oluşturmak
+
+`ad = değer` yazınca değer o ada bağlanır. Sonra o adı her kullandığında değeri gelir.
+
+```kbl
+ogrenci = "Elif"
+yas = 15
+yazdir(ogrenci)
+yazdir(yas)
+```
+```cikti
+Elif
+15
+```
+
+Türü yazmana gerek yoktur; KabaLang değere bakıp anlar. `"Elif"` bir metin, `15` bir tam sayıdır.
+
+## Değeri değiştirmek
+
+Bir değişkene yeni değer atayınca eskisi unutulur.
+
+```kbl
+sicaklik = 18
+yazdir(sicaklik)
+sicaklik = 24
+yazdir(sicaklik)
+```
+```cikti
+18
+24
+```
+
+Değişkenin yeni değerini eskisinden de hesaplayabilirsin.
+
+```kbl
+bakiye = 500
+bakiye = bakiye - 120
+bakiye = bakiye + 75
+yazdir(bakiye)
+```
+```cikti
+455
+```
+
+## Kısaltmalar: += ve -=
+
+`bakiye = bakiye + 75` yerine `bakiye += 75` yazabilirsin. `-=` ve `*=` de aynı mantıkla çalışır.
+
+```kbl
+puan = 10
+puan += 5      # puan = puan + 5
+puan *= 2      # puan = puan * 2
+puan -= 4      # puan = puan - 4
+yazdir(puan)
+```
+```cikti
+26
+```
+
+## Değişken adları
+
+- Harfle ya da `_` ile başlar; içinde harf, rakam ve `_` olabilir.
+- Boşluk içeremez: `dogum yili` olmaz, `dogum_yili` olur.
+- Anahtar sözcükler ad olamaz: `eger`, `dongu`, `sinif` gibi.
+- Anlamlı ad seç: `x` yerine `fiyat`, `n` yerine `ogrenci_sayisi`.
+
+```kbl
+dogum_yili = 2010
+bu_yil = 2026
+yazdir(bu_yil - dogum_yili)
+```
+```cikti
+16
+```
+
+## Bir değişkenin türü sabittir
+
+Bir değişkene ilk verdiğin değerin türü onun türü olur. Sonra başka türde bir değer atayamazsın.
+
+```kbl goster
+adet = 5
+adet = "beş"     # derleme hatası: metin, sayı türündeki değişkene atanamaz
+```
+
+> **Dikkat:** Program derlenmeden önce bu hata yakalanır. Farklı türde bir değer saklamak istiyorsan yeni bir ad kullan: `adet_yazi = "beş"`.
+
+## Aynı anda birden çok değişken
+
+Virgülle ayırarak birkaç değişkeni tek satırda oluşturabilirsin.
+
+```kbl
+ad, sehir = "Mert", "Trabzon"
+yazdir(ad, sehir)
+```
+```cikti
+Mert Trabzon
+```
+
+## Değişmezler
+
+Programda hiç değişmemesi gereken değerler için `degismez` kullan. Böyle bir değere yeniden atama yaparsan program derlenmez.
+
+```kbl
+degismez KDV_ORANI = 20
+fiyat = 150
+yazdir(fiyat + fiyat * KDV_ORANI / 100)
+```
+```cikti
+180.0
+```
+
+```kbl goster
+degismez KDV_ORANI = 20
+KDV_ORANI = 18     # hata: 'KDV_ORANI' değişmez — değeri değiştirilemez
+```
+
+> **İpucu:** Değişmezleri BÜYÜK_HARFLE yazmak yaygın bir alışkanlıktır; kodu okuyan biri onun değişmeyeceğini hemen anlar.
+
+## Alıştırma
+
+```alistirma
+`cuzdan` 200 TL ile başlıyor. Önce 45 TL'lik bir kitap al (`-=`), sonra 30 TL harçlık ekle (`+=`). Son durumu yazdır.
+%%%
+cuzdan = 200
+# buraya yaz
+yazdir(cuzdan)
+%%%
+cuzdan = 200
+cuzdan -= 45
+cuzdan += 30
+yazdir(cuzdan)
+%%%
+185
+```
+
+```alistirma
+`kenar` değişkeni bir karenin kenar uzunluğunu tutuyor. `alan` ve `cevre` adında iki değişken oluşturup karenin alanını ve çevresini hesapla, ikisini aynı satırda yazdır.
+%%%
+kenar = 7
+# buraya yaz
+%%%
+kenar = 7
+alan = kenar * kenar
+cevre = 4 * kenar
+yazdir(alan, cevre)
+%%%
+49 28
+```
@@ -0,0 +1,111 @@
+---
+baslik: Veri türleri
+bolum: Temeller
+ozet: sayi, ondalik, metin, mantik ve tür belirtmek
+---
+
+Her değerin bir türü vardır. Tür, o değerle neler yapabileceğini belirler: sayılar toplanır, metinler birleştirilir, mantık değerleriyle karar verilir.
+
+## Dört temel tür
+
+| Tür | Ne tutar | Örnek |
+|---|---|---|
+| `sayi` | tam sayı | `42`, `-7`, `85_000_000` |
+| `ondalik` | küsuratlı sayı | `3.14`, `-0.5`, `1.0` |
+| `metin` | yazı | `"Kars"`, `""` |
+| `mantik` | doğru ya da yanlış | `dogru`, `yanlis` |
+
+```kbl
+il = "Kars"          # metin
+rakim = 1768         # sayi
+sicaklik = -4.5      # ondalik
+kar_yagiyor = dogru  # mantik
+yazdir(il, rakim, sicaklik, kar_yagiyor)
+```
+```cikti
+Kars 1768 -4.5 doğru
+```
+
+Mantık değerleri kodda `dogru`/`yanlis` diye yazılır ama ekranda Türkçe harflerle `doğru`/`yanlış` görünür.
+
+## sayi ve ondalik farklı türlerdir
+
+Ondalık sayılarda virgül değil **nokta** kullanılır. `3` bir `sayi`, `3.0` ise bir `ondalik`tır.
+
+```kbl
+a = 3
+b = 3.0
+yazdir(a)
+yazdir(b)
+```
+```cikti
+3
+3.0
+```
+
+Uzun sayılarda basamakları `_` ile ayırabilirsin; değer değişmez, okumak kolaylaşır.
+
+```kbl
+nufus = 85_000_000
+yazdir(nufus)
+```
+```cikti
+85000000
+```
+
+## Metinler
+
+Metin, tırnak içindeki yazıdır. Çift ya da tek tırnak kullanabilirsin. Hiç karakter içermeyen `""` boş metindir.
+
+```kbl
+selam = "Merhaba"
+isim = 'Zeynep'
+yazdir(selam + " " + isim)
+```
+```cikti
+Merhaba Zeynep
+```
+
+> **Dikkat:** `"42"` bir sayı değil, iki karakterlik bir metindir. `"42" + 1` derlenmez. Metinle sayı arasında geçişi *Tür dönüşümleri* dersinde göreceksin.
+
+## Türü açıkça yazmak
+
+Türü yazmak zorunlu değil ama istersen `ad: tur = değer` biçiminde yazabilirsin. Derleyici o zaman değerin o türde olduğunu denetler.
+
+```kbl
+fiyat: ondalik = 49.90
+stok: sayi = 12
+urun: metin = "Defter"
+yazdir(urun, stok, fiyat)
+```
+```cikti
+Defter 12 49.9
+```
+
+`49.90` ekranda `49.9` olarak görünür; sondaki sıfır sayının değerini değiştirmez. Biçimini kendin belirlemeyi *Biçimlendirme* dersinde öğreneceksin.
+
+## Türler karşılaştırılabilir mi?
+
+Farklı türden iki değeri karşılaştırmak anlamsızdır ve derleyici buna izin vermez:
+
+```kbl goster
+yazdir("5" == 5)   # hata: 'metin' ile 'sayi' karşılaştırılamaz
+```
+
+Bu bir kolaylıktır: yanlışlıkla metni sayıyla karşılaştırdığın bir hatayı program çalışmadan yakalarsın.
+
+## Alıştırma
+
+```alistirma
+Bir kitap için dört değişken oluştur: `ad` (metin, "Çalıkuşu"), `sayfa` (sayi, 544), `puan` (ondalik, 4.8), `okundu` (mantik, dogru). Dördünü tek bir `yazdir` ile sırayla yazdır.
+%%%
+# buraya yaz
+%%%
+ad = "Çalıkuşu"
+sayfa = 544
+puan = 4.8
+okundu = dogru
+yazdir(ad, sayfa, puan, okundu)
+%%%
+Çalıkuşu 544 4.8 doğru
+```
@@ -0,0 +1,145 @@
+---
+baslik: Sayılar ve aritmetik
+bolum: Temeller
+ozet: Dört işlem, tam bölme, kalan, üs ve işlem önceliği
+---
+
+Bilgisayarın en iyi yaptığı iş hesaptır. Bu derste KabaLang'in aritmetik işleçlerini ve sık yapılan hesapları göreceksin.
+
+## Aritmetik işleçler
+
+| İşleç | Anlamı | Örnek | Sonuç |
+|---|---|---|---|
+| `+` | toplama | `17 + 5` | `22` |
+| `-` | çıkarma | `17 - 5` | `12` |
+| `*` | çarpma | `17 * 5` | `85` |
+| `/` | bölme | `17 / 5` | `3.4` |
+| `//` | tam bölme | `17 // 5` | `3` |
+| `%` | kalan | `17 % 5` | `2` |
+| `**` | üs alma | `2 ** 10` | `1024` |
+
+```kbl
+a = 17
+b = 5
+yazdir(a + b, a - b, a * b)
+yazdir(a / b, a // b, a % b)
+yazdir(2 ** 10)
+```
+```cikti
+22 12 85
+3.4 3 2
+1024
+```
+
+## / her zaman ondalık verir
+
+`/` bölmesinin sonucu, sayılar tam bölünse bile `ondalik`tır. Küsuratsız tam sayı istiyorsan `//` kullan.
+
+```kbl
+yazdir(10 / 2)
+yazdir(10 // 2)
+yazdir(7 // 2)
+```
+```cikti
+5.0
+5
+3
+```
+
+## Kalan işleci: %
+
+`%` bölümden kalanı verir. Bir sayının çift mi tek mi olduğunu, bir sayıya bölünüp bölünmediğini anlamak için kullanılır.
+
+```kbl
+yazdir(14 % 2)    # 0 ise çift
+yazdir(15 % 2)    # 1 ise tek
+yazdir(2026 % 4)  # 4'e tam bölünmüyor
+```
+```cikti
+0
+1
+2
+```
+
+## Gerçek bir hesap: saniyeyi saate çevirmek
+
+`//` ve `%` birlikte çok işe yarar.
+
+```kbl
+toplam_saniye = 7384
+saat = toplam_saniye // 3600
+dakika = (toplam_saniye % 3600) // 60
+saniye = toplam_saniye % 60
+yazdir(saat, "saat", dakika, "dakika", saniye, "saniye")
+```
+```cikti
+2 saat 3 dakika 4 saniye
+```
+
+## İşlem önceliği
+
+Matematikteki gibi: önce `**`, sonra `*` `/` `//` `%`, en son `+` `-`. Parantez önceliği değiştirir.
+
+```kbl
+yazdir(2 + 3 * 4)
+yazdir((2 + 3) * 4)
+yazdir(2 * 3 ** 2)
+```
+```cikti
+14
+20
+18
+```
+
+> **İpucu:** Emin olmadığın her yerde parantez kullan. `(a + b) / 2` hem doğru çalışır hem kolay okunur.
+
+## sayi ile ondalik birlikte
+
+Bir işlemde biri `sayi` öteki `ondalik` ise sonuç `ondalik` olur.
+
+```kbl
+adet = 3
+fiyat = 12.5
+yazdir(adet * fiyat)
+```
+```cikti
+37.5
+```
+
+> **Dikkat:** Ondalık sayılar bilgisayarda yaklaşık tutulur. `0.1 + 0.2` tam `0.3` değil `0.30000000000000004` çıkar. Bu her dilde böyledir; para gibi değerleri ekrana yazarken basamak sayısını sınırlarsın (*Biçimlendirme* dersi).
+
+```kbl
+yazdir(0.1 + 0.2)
+```
+```cikti
+0.30000000000000004
+```
+
+## Alıştırma
+
+```alistirma
+Bir sınıfta 29 öğrenci var ve 4 kişilik gruplar kurulacak. Kaç tam grup olacağını ve kaç öğrencinin açıkta kalacağını aynı satırda yazdır.
+%%%
+ogrenci = 29
+grup_buyuklugu = 4
+# buraya yaz
+%%%
+ogrenci = 29
+grup_buyuklugu = 4
+yazdir(ogrenci // grup_buyuklugu, ogrenci % grup_buyuklugu)
+%%%
+7 1
+```
+
+```alistirma
+Fahrenhayt'ı Celsius'a çevir: `C = (F - 32) * 5 / 9`. `f` değişkeni 212 iken sonucu yazdır.
+%%%
+f = 212
+# buraya yaz
+%%%
+f = 212
+c = (f - 32) * 5 / 9
+yazdir(c)
+%%%
+100.0
+```
@@ -0,0 +1,130 @@
+---
+baslik: Tür dönüşümleri
+bolum: Temeller
+ozet: sayi(), ondalik() ve metin() ile türler arasında geçiş
+---
+
+Türler kendiliğinden birbirine dönüşmez. Kullanıcıdan ya da bir dosyadan gelen `"42"` bir metindir; onunla hesap yapmak için önce sayıya çevirmen gerekir. Dönüşümü her zaman açıkça yazarsın.
+
+## Üç dönüşüm fonksiyonu
+
+| Fonksiyon | Ne yapar | Örnek | Sonuç |
+|---|---|---|---|
+| `sayi(x)` | tam sayıya çevirir | `sayi("42")` | `42` |
+| `ondalik(x)` | ondalık sayıya çevirir | `ondalik("2.75")` | `2.75` |
+| `metin(x)` | metne çevirir | `metin(24)` | `"24"` |
+
+## Metinden sayıya
+
+```kbl
+yas_yazi = "17"
+yas = sayi(yas_yazi)
+yazdir(yas + 1)
+
+fiyat = ondalik("19.90")
+yazdir(fiyat * 2)
+```
+```cikti
+18
+39.8
+```
+
+Baştaki ve sondaki boşluklar sorun olmaz: `sayi(" 42 ")` da `42` verir.
+
+## Sayıdan metne
+
+Bir metni sayıyla `+` ile birleştiremezsin. Önce sayıyı `metin()` ile çevir.
+
+```kbl
+ogrenci = 24
+yazdir("Sınıfta " + metin(ogrenci) + " öğrenci var.")
+```
+```cikti
+Sınıfta 24 öğrenci var.
+```
+
+> **İpucu:** Metinle sayıyı yan yana yazmanın daha kolay bir yolu var: `f"Sınıfta {ogrenci} öğrenci var."`. Bunu *Biçimlendirme* dersinde göreceksin.
+
+## ondalik ile sayi arasında
+
+`sayi()` bir ondalığın küsuratını **atar**, yuvarlamaz. `ondalik()` tam sayıyı ondalığa çevirir.
+
+```kbl
+yazdir(sayi(3.99))
+yazdir(sayi(-3.99))
+yazdir(ondalik(7))
+yazdir(ondalik(7) / 2)
+```
+```cikti
+3
+-3
+7.0
+3.5
+```
+
+Yuvarlamak istiyorsan `matematik.yuvarla()` kullanırsın; onu *Modüller* dersinde göreceksin.
+
+## Mantık değerini metne çevirmek
+
+```kbl
+gecti = dogru
+yazdir("Sonuç: " + metin(gecti))
+```
+```cikti
+Sonuç: doğru
+```
+
+> **Dikkat:** `sayi()` yalnız tam sayı yazılmış bir metni doğru çevirir. `sayi("3.9")` ya da `sayi("on iki")` hata vermez ama **0** döndürür; bu da fark edilmesi zor bir yanlışa yol açar. Ondalık bir metni önce `ondalik()` ile çevir. Kullanıcıdan gelen sayıyı güvenle okumanın yolunu *Kullanıcıdan girdi* dersinde öğreneceksin.
+
+```kbl
+yazdir(sayi(ondalik("3.9")))
+```
+```cikti
+3
+```
+
+## Gerçek bir örnek: virgülle ayrılmış veriler
+
+Bir satırdaki verileri metin olarak alıp sayıya çevirerek hesap yapalım. `bol(";")` metni parçalara ayırır (ayrıntısı *Metin işlemleri* dersinde).
+
+```kbl
+satir = "Defter;3;24.50"
+parca = satir.bol(";")
+urun = parca[0]
+adet = sayi(parca[1])
+fiyat = ondalik(parca[2])
+yazdir(urun + ": " + metin(adet * fiyat) + " TL")
+```
+```cikti
+Defter: 73.5 TL
+```
+
+## Alıştırma
+
+```alistirma
+`a` ve `b` metin olarak verilmiş. İkisini sayıya çevirip toplamını yazdır.
+%%%
+a = "125"
+b = "75"
+# buraya yaz
+%%%
+a = "125"
+b = "75"
+yazdir(sayi(a) + sayi(b))
+%%%
+200
+```
+
+```alistirma
+`metin()` kullanarak `Toplam: 3 ürün, 45.5 TL` satırını yazdır. Sayıları değişkenlerden al, `+` ile birleştir.
+%%%
+adet = 3
+tutar = 45.5
+# buraya yaz
+%%%
+adet = 3
+tutar = 45.5
+yazdir("Toplam: " + metin(adet) + " ürün, " + metin(tutar) + " TL")
+%%%
+Toplam: 3 ürün, 45.5 TL
+```
@@ -0,0 +1,163 @@
+---
+baslik: Metinler
+bolum: Temeller
+ozet: Metin yazmak, birleştirmek, kaçış karakterleri ve harflere erişim
+---
+
+Ad, adres, mesaj, ürün açıklaması... Programların işlediği verilerin çoğu metindir. KabaLang metinleri Türkçe harflerle sorunsuz çalışır.
+
+## Metin oluşturmak
+
+Metin çift (`"..."`) ya da tek (`'...'`) tırnak arasına yazılır.
+
+```kbl
+sehir = "Çanakkale"
+ulke = 'Türkiye'
+yazdir(sehir)
+yazdir(ulke)
+```
+```cikti
+Çanakkale
+Türkiye
+```
+
+## Birleştirmek
+
+İki metni `+` ile uç uca eklersin. `+=` bir metnin sonuna ekleme yapar.
+
+```kbl
+ad = "Reşat Nuri"
+soyad = "Güntekin"
+tam_ad = ad + " " + soyad
+yazdir(tam_ad)
+
+mesaj = "Merhaba"
+mesaj += ", hoş geldin!"
+yazdir(mesaj)
+```
+```cikti
+Reşat Nuri Güntekin
+Merhaba, hoş geldin!
+```
+
+## Kaçış karakterleri
+
+Bazı karakterler ters eğik çizgiyle yazılır:
+
+| Yazım | Anlamı |
+|---|---|
+| `\n` | yeni satır |
+| `\t` | sekme |
+| `\"` | çift tırnak |
+| `\\` | ters eğik çizgi |
+
+```kbl
+yazdir("Birinci satır\nİkinci satır")
+yazdir("Öğretmen \"tahtaya bakın\" dedi.")
+yazdir("Dosya: C:\\belgeler")
+```
+```cikti
+Birinci satır
+İkinci satır
+Öğretmen "tahtaya bakın" dedi.
+Dosya: C:\belgeler
+```
+
+## Çok satırlı metin
+
+Üç tırnak (`"""`) arasına yazdığın metin, satır sonlarıyla birlikte olduğu gibi saklanır.
+
+```kbl
+siir = """Gün doğdu,
+kuşlar uyandı."""
+yazdir(siir)
+```
+```cikti
+Gün doğdu,
+kuşlar uyandı.
+```
+
+## Uzunluk
+
+`uzunluk()` metindeki karakter sayısını verir. ş, ğ, İ gibi harfler de tek karakter sayılır.
+
+```kbl
+il = "Şanlıurfa"
+yazdir(il.uzunluk())
+```
+```cikti
+9
+```
+
+## Harflere erişmek: indeks
+
+Metindeki her karakterin bir sıra numarası (indeks) vardır. Sayma **0'dan** başlar. Negatif indeks sondan sayar: `-1` son karakterdir.
+
+```kbl
+il = "Kayseri"
+yazdir(il[0])
+yazdir(il[1])
+yazdir(il[-1])
+```
+```cikti
+K
+a
+i
+```
+
+`[a..b]` ile a'dan b'ye kadar (b dahil) bir parça alırsın.
+
+```kbl
+il = "Kayseri"
+yazdir(il[0..2])
+yazdir(il[3..6])
+```
+```cikti
+Kay
+seri
+```
+
+> **Dikkat:** Metindeki bir harfi yerinde değiştiremezsin: `il[0] = "M"` derlenmez. Değişmiş bir metin istiyorsan yenisini oluşturursun, örneğin `"M" + il[1..6]`.
+
+## Harf harf gezmek
+
+`dongu harf icinde metin:` her turda bir karakter verir (döngüleri ileride ayrıntılı göreceksin).
+
+```kbl
+dongu harf icinde "Ağrı":
+    yazdir(harf)
+```
+```cikti
+A
+ğ
+r
+ı
+```
+
+## Alıştırma
+
+```alistirma
+`ad` ve `sehir` değişkenlerini `+` ile birleştirerek `Ayşe, Eskişehir'de yaşıyor.` satırını yazdır.
+%%%
+ad = "Ayşe"
+sehir = "Eskişehir"
+# buraya yaz
+%%%
+ad = "Ayşe"
+sehir = "Eskişehir"
+yazdir(ad + ", " + sehir + "'de yaşıyor.")
+%%%
+Ayşe, Eskişehir'de yaşıyor.
+```
+
+```alistirma
+`kelime` değişkeninin ilk harfini, son harfini ve uzunluğunu aynı satırda yazdır.
+%%%
+kelime = "Çiçekçi"
+# buraya yaz
+%%%
+kelime = "Çiçekçi"
+yazdir(kelime[0], kelime[-1], kelime.uzunluk())
+%%%
+Ç i 7
+```
@@ -0,0 +1,176 @@
+---
+baslik: Metin işlemleri
+bolum: Temeller
+ozet: buyut, kucult, kirp, bol, birlestir, degistir, bul ve diğer metin yöntemleri
+---
+
+Metinlerin kendi yöntemleri (metotları) vardır: `metin.yontem()` biçiminde çağrılır. Kullanıcının yazdığını temizlemek, bir cümleyi kelimelere ayırmak, bir sözcüğü değiştirmek bu yöntemlerle yapılır.
+
+## Türkçe büyük ve küçük harf
+
+`buyut()` bütün harfleri büyütür, `kucult()` küçültür. Türkçe kurallara uyar: `i` büyüyünce `İ`, `I` küçülünce `ı` olur.
+
+```kbl
+yazdir("istanbul".buyut())
+yazdir("ILIK IRMAK".kucult())
+yazdir("şişli öğüt".buyut())
+```
+```cikti
+İSTANBUL
+ılık ırmak
+ŞİŞLİ ÖĞÜT
+```
+
+Büyük/küçük harfe aldırmadan karşılaştırmak için iki tarafı da küçültürsün.
+
+```kbl
+girilen = "İZMİR"
+yazdir(girilen.kucult() == "izmir")
+```
+```cikti
+doğru
+```
+
+## Boşlukları temizlemek: kirp
+
+`kirp()` baştaki ve sondaki boşlukları atar. Kullanıcı girdisinde çok işe yarar.
+
+```kbl
+ham = "   Merhaba Dünya   "
+yazdir("[" + ham + "]")
+yazdir("[" + ham.kirp() + "]")
+```
+```cikti
+[   Merhaba Dünya   ]
+[Merhaba Dünya]
+```
+
+## Aramak
+
+| Yöntem | Sorusu | Sonuç |
+|---|---|---|
+| `icerir(x)` | x geçiyor mu? | `dogru`/`yanlis` |
+| `ile_baslar(x)` | x ile mi başlıyor? | `dogru`/`yanlis` |
+| `ile_biter(x)` | x ile mi bitiyor? | `dogru`/`yanlis` |
+| `bul(x)` | x nerede başlıyor? | indeks, yoksa `-1` |
+
+```kbl
+cumle = "Ankara Türkiye'nin başkentidir"
+yazdir(cumle.icerir("başkent"))
+yazdir(cumle.ile_baslar("Ankara"))
+yazdir(cumle.ile_biter("dir"))
+yazdir(cumle.bul("Türkiye"))
+yazdir(cumle.bul("İzmir"))
+```
+```cikti
+doğru
+doğru
+doğru
+7
+-1
+```
+
+## Değiştirmek: degistir
+
+`degistir(eski, yeni)` metindeki her `eski`yi `yeni` ile değiştirir. Asıl metin değişmez, yeni bir metin döner.
+
+```kbl
+duyuru = "Toplantı salı günü, salı saat 10'da."
+yeni = duyuru.degistir("salı", "çarşamba")
+yazdir(yeni)
+```
+```cikti
+Toplantı çarşamba günü, çarşamba saat 10'da.
+```
+
+## Parça almak
+
+`bastan(n)` ilk n karakteri, `sondan(n)` son n karakteri, `dilim(baslangic, adet)` belli bir yerden başlayan parçayı verir.
+
+```kbl
+kelime = "Karadeniz"
+yazdir(kelime.bastan(4))
+yazdir(kelime.sondan(5))
+yazdir(kelime.dilim(2, 3))
+```
+```cikti
+Kara
+deniz
+rad
+```
+
+## Bölmek ve birleştirmek
+
+`bol(ayrac)` metni parçalara ayırıp bir liste verir. `birlestir(ayrac)` ise bir metin listesini tek metne çevirir.
+
+```kbl
+satir = "Ayşe;Kaya;Eskişehir"
+alanlar = satir.bol(";")
+yazdir(alanlar)
+yazdir(alanlar[2])
+yazdir(alanlar.birlestir(" | "))
+```
+```cikti
+[Ayşe, Kaya, Eskişehir]
+Eskişehir
+Ayşe | Kaya | Eskişehir
+```
+
+## Diğer yararlı yöntemler
+
+```kbl
+yazdir("=".tekrarla(20))
+yazdir("".bos_mu())
+yazdir("abc".bos_mu())
+```
+```cikti
+====================
+doğru
+yanlış
+```
+
+> **Dikkat:** Yöntem adlarına dikkat: büyütme `buyut()`, küçültme `kucult()`, uzunluk `uzunluk()`'tür. `buyuk()`, `kucuk()` diye yöntem yoktur; derleyici "böyle bir metot bulunamadı" der.
+
+## Yöntemleri zincirlemek
+
+Her yöntem yeni bir metin döndürdüğü için arka arkaya yazabilirsin.
+
+```kbl
+girdi = "   ankara   "
+yazdir(girdi.kirp().buyut())
+```
+```cikti
+ANKARA
+```
+
+## Alıştırma
+
+```alistirma
+`eposta` değişkenindeki boşlukları temizle, harflerini küçült ve sonucu yazdır. Ardından temizlenmiş adresin `@` içerip içermediğini yazdır.
+%%%
+eposta = "  [email protected]  "
+# buraya yaz
+%%%
+eposta = "  [email protected]  "
+temiz = eposta.kirp().kucult()
+yazdir(temiz)
+yazdir(temiz.icerir("@"))
+%%%
+[email protected]
+doğru
+```
+
+```alistirma
+`liste` metnindeki ürünler virgülle ayrılmış. Metni böl, ürün sayısını yazdır, sonra ürünleri ` - ` ile birleştirip yazdır.
+%%%
+liste = "ekmek,süt,peynir,zeytin"
+# buraya yaz
+%%%
+liste = "ekmek,süt,peynir,zeytin"
+urunler = liste.bol(",")
+yazdir(urunler.uzunluk())
+yazdir(urunler.birlestir(" - "))
+%%%
+4
+ekmek - süt - peynir - zeytin
+```
@@ -0,0 +1,151 @@
+---
+baslik: Biçimlendirme
+bolum: Temeller
+ozet: f-string ile değerleri metne yerleştirmek, basamak ve hizalama
+---
+
+Metinle sayıları `+` ve `metin()` ile birleştirmek çabuk karışır. Biçimli metin (f-string) bunu çok kolaylaştırır: değişkenleri doğrudan metnin içine yazarsın.
+
+## f-string
+
+Metnin önüne `f` koy, değerleri süslü parantez `{}` içine yaz.
+
+```kbl
+ad = "Deniz"
+yas = 14
+yazdir(f"{ad} {yas} yaşında.")
+```
+```cikti
+Deniz 14 yaşında.
+```
+
+Süslü parantezin içine hesap da yazabilirsin.
+
+```kbl
+adet = 3
+fiyat = 12
+yazdir(f"{adet} kalem toplam {adet * fiyat} TL.")
+```
+```cikti
+3 kalem toplam 36 TL.
+```
+
+## Ondalık basamak sayısı
+
+`{deger:.2f}` virgülden sonra 2 basamak yazar ve yuvarlar.
+
+```kbl
+pi = 3.14159
+fiyat = 49.9
+yazdir(f"{pi:.2f}")
+yazdir(f"{fiyat:.2f} TL")
+yazdir(f"{0.1 + 0.2:.2f}")
+```
+```cikti
+3.14
+49.90 TL
+0.30
+```
+
+## Sıfırla doldurmak
+
+`{deger:02}` sayıyı en az 2 basamağa tamamlar; eksik basamaklar sıfır olur. Saat ve tarih yazarken işe yarar.
+
+```kbl
+saat = 9
+dakika = 5
+yazdir(f"{saat:02}:{dakika:02}")
+```
+```cikti
+09:05
+```
+
+## Binlik ayırıcı ve yüzde
+
+```kbl
+nufus = 85_372_377
+oran = 0.256
+yazdir(f"{nufus:,}")
+yazdir(f"{oran:.1%}")
+```
+```cikti
+85,372,377
+25.6%
+```
+
+## Hizalama
+
+`{deger:<10}` değeri 10 karakterlik alana sola, `{deger:>10}` sağa, `{deger:^10}` ortaya yaslar. Tablo yazmak için birebirdir.
+
+```kbl
+yazdir(f"[{'Rize':<8}]")
+yazdir(f"[{'Rize':>8}]")
+yazdir(f"[{'Rize':^8}]")
+```
+```cikti
+[Rize    ]
+[    Rize]
+[  Rize  ]
+```
+
+Hizalama ile basamak sayısını birlikte de verebilirsin: `{fiyat:>8.2f}`.
+
+```kbl
+yazdir(f"{'Ürün':<10}{'Fiyat':>8}")
+yazdir(f"{'Ekmek':<10}{12.5:>8.2f}")
+yazdir(f"{'Peynir':<10}{149.0:>8.2f}")
+```
+```cikti
+Ürün         Fiyat
+Ekmek        12.50
+Peynir      149.00
+```
+
+> **Dikkat:** f-string içinde metin yazarken iç tırnağı dıştakinden farklı seç: `f"{'Ürün':<10}"` doğrudur. Süslü parantezin kendisini yazmak için ikiler: `f"{{ }}"` ekrana `{ }` basar.
+
+## Özet tablo
+
+| Yazım | Anlamı | Örnek | Sonuç |
+|---|---|---|---|
+| `{x:.2f}` | 2 ondalık basamak | `{3.14159:.2f}` | `3.14` |
+| `{x:03}` | 3 basamağa sıfırla tamamla | `{7:03}` | `007` |
+| `{x:,}` | binlik ayırıcı | `{1234567:,}` | `1,234,567` |
+| `{x:.0%}` | yüzde | `{0.5:.0%}` | `50%` |
+| `{x:<6}` | sola yasla | `[{'ab':<6}]` | `[ab    ]` |
+| `{x:>6}` | sağa yasla | `[{'ab':>6}]` | `[    ab]` |
+| `{x:^6}` | ortala | `[{'ab':^6}]` | `[  ab  ]` |
+
+## Alıştırma
+
+```alistirma
+f-string kullanarak `Elif'in ortalaması: 84.67` satırını yazdır. Ortalamayı üç notun ortalaması olarak hesapla ve 2 basamakla yaz.
+%%%
+ad = "Elif"
+not1 = 78
+not2 = 91
+not3 = 85
+# buraya yaz
+%%%
+ad = "Elif"
+not1 = 78
+not2 = 91
+not3 = 85
+ortalama = (not1 + not2 + not3) / 3
+yazdir(f"{ad}'in ortalaması: {ortalama:.2f}")
+%%%
+Elif'in ortalaması: 84.67
+```
+
+```alistirma
+`toplam_dakika` değerini `SS:DD` biçiminde (iki basamaklı saat ve dakika) yazdır. 425 dakika `07:05` olmalı.
+%%%
+toplam_dakika = 425
+# buraya yaz
+%%%
+toplam_dakika = 425
+saat = toplam_dakika // 60
+dakika = toplam_dakika % 60
+yazdir(f"{saat:02}:{dakika:02}")
+%%%
+07:05
+```
@@ -0,0 +1,159 @@
+---
+baslik: Mantık ve karşılaştırma
+bolum: Temeller
+ozet: dogru/yanlis, karşılaştırma işleçleri, ve/veya/degil ve işleçlerin özeti
+---
+
+Program karar verirken bir sorunun cevabına bakar: "puan 50'den büyük mü?", "kullanıcı adı doğru mu?". Bu soruların cevabı bir mantık değeridir: `dogru` ya da `yanlis`.
+
+## Karşılaştırma işleçleri
+
+| İşleç | Sorusu |
+|---|---|
+| `==` | eşit mi? |
+| `!=` | farklı mı? |
+| `<` | küçük mü? |
+| `<=` | küçük ya da eşit mi? |
+| `>` | büyük mü? |
+| `>=` | büyük ya da eşit mi? |
+
+```kbl
+yazdir(7 > 3)
+yazdir(7 == 3)
+yazdir(7 != 3)
+yazdir(5 <= 5)
+```
+```cikti
+doğru
+yanlış
+doğru
+doğru
+```
+
+> **Dikkat:** Eşitlik sorusu **iki** eşittir işaretiyle yazılır: `==`. Tek `=` atamadır, değeri değiştirir.
+
+## Metinleri karşılaştırmak
+
+Metinler harf harf karşılaştırılır; büyük/küçük harf fark eder.
+
+```kbl
+yazdir("elma" == "elma")
+yazdir("elma" == "Elma")
+yazdir("elma".kucult() == "Elma".kucult())
+```
+```cikti
+doğru
+yanlış
+doğru
+```
+
+## Sonucu değişkende tutmak
+
+Karşılaştırmanın sonucu bir değerdir; değişkene atayabilirsin.
+
+```kbl
+yas = 20
+ehliyet_alabilir = yas >= 18
+yazdir(ehliyet_alabilir)
+```
+```cikti
+doğru
+```
+
+## ve, veya, degil
+
+Birden çok koşulu birleştirmek için sözcük işleçleri kullanılır:
+
+| İşleç | Ne zaman doğru? |
+|---|---|
+| `a ve b` | ikisi de doğruysa |
+| `a veya b` | en az biri doğruysa |
+| `degil a` | a yanlışsa |
+
+```kbl
+yas = 16
+veli_izni = dogru
+yazdir(yas >= 18 ve veli_izni)
+yazdir(yas >= 18 veya veli_izni)
+yazdir(degil veli_izni)
+```
+```cikti
+yanlış
+doğru
+yanlış
+```
+
+> **Dikkat:** `&&`, `||`, `!` gibi simgeler KabaLang'de yoktur. Her zaman `ve`, `veya`, `degil` yaz.
+
+## Aralık sorusu
+
+Bir değerin iki sınır arasında olup olmadığını `ve` ile sorarsın.
+
+```kbl
+sicaklik = 22
+yazdir(sicaklik >= 18 ve sicaklik <= 26)
+```
+```cikti
+doğru
+```
+
+## Parantezle gruplamak
+
+`ve`, `veya`'dan önce hesaplanır. Uzun koşullarda parantez kullanmak hem doğru sonucu garanti eder hem okumayı kolaylaştırır. Artık yıl kuralı buna güzel bir örnek: yıl 4'e bölünür ve 100'e bölünmez **ya da** 400'e bölünür.
+
+```kbl
+yil = 2024
+artik = (yil % 4 == 0 ve yil % 100 != 0) veya yil % 400 == 0
+yazdir(artik)
+```
+```cikti
+doğru
+```
+
+## Tek satırda seçim
+
+`A eger kosul degilse B` ifadesi, koşul doğruysa A'yı, değilse B'yi verir.
+
+```kbl
+n = 7
+yazdir("çift" eger n % 2 == 0 degilse "tek")
+```
+```cikti
+tek
+```
+
+## İşleçlerin özeti
+
+| Tür | İşleçler |
+|---|---|
+| Aritmetik | `+` `-` `*` `/` `//` `%` `**` |
+| Atama | `=` `+=` `-=` `*=` |
+| Karşılaştırma | `==` `!=` `<` `<=` `>` `>=` |
+| Mantık | `ve` `veya` `degil` |
+
+## Alıştırma
+
+```alistirma
+Bir bilet indirimi şöyle: yaşı 12'den küçük **veya** 65'ten büyük olanlar indirim alır. `yas` için bu koşulun sonucunu yazdır.
+%%%
+yas = 70
+# buraya yaz
+%%%
+yas = 70
+yazdir(yas < 12 veya yas > 65)
+%%%
+doğru
+```
+
+```alistirma
+Bir şifre geçerli sayılmak için en az 8 karakter olmalı **ve** içinde boşluk bulunmamalı. `sifre` için `gecerli` değişkenini hesaplayıp yazdır.
+%%%
+sifre = "kirmizi kalem"
+# buraya yaz
+%%%
+sifre = "kirmizi kalem"
+gecerli = sifre.uzunluk() >= 8 ve degil sifre.icerir(" ")
+yazdir(gecerli)
+%%%
+yanlış
+```
@@ -0,0 +1,164 @@
+---
+baslik: Koşullar
+bolum: Akış denetimi
+ozet: eger, degilse eger, degilse ile karar vermek
+---
+
+Program her zaman aynı şeyi yapmaz: hava sıcaksa bir şey, soğuksa başka bir şey söyler. `eger` ile kodun bir bölümünü yalnız belli bir durumda çalıştırırsın.
+
+## eger
+
+`eger kosul:` satırının altındaki girintili blok, koşul doğruysa çalışır.
+
+```kbl
+sicaklik = 31
+eger sicaklik > 30:
+    yazdir("Hava çok sıcak.")
+yazdir("İyi günler.")
+```
+```cikti
+Hava çok sıcak.
+İyi günler.
+```
+
+## degilse
+
+Koşul yanlışsa çalışacak bir blok istiyorsan `degilse:` ekle.
+
+```kbl
+bakiye = 80
+fiyat = 120
+eger bakiye >= fiyat:
+    yazdir("Ödeme yapıldı.")
+degilse:
+    yazdir("Bakiye yetersiz.")
+```
+```cikti
+Bakiye yetersiz.
+```
+
+## degilse eger: birden çok seçenek
+
+Seçenek ikiden fazlaysa `degilse eger` kullanırsın. Koşullar yukarıdan aşağıya denenir; **doğru çıkan ilk dal** çalışır, gerisi atlanır.
+
+```kbl
+puan = 77
+eger puan >= 85:
+    harf = "AA"
+degilse eger puan >= 70:
+    harf = "BA"
+degilse eger puan >= 60:
+    harf = "BB"
+degilse eger puan >= 50:
+    harf = "CC"
+degilse:
+    harf = "FF"
+yazdir(f"{puan} puan: {harf}")
+```
+```cikti
+77 puan: BA
+```
+
+> **Dikkat:** Sıralama önemlidir. Yukarıdaki örnekte önce `puan >= 50` sorulsaydı, 77 puan o dala girer ve `CC` alırdı. Eşikleri büyükten küçüğe sırala.
+
+## Birleşik koşullar
+
+Koşulda `ve`, `veya`, `degil` kullanabilirsin.
+
+```kbl
+yas = 16
+veli_izni = dogru
+eger yas >= 18 veya veli_izni:
+    yazdir("Geziye katılabilir.")
+degilse:
+    yazdir("Veli izni gerekli.")
+```
+```cikti
+Geziye katılabilir.
+```
+
+## İç içe koşul
+
+Bir `eger` bloğunun içinde başka bir `eger` olabilir.
+
+```kbl
+kullanici = "ayse"
+parola = "kirmizi-kalem"
+eger kullanici == "ayse":
+    eger parola == "kirmizi-kalem":
+        yazdir("Giriş başarılı.")
+    degilse:
+        yazdir("Parola yanlış.")
+degilse:
+    yazdir("Böyle bir kullanıcı yok.")
+```
+```cikti
+Giriş başarılı.
+```
+
+**Dene**'ye basıp parolayı değiştir; hangi dalın çalıştığını gör.
+
+## Gerçek bir örnek: kargo ücreti
+
+```kbl
+sepet = 420.0
+agirlik = 3.2
+eger sepet >= 500.0:
+    kargo = 0.0
+degilse eger agirlik <= 1.0:
+    kargo = 39.90
+degilse eger agirlik <= 5.0:
+    kargo = 59.90
+degilse:
+    kargo = 89.90
+yazdir(f"Kargo: {kargo:.2f} TL")
+eger kargo > 0.0:
+    yazdir(f"{500.0 - sepet:.2f} TL daha ekle, kargo bedava.")
+```
+```cikti
+Kargo: 59.90 TL
+80.00 TL daha ekle, kargo bedava.
+```
+
+> **İpucu:** Bir değişkeni `eger` dallarında oluşturuyorsan (yukarıdaki `kargo` gibi) her dalda aynı türde değer ver: hepsi `ondalik` ya da hepsi `sayi`.
+
+## Alıştırma
+
+```alistirma
+`sayi_degeri` pozitifse `pozitif`, negatifse `negatif`, sıfırsa `sıfır` yazdır.
+%%%
+sayi_degeri = -8
+# buraya yaz
+%%%
+sayi_degeri = -8
+eger sayi_degeri > 0:
+    yazdir("pozitif")
+degilse eger sayi_degeri < 0:
+    yazdir("negatif")
+degilse:
+    yazdir("sıfır")
+%%%
+negatif
+```
+
+```alistirma
+Vücut kitle indeksini (`kilo / (boy * boy)`) hesapla ve 1 basamakla yazdır. Sonra değer 18.5'ten küçükse `zayıf`, 25'ten küçükse `normal`, değilse `fazla kilolu` yazdır.
+%%%
+kilo = 68.0
+boy = 1.75
+# buraya yaz
+%%%
+kilo = 68.0
+boy = 1.75
+vki = kilo / (boy * boy)
+yazdir(f"{vki:.1f}")
+eger vki < 18.5:
+    yazdir("zayıf")
+degilse eger vki < 25.0:
+    yazdir("normal")
+degilse:
+    yazdir("fazla kilolu")
+%%%
+22.2
+normal
+```
@@ -0,0 +1,140 @@
+---
+baslik: iken döngüsü
+bolum: Akış denetimi
+ozet: Koşul doğru olduğu sürece tekrar etmek
+---
+
+Bir işi defalarca yapmak için aynı satırı tekrar tekrar yazmazsın; döngü kullanırsın. `iken` döngüsü, koşul doğru olduğu **sürece** bloğunu tekrarlar.
+
+## Temel kullanım
+
+```kbl
+sayac = 1
+iken sayac <= 5:
+    yazdir(sayac)
+    sayac += 1
+yazdir("Bitti")
+```
+```cikti
+1
+2
+3
+4
+5
+Bitti
+```
+
+Her turdan önce koşul sorulur. `sayac` 6 olunca koşul yanlış çıkar ve döngü biter.
+
+## Geri sayım
+
+```kbl
+kalan = 3
+iken kalan > 0:
+    yazdir(f"{kalan}...")
+    kalan -= 1
+yazdir("Kalkış!")
+```
+```cikti
+3...
+2...
+1...
+Kalkış!
+```
+
+## Toplam biriktirmek
+
+Döngüde bir değişkene her turda ekleme yaparak toplam bulursun.
+
+```kbl
+toplam = 0
+n = 1
+iken n <= 100:
+    toplam += n
+    n += 1
+yazdir(f"1'den 100'e kadar toplam: {toplam}")
+```
+```cikti
+1'den 100'e kadar toplam: 5050
+```
+
+## Kaç turda biteceğini bilmediğin işler
+
+`iken`, tekrar sayısını önceden bilmediğin durumlar için idealdir. Yıllık %40 faizle 10.000 TL kaç yılda iki katını geçer?
+
+```kbl
+para = 10_000.0
+yil = 0
+iken para < 20_000.0:
+    para = para * 1.40
+    yil += 1
+yazdir(f"{yil} yıl sonra: {para:,.2f} TL")
+```
+```cikti
+3 yıl sonra: 27,440.00 TL
+```
+
+Bir sayının basamaklarını tek tek ayırmak da böyle bir iştir.
+
+```kbl
+n = 4729
+basamak_toplami = 0
+iken n > 0:
+    basamak_toplami += n % 10
+    n = n // 10
+yazdir(basamak_toplami)
+```
+```cikti
+22
+```
+
+> **Dikkat:** Koşulu bir gün yanlış yapacak satırı unutursan döngü **sonsuza dek** döner. Aşağıdaki kodda `sayac` hiç artmıyor; program durmaz (IDE belli bir süre sonra onu keser).
+
+```kbl goster
+sayac = 1
+iken sayac <= 5:
+    yazdir(sayac)
+    # sayac += 1 unutuldu!
+```
+
+## Alıştırma
+
+```alistirma
+`iken` ile 2'nin kuvvetlerini yazdır: 1, 2, 4, 8, ... 1000'i geçmeyenleri, her biri ayrı satırda.
+%%%
+kuvvet = 1
+# buraya yaz
+%%%
+kuvvet = 1
+iken kuvvet <= 1000:
+    yazdir(kuvvet)
+    kuvvet *= 2
+%%%
+1
+2
+4
+8
+16
+32
+64
+128
+256
+512
+```
+
+```alistirma
+Bir kumbarada 0 TL var. Her hafta 35 TL atılıyor. Kumbara 500 TL'ye ulaşana ya da geçene kadar kaç hafta gerektiğini ve son tutarı `X hafta, Y TL` biçiminde yazdır.
+%%%
+kumbara = 0
+hafta = 0
+# buraya yaz
+%%%
+kumbara = 0
+hafta = 0
+iken kumbara < 500:
+    kumbara += 35
+    hafta += 1
+yazdir(f"{hafta} hafta, {kumbara} TL")
+%%%
+15 hafta, 525 TL
+```
@@ -0,0 +1,150 @@
+---
+baslik: dongu ... icinde ve aralıklar
+bolum: Akış denetimi
+ozet: Bir listenin, metnin ya da sayı aralığının her öğesi için tekrar etmek
+---
+
+Elinde bir şehir listesi var ve her birini yazdırmak istiyorsun. `dongu x icinde ...` döngüsü bir topluluğun her öğesi için bloğunu bir kez çalıştırır; sayaç tutmana gerek kalmaz.
+
+## Liste üzerinde dönmek
+
+Her turda `sehir` değişkeni sıradaki öğeyi alır.
+
+```kbl
+sehirler = ["Ankara", "İzmir", "Trabzon", "Van"]
+dongu sehir icinde sehirler:
+    yazdir(f"• {sehir}")
+```
+```cikti
+• Ankara
+• İzmir
+• Trabzon
+• Van
+```
+
+Döngü değişkenine istediğin adı verebilirsin. Anlamlı bir ad seç: `dongu ogrenci icinde ogrenciler`.
+
+## Sayı aralığı: a..b
+
+`1..5` aralığı 1, 2, 3, 4, 5 demektir. **Üst sınır dahildir.**
+
+```kbl
+dongu i icinde 1..5:
+    yazdir(f"{i} x 3 = {i * 3}")
+```
+```cikti
+1 x 3 = 3
+2 x 3 = 6
+3 x 3 = 9
+4 x 3 = 12
+5 x 3 = 15
+```
+
+Sınırlar değişken ya da hesap olabilir.
+
+```kbl
+n = 4
+toplam = 0
+dongu i icinde 1..n:
+    toplam += i * i
+yazdir(f"1'den {n}'e kadar karelerin toplamı: {toplam}")
+```
+```cikti
+1'den 4'e kadar karelerin toplamı: 30
+```
+
+## İndeksle dönmek
+
+Sıra numarasına da ihtiyacın varsa `0..liste.uzunluk() - 1` aralığında dönersin.
+
+```kbl
+kazananlar = ["Elif", "Mert", "Zeynep"]
+dongu i icinde 0..kazananlar.uzunluk() - 1:
+    yazdir(f"{i + 1}. {kazananlar[i]}")
+```
+```cikti
+1. Elif
+2. Mert
+3. Zeynep
+```
+
+## Metin üzerinde dönmek
+
+Bir metin üzerinde dönünce her turda bir karakter gelir.
+
+```kbl
+kelime = "Çalışkan öğrenciler"
+unlu = 0
+dongu harf icinde kelime.kucult():
+    eger "aeıioöuü".icerir(harf):
+        unlu += 1
+yazdir(f"{unlu} ünlü harf var.")
+```
+```cikti
+7 ünlü harf var.
+```
+
+## İç içe döngü
+
+Dıştaki döngünün her turunda içteki döngü baştan sona çalışır. Çarpım tablosu buna klasik bir örnektir.
+
+```kbl
+dongu satir icinde 1..4:
+    cizgi = ""
+    dongu sutun icinde 1..4:
+        cizgi += f"{satir * sutun:4}"
+    yazdir(cizgi)
+```
+```cikti
+   1   2   3   4
+   2   4   6   8
+   3   6   9  12
+   4   8  12  16
+```
+
+> **Dikkat:** Aralık yalnız ileri sayar. `5..1` boş bir aralıktır, döngü hiç çalışmaz. Geri saymak için `iken` kullan.
+
+```kbl
+dongu i icinde 5..1:
+    yazdir(i)
+yazdir("Döngü hiç çalışmadı.")
+```
+```cikti
+Döngü hiç çalışmadı.
+```
+
+> **İpucu:** Döngü değişkenini değiştirmek listeyi değiştirmez. `dongu x icinde l: x = x * 2` yazınca `l` aynı kalır. Listeyi güncellemenin yolunu *Liste işlemleri* dersinde göreceksin.
+
+## Alıştırma
+
+```alistirma
+`notlar` listesindeki notların toplamını ve ortalamasını bul. Ortalamayı 1 basamakla `Toplam: 404, ortalama: 80.8` biçiminde yazdır.
+%%%
+notlar = [72, 95, 88, 61, 88]
+toplam = 0
+# buraya yaz
+%%%
+notlar = [72, 95, 88, 61, 88]
+toplam = 0
+dongu n icinde notlar:
+    toplam += n
+ortalama = toplam / notlar.uzunluk()
+yazdir(f"Toplam: {toplam}, ortalama: {ortalama:.1f}")
+%%%
+Toplam: 404, ortalama: 80.8
+```
+
+```alistirma
+1'den 5'e kadar her `n` için `n` tane yıldızdan oluşan bir satır yazdır (bir merdiven). `"*".tekrarla(n)` işini görür.
+%%%
+# buraya yaz
+%%%
+dongu n icinde 1..5:
+    yazdir("*".tekrarla(n))
+%%%
+*
+**
+***
+****
+*****
+```
@@ -0,0 +1,146 @@
+---
+baslik: kir ve devam
+bolum: Akış denetimi
+ozet: Döngüden erken çıkmak ve bir turu atlamak
+---
+
+Bazen döngünün sonuna kadar gitmek gerekmez: aradığını bulmuşsundur ya da bu turdaki öğe seni ilgilendirmiyordur. `kir` döngüden tümden çıkar, `devam` yalnız bu turu atlar.
+
+## kir: döngüden çık
+
+Listede ilk başarısız notu arayalım. Bulunca aramaya devam etmenin anlamı yok.
+
+```kbl
+notlar = [62, 81, 48, 77, 35]
+dongu n icinde notlar:
+    eger n < 50:
+        yazdir(f"İlk başarısız not: {n}")
+        kir
+    yazdir(f"{n} geçti")
+```
+```cikti
+62 geçti
+81 geçti
+İlk başarısız not: 48
+```
+
+`kir` çalışınca döngü hemen biter; 77 ve 35'e hiç bakılmaz.
+
+## devam: bu turu atla
+
+`devam`'a gelince turun geri kalanı atlanır, döngü bir sonraki öğeyle sürer.
+
+```kbl
+dongu i icinde 1..10:
+    eger i % 3 == 0:
+        devam
+    konsol.yaz(f"{i} ")
+yazdir()
+```
+```cikti
+1 2 4 5 7 8 10
+```
+
+Burada `konsol.yaz` kullandık: `yazdir` gibidir ama satırı bitirmez, böylece sayılar yan yana dizilir. En sondaki boş `yazdir()` satırı kapatır.
+
+## iken dogru ile kir
+
+Kaç tur süreceği belli olmayan bir döngüyü `iken dogru:` ile başlatıp koşul sağlanınca `kir` ile bitirebilirsin.
+
+```kbl
+n = 27
+adim = 0
+iken dogru:
+    eger n == 1:
+        kir
+    eger n % 2 == 0:
+        n = n // 2
+    degilse:
+        n = 3 * n + 1
+    adim += 1
+yazdir(f"27, {adim} adımda 1'e ulaştı.")
+```
+```cikti
+27, 111 adımda 1'e ulaştı.
+```
+
+> **Dikkat:** `iken dogru:` yazdıysan döngünün içinde mutlaka bir `kir` olmalı ve ona bir gün ulaşılmalı. Yoksa döngü sonsuza dek döner.
+
+## İç içe döngüde kir
+
+`kir` yalnız **içinde bulunduğu** döngüden çıkar; dıştaki döngü devam eder.
+
+```kbl
+dongu satir icinde 1..3:
+    dongu sutun icinde 1..3:
+        eger sutun > satir:
+            kir
+        konsol.yaz(f"{satir}{sutun} ")
+    yazdir()
+```
+```cikti
+11
+21 22
+31 32 33
+```
+
+## Hepsi bir arada: asal sayılar
+
+Bir sayı, 1 ve kendisinden başka böleni yoksa asaldır. Her aday için bölen arıyoruz; bulunca `kir` ile içteki döngüden çıkıyoruz.
+
+```kbl
+dongu aday icinde 2..30:
+    asal = dogru
+    bolen = 2
+    iken bolen * bolen <= aday:
+        eger aday % bolen == 0:
+            asal = yanlis
+            kir
+        bolen += 1
+    eger asal:
+        konsol.yaz(f"{aday} ")
+yazdir()
+```
+```cikti
+2 3 5 7 11 13 17 19 23 29
+```
+
+## Alıştırma
+
+```alistirma
+`urunler` listesinde ilk `"süt"`ü bul: bulunduğu sırayı (1'den sayarak) `süt 3. sırada` biçiminde yazdır ve döngüden çık.
+%%%
+urunler = ["ekmek", "peynir", "süt", "yumurta", "süt"]
+sira = 0
+dongu u icinde urunler:
+    sira += 1
+    # buraya yaz
+%%%
+urunler = ["ekmek", "peynir", "süt", "yumurta", "süt"]
+sira = 0
+dongu u icinde urunler:
+    sira += 1
+    eger u == "süt":
+        yazdir(f"süt {sira}. sırada")
+        kir
+%%%
+süt 3. sırada
+```
+
+```alistirma
+1'den 20'ye kadar sayıları gez. Çift sayıları `devam` ile atla, tek sayıların toplamını bulup yazdır.
+%%%
+toplam = 0
+dongu i icinde 1..20:
+    # buraya yaz
+yazdir(toplam)
+%%%
+toplam = 0
+dongu i icinde 1..20:
+    eger i % 2 == 0:
+        devam
+    toplam += i
+yazdir(toplam)
+%%%
+100
+```
@@ -0,0 +1,159 @@
+---
+baslik: Listeler
+bolum: Veri yapıları
+ozet: Değerleri sırayla tutmak, indeksle okumak ve değiştirmek
+---
+
+Bir sınıfın 30 notunu 30 ayrı değişkende tutamazsın. Liste, birçok değeri sırayla tek bir adın altında tutar.
+
+## Liste oluşturmak
+
+Köşeli parantez içine öğeleri virgülle ayırarak yazarsın.
+
+```kbl
+meyveler = ["elma", "armut", "kiraz"]
+notlar = [72, 95, 48, 88]
+yazdir(meyveler)
+yazdir(notlar)
+```
+```cikti
+[elma, armut, kiraz]
+[72, 95, 48, 88]
+```
+
+Bir listedeki öğelerin hepsi **aynı türde** olmalıdır: hepsi sayı, hepsi metin gibi.
+
+## Uzunluk
+
+`uzunluk()` listedeki öğe sayısını verir.
+
+```kbl
+meyveler = ["elma", "armut", "kiraz"]
+yazdir(meyveler.uzunluk())
+```
+```cikti
+3
+```
+
+## Öğelere erişmek
+
+Her öğenin bir sıra numarası (indeksi) vardır. Sayma **0'dan** başlar. Negatif indeks sondan sayar.
+
+```kbl
+gunler = ["Pazartesi", "Salı", "Çarşamba", "Perşembe", "Cuma"]
+yazdir(gunler[0])
+yazdir(gunler[2])
+yazdir(gunler[-1])
+yazdir(gunler[-2])
+```
+```cikti
+Pazartesi
+Çarşamba
+Cuma
+Perşembe
+```
+
+> **Dikkat:** Listede olmayan bir indeksi okumak programı durdurur. 5 öğeli bir listede geçerli indeksler 0'dan 4'e kadardır; `gunler[5]` çalışma anında "liste sınır dışı" hatası verir.
+
+## Öğe değiştirmek
+
+İndeksle bir öğeye yeni değer atayabilirsin.
+
+```kbl
+sepet = ["ekmek", "süt", "çay"]
+sepet[1] = "ayran"
+yazdir(sepet)
+```
+```cikti
+[ekmek, ayran, çay]
+```
+
+## Parça almak
+
+`liste[a..b]` a'dan b'ye kadar olan öğeleri (b dahil) yeni bir liste olarak verir. `dilim(baslangic, adet)` ise bir yerden başlayıp belli sayıda öğe alır.
+
+```kbl
+sayilar = [10, 20, 30, 40, 50, 60]
+yazdir(sayilar[1..3])
+yazdir(sayilar.dilim(3, 2))
+```
+```cikti
+[20, 30, 40]
+[40, 50]
+```
+
+## Boş listeyle başlamak ve ekleme
+
+`[]` boş bir listedir. `ekle()` sona bir öğe ekler.
+
+```kbl
+alisveris = []
+alisveris.ekle("domates")
+alisveris.ekle("biber")
+alisveris.ekle("patlıcan")
+yazdir(alisveris)
+yazdir(alisveris.uzunluk())
+```
+```cikti
+[domates, biber, patlıcan]
+3
+```
+
+> **İpucu:** Boş listenin türü, ona ilk eklediğin değerden anlaşılır. Türü baştan belirtmek istersen `notlar: liste<sayi> = []` yazabilirsin.
+
+## Liste ve döngü
+
+Listeler en çok döngüyle birlikte kullanılır.
+
+```kbl
+fiyatlar = [12.5, 34.9, 8.75]
+toplam = 0.0
+dongu f icinde fiyatlar:
+    toplam += f
+yazdir(f"Toplam: {toplam:.2f} TL")
+```
+```cikti
+Toplam: 56.15 TL
+```
+
+## Liste içinde liste
+
+Listenin öğeleri de liste olabilir; tablo gibi düşünebilirsin. `tablo[satir][sutun]` diye okunur.
+
+```kbl
+tablo = [[3, 8, 1], [9, 4, 7]]
+yazdir(tablo[0])
+yazdir(tablo[1][0])
+```
+```cikti
+[3, 8, 1]
+9
+```
+
+## Alıştırma
+
+```alistirma
+`sehirler` listesinin ilk ve son öğesini ve öğe sayısını aynı satırda yazdır.
+%%%
+sehirler = ["Edirne", "Bursa", "Konya", "Kars"]
+# buraya yaz
+%%%
+sehirler = ["Edirne", "Bursa", "Konya", "Kars"]
+yazdir(sehirler[0], sehirler[-1], sehirler.uzunluk())
+%%%
+Edirne Kars 4
+```
+
+```alistirma
+Boş bir `kareler` listesi oluştur. 1'den 6'ya kadar her sayının karesini listeye ekle ve listeyi yazdır.
+%%%
+kareler = []
+# buraya yaz
+%%%
+kareler = []
+dongu i icinde 1..6:
+    kareler.ekle(i * i)
+yazdir(kareler)
+%%%
+[1, 4, 9, 16, 25, 36]
+```
@@ -0,0 +1,186 @@
+---
+baslik: Liste işlemleri
+bolum: Veri yapıları
+ozet: Aramak, silmek, sıralamak, birleştirmek ve koleksiyon modülü
+---
+
+Listeyi oluşturmayı öğrendin. Şimdi listeyle yapılan günlük işlere bakalım: bir öğe var mı, nerede, nasıl silinir, nasıl sıralanır.
+
+## Aramak: icerir ve bul
+
+`icerir(x)` öğe listede var mı diye sorar. `bul(x)` öğenin indeksini verir; yoksa `-1` döner.
+
+```kbl
+meyveler = ["elma", "armut", "kiraz"]
+yazdir(meyveler.icerir("kiraz"))
+yazdir(meyveler.bul("kiraz"))
+yazdir(meyveler.bul("karpuz"))
+```
+```cikti
+doğru
+2
+-1
+```
+
+## Silmek: sil
+
+`sil(i)` **i'nci sıradaki** öğeyi siler; değere göre değil, konuma göre çalışır. Bir değeri silmek için önce `bul()` ile yerini bulursun.
+
+```kbl
+meyveler = ["elma", "armut", "kiraz", "muz"]
+meyveler.sil(0)
+yazdir(meyveler)
+konum = meyveler.bul("kiraz")
+eger konum != -1:
+    meyveler.sil(konum)
+yazdir(meyveler)
+```
+```cikti
+[armut, kiraz, muz]
+[armut, muz]
+```
+
+`temizle()` bütün öğeleri siler, `bos_mu()` listenin boş olup olmadığını söyler.
+
+```kbl
+sepet = ["ekmek", "süt"]
+sepet.temizle()
+yazdir(sepet.bos_mu())
+```
+```cikti
+doğru
+```
+
+## Sıralamak: sirala
+
+`sirala()` listeyi yerinde, küçükten büyüğe dizer. Metinler Türk alfabesine göre sıralanır: Ç, C'den sonra; İ, I'dan sonra gelir.
+
+```kbl
+notlar = [72, 95, 48, 88]
+notlar.sirala()
+yazdir(notlar)
+
+isimler = ["Zeynep", "Ömer", "Can", "Çağla", "İlker", "Işıl", "Ahmet"]
+isimler.sirala()
+yazdir(isimler)
+```
+```cikti
+[48, 72, 88, 95]
+[Ahmet, Can, Çağla, Işıl, İlker, Ömer, Zeynep]
+```
+
+## Metne çevirmek: birlestir
+
+Bir metin listesini `birlestir(ayrac)` ile tek bir metne çevirirsin.
+
+```kbl
+renkler = ["kırmızı", "beyaz"]
+yazdir(renkler.birlestir(" ve "))
+```
+```cikti
+kırmızı ve beyaz
+```
+
+## Koşula uyanları toplamak
+
+Boş bir listeyle başlayıp koşula uyan öğeleri eklemek çok sık yapılan bir iştir.
+
+```kbl
+notlar = [72, 95, 48, 88, 35, 61]
+gecenler = []
+dongu n icinde notlar:
+    eger n >= 50:
+        gecenler.ekle(n)
+yazdir(gecenler)
+```
+```cikti
+[72, 95, 88, 61]
+```
+
+## Öğeleri indeksle güncellemek
+
+Listedeki her öğeyi değiştirmek için indeksle dönersin.
+
+```kbl
+fiyatlar = [100, 250, 40]
+dongu i icinde 0..fiyatlar.uzunluk() - 1:
+    fiyatlar[i] = fiyatlar[i] * 2
+yazdir(fiyatlar)
+```
+```cikti
+[200, 500, 80]
+```
+
+## koleksiyon modülü
+
+Toplam, en büyük, en küçük gibi işler için `kullan kaba.koleksiyon` yazıp hazır fonksiyonları kullanabilirsin. Bu fonksiyonlar asıl listeyi değiştirmez, sonuç döndürür.
+
+```kbl
+kullan kaba.koleksiyon
+notlar = [72, 95, 48, 88, 72]
+yazdir(koleksiyon.topla(notlar))
+yazdir(koleksiyon.en_buyuk(notlar))
+yazdir(koleksiyon.en_kucuk(notlar))
+yazdir(koleksiyon.say(notlar, 72))
+yazdir(koleksiyon.sirali(notlar))
+yazdir(koleksiyon.ters(notlar))
+yazdir(notlar)
+```
+```cikti
+375
+95
+48
+2
+[48, 72, 72, 88, 95]
+[72, 88, 48, 95, 72]
+[72, 95, 48, 88, 72]
+```
+
+| Fonksiyon | Ne verir |
+|---|---|
+| `koleksiyon.topla(l)` | öğelerin toplamı |
+| `koleksiyon.en_buyuk(l)` / `en_kucuk(l)` | en büyük / en küçük öğe |
+| `koleksiyon.say(l, x)` | x kaç kez geçiyor |
+| `koleksiyon.sirali(l)` | sıralı bir kopya |
+| `koleksiyon.ters(l)` | ters çevrilmiş bir kopya |
+| `koleksiyon.benzersiz(l)` | tekrarları atılmış bir kopya |
+
+> **Dikkat:** Listenin kendisinde `toplam()`, `en_buyuk()` ya da `ters_cevir()` diye yöntem yoktur. Bunlar için ya döngü yazarsın ya da `koleksiyon` modülünü kullanırsın.
+
+## Alıştırma
+
+```alistirma
+`misafirler` listesinden `"Kemal"`i sil (önce `bul` ile yerini bul), sonra listeyi alfabetik sırala ve virgülle birleştirip yazdır.
+%%%
+misafirler = ["Selin", "Kemal", "Burak", "Ayla"]
+# buraya yaz
+%%%
+misafirler = ["Selin", "Kemal", "Burak", "Ayla"]
+konum = misafirler.bul("Kemal")
+misafirler.sil(konum)
+misafirler.sirala()
+yazdir(misafirler.birlestir(", "))
+%%%
+Ayla, Burak, Selin
+```
+
+```alistirma
+`sicakliklar` listesindeki en yüksek ve en düşük değeri **döngüyle** (modül kullanmadan) bul ve `En yüksek 31, en düşük 18` biçiminde yazdır.
+%%%
+sicakliklar = [24, 31, 18, 27, 22]
+en_yuksek = sicakliklar[0]
+en_dusuk = sicakliklar[0]
+# buraya yaz
+%%%
+sicakliklar = [24, 31, 18, 27, 22]
+en_yuksek = sicakliklar[0]
+en_dusuk = sicakliklar[0]
+dongu s icinde sicakliklar:
+    eger s > en_yuksek:
+        en_yuksek = s
+    eger s < en_dusuk:
+        en_dusuk = s
+yazdir(f"En yüksek {en_yuksek}, en düşük {en_dusuk}")
+%%%
+En yüksek 31, en düşük 18
+```
@@ -0,0 +1,176 @@
+---
+baslik: Sözlükler
+bolum: Veri yapıları
+ozet: Anahtar-değer çiftleri, ekleme, sorgulama, gezme ve sayım
+---
+
+Listede bir öğeye sıra numarasıyla ulaşırsın. Ama "Ankara'nın plakası kaç?" sorusunda sıra numarası işe yaramaz. Sözlük, her değeri bir **anahtarla** eşleştirir: `plaka["Ankara"]` gibi.
+
+## Sözlük oluşturmak
+
+Süslü parantez içine `anahtar: değer` çiftlerini virgülle ayırarak yazarsın.
+
+```kbl
+plaka = {"İstanbul": 34, "Ankara": 6, "İzmir": 35}
+yazdir(plaka["Ankara"])
+yazdir(plaka.uzunluk())
+```
+```cikti
+6
+3
+```
+
+## Ekleme ve güncelleme
+
+Olmayan bir anahtara değer atamak yeni çift ekler; var olan bir anahtara atamak değeri değiştirir.
+
+```kbl
+stok = {"elma": 40, "armut": 25}
+stok["kiraz"] = 12
+stok["elma"] = stok["elma"] - 5
+yazdir(stok["elma"])
+yazdir(stok["kiraz"])
+```
+```cikti
+35
+12
+```
+
+## Anahtar var mı?
+
+Sözlükte olmayan bir anahtarı okumak programı hatayla durdurur. Emin değilsen önce `var_mi()` ile sor.
+
+```kbl
+plaka = {"İstanbul": 34, "Ankara": 6}
+dongu sehir icinde ["Ankara", "Konya"]:
+    eger plaka.var_mi(sehir):
+        yazdir(f"{sehir}: {plaka[sehir]}")
+    degilse:
+        yazdir(f"{sehir}: kayıtlı değil")
+```
+```cikti
+Ankara: 6
+Konya: kayıtlı değil
+```
+
+## Silmek
+
+Sözlükte `sil()` **anahtara** göre siler (listede konuma göre silerdi).
+
+```kbl
+stok = {"elma": 40, "armut": 25, "kiraz": 12}
+stok.sil("armut")
+yazdir(stok.uzunluk())
+yazdir(stok.var_mi("armut"))
+```
+```cikti
+2
+yanlış
+```
+
+## Sözlükte gezmek
+
+`anahtarlar()` bütün anahtarları bir liste olarak verir. Her anahtar için değeri `sozluk[anahtar]` ile okursun.
+
+```kbl
+fiyat = {"ekmek": 12.5, "süt": 34.9, "peynir": 149.0}
+anahtarlar = fiyat.anahtarlar()
+anahtarlar.sirala()
+dongu urun icinde anahtarlar:
+    yazdir(f"{urun:<8}{fiyat[urun]:>8.2f} TL")
+```
+```cikti
+ekmek      12.50 TL
+peynir    149.00 TL
+süt        34.90 TL
+```
+
+> **Dikkat:** `anahtarlar()` listesi ekleme sırasında gelmez. Belli bir sırada gezmek istiyorsan yukarıdaki gibi önce `sirala()` ile sırala.
+
+## Sayım: en sık kullanılan sözlük işi
+
+Bir metinde hangi kelimenin kaç kez geçtiğini sayalım. Her kelime için: daha önce gördüysek sayısını artırırız, görmediysek 1 ile başlatırız.
+
+```kbl
+cumle = "bir elma bir armut iki elma bir kiraz"
+sayim = {}
+dongu kelime icinde cumle.bol(" "):
+    eger sayim.var_mi(kelime):
+        sayim[kelime] = sayim[kelime] + 1
+    degilse:
+        sayim[kelime] = 1
+kelimeler = sayim.anahtarlar()
+kelimeler.sirala()
+dongu k icinde kelimeler:
+    yazdir(f"{k}: {sayim[k]}")
+```
+```cikti
+armut: 1
+bir: 3
+elma: 2
+iki: 1
+kiraz: 1
+```
+
+## Değerleri toplamak
+
+Bir sözlükteki sayıların toplamını anahtarlar üzerinden dönerek bulursun.
+
+```kbl
+notlar = {"Ayşe": 88, "Mehmet": 64, "Elif": 92}
+toplam = 0
+dongu ad icinde notlar.anahtarlar():
+    toplam += notlar[ad]
+yazdir(f"Ortalama: {toplam / notlar.uzunluk():.1f}")
+```
+```cikti
+Ortalama: 81.3
+```
+
+> **İpucu:** Bir sözlüğün bütün değerleri aynı türde olsun: hepsi sayı ya da hepsi metin. Öğrencinin adını, notunu ve şehrini birlikte tutmak istiyorsan *Yapılar* dersindeki `yapi` daha uygun bir araçtır.
+
+## Alıştırma
+
+```alistirma
+`telefon` sözlüğüne `"Can": "0532 111 22 33"` kaydını ekle. Sonra `"Can"` ve `"Deniz"` için ya numarayı ya da `Deniz: bulunamadı` yazdır.
+%%%
+telefon = {"Ayşe": "0555 123 45 67"}
+# buraya yaz
+%%%
+telefon = {"Ayşe": "0555 123 45 67"}
+telefon["Can"] = "0532 111 22 33"
+dongu ad icinde ["Can", "Deniz"]:
+    eger telefon.var_mi(ad):
+        yazdir(f"{ad}: {telefon[ad]}")
+    degilse:
+        yazdir(f"{ad}: bulunamadı")
+%%%
+Can: 0532 111 22 33
+Deniz: bulunamadı
+```
+
+```alistirma
+`metin_` içindeki her harfin kaç kez geçtiğini say (boşlukları atla). Harfleri sıralayıp `a 3` biçiminde, her biri ayrı satırda yazdır.
+%%%
+metin_ = "kar kara"
+sayim = {}
+# buraya yaz
+%%%
+metin_ = "kar kara"
+sayim = {}
+dongu h icinde metin_:
+    eger h == " ":
+        devam
+    eger sayim.var_mi(h):
+        sayim[h] = sayim[h] + 1
+    degilse:
+        sayim[h] = 1
+harfler = sayim.anahtarlar()
+harfler.sirala()
+dongu h icinde harfler:
+    yazdir(f"{h} {sayim[h]}")
+%%%
+a 3
+k 2
+r 2
+```
@@ -0,0 +1,168 @@
+---
+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
+```
+
+> **Dikkat:** Fonksiyonun içinde, programın başka bir yerinde kullandığın değişken adlarını kullanmamaya özen göster; her fonksiyonun içinde kendine özgü adlar seç. İyi bir alışkanlık da şudur: fonksiyonlarını dosyanın başına yaz, programın asıl işini altlarına koy.
+
+## 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
+```
@@ -0,0 +1,200 @@
+---
+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
+```
@@ -0,0 +1,172 @@
+---
+baslik: Özyineleme
+bolum: Fonksiyonlar
+ozet: Kendini çağıran fonksiyonlar, durma koşulu ve klasik örnekler
+---
+
+Bazı problemler kendisinin daha küçük bir kopyasını içerir: 5! = 5 × 4!, bir klasörün boyutu = içindeki dosyalar + alt klasörlerin boyutu. Böyle problemleri, kendini çağıran fonksiyonlarla (özyineleme) çok doğal çözersin.
+
+## Faktöriyel
+
+n! = n × (n-1)! ve 1! = 1. Fonksiyon kendini bir küçük sayıyla çağırır; n 1'e inince durur.
+
+```kbl
+fonksiyon faktoriyel(n: sayi) -> sayi:
+    eger n <= 1:
+        don 1
+    don n * faktoriyel(n - 1)
+
+yazdir(faktoriyel(5))
+yazdir(faktoriyel(10))
+```
+```cikti
+120
+3628800
+```
+
+Her özyinelemeli fonksiyonun iki parçası vardır:
+
+1. **Durma koşulu:** cevabın doğrudan bilindiği en küçük durum (`n <= 1` ise 1).
+2. **Küçülten adım:** problemi biraz küçültüp fonksiyonu yeniden çağırmak (`faktoriyel(n - 1)`).
+
+> **Dikkat:** Durma koşulunu unutursan ya da adım problemi küçültmezse fonksiyon kendini sonsuza dek çağırır ve program çöker. Her çağrının durma koşuluna biraz daha yaklaştığından emin ol.
+
+## Adım adım izlemek
+
+Ne olduğunu görmek için fonksiyonun içine `yazdir` koyalım.
+
+```kbl
+fonksiyon geri_say(n: sayi):
+    eger n == 0:
+        yazdir("Kalkış!")
+        don
+    yazdir(n)
+    geri_say(n - 1)
+
+geri_say(3)
+```
+```cikti
+3
+2
+1
+Kalkış!
+```
+
+Bu fonksiyon değer döndürmez; tek başına `don` yazmak fonksiyondan çıkmak demektir.
+
+## Basamakların toplamı
+
+4729 → 4 + 7 + 2 + 9. Son basamak `n % 10`, geri kalan `n // 10`'dur.
+
+```kbl
+fonksiyon basamak_toplami(n: sayi) -> sayi:
+    eger n < 10:
+        don n
+    don n % 10 + basamak_toplami(n // 10)
+
+yazdir(basamak_toplami(4729))
+```
+```cikti
+22
+```
+
+## Fibonacci
+
+Her sayı kendinden önceki iki sayının toplamıdır: 0, 1, 1, 2, 3, 5, 8...
+
+```kbl
+fonksiyon fib(n: sayi) -> sayi:
+    eger n < 2:
+        don n
+    don fib(n - 1) + fib(n - 2)
+
+dongu i icinde 0..10:
+    konsol.yaz(f"{fib(i)} ")
+yazdir()
+```
+```cikti
+0 1 1 2 3 5 8 13 21 34 55
+```
+
+> **İpucu:** Bu Fibonacci fonksiyonu aynı değerleri defalarca hesaplar; `fib(40)` gibi büyük değerlerde çok yavaşlar. Özyineleme her zaman en hızlı yol değildir; aynı işi bir `iken` döngüsüyle de yapabilirsin.
+
+## Metni ters çevirmek
+
+Özyineleme yalnız sayılarla çalışmaz. Bir metnin tersi = ilk harf hariç kalanın tersi + ilk harf.
+
+```kbl
+fonksiyon ters(m: metin) -> metin:
+    eger m.uzunluk() <= 1:
+        don m
+    don ters(m.dilim(1, m.uzunluk() - 1)) + m[0]
+
+yazdir(ters("kalem"))
+yazdir(ters("Ey Edip"))
+```
+```cikti
+melak
+pidE yE
+```
+
+## Hanoi kuleleri
+
+n diski A'dan C'ye taşımak için: n-1 diski B'ye taşı, en büyüğünü C'ye taşı, n-1 diski B'den C'ye taşı. Üç satırlık bir tanım, döngüyle yazması zor bir işi çözer.
+
+```kbl
+fonksiyon hanoi(n: sayi, kaynak: metin, hedef: metin, ara: metin):
+    eger n == 0:
+        don
+    hanoi(n - 1, kaynak, ara, hedef)
+    yazdir(f"{n}. diski {kaynak} → {hedef}")
+    hanoi(n - 1, ara, hedef, kaynak)
+
+hanoi(3, "A", "C", "B")
+```
+```cikti
+1. diski A → C
+2. diski A → B
+1. diski C → B
+3. diski A → C
+1. diski B → A
+2. diski B → C
+1. diski A → C
+```
+
+## Alıştırma
+
+```alistirma
+`us(taban: sayi, kuvvet: sayi) -> sayi` fonksiyonunu özyinelemeyle yaz: `us(t, 0)` 1'dir, `us(t, k)` ise `t * us(t, k - 1)`'dir. `us(2, 10)` ve `us(3, 4)` sonuçlarını yazdır.
+%%%
+# buraya yaz
+
+yazdir(us(2, 10))
+yazdir(us(3, 4))
+%%%
+fonksiyon us(taban: sayi, kuvvet: sayi) -> sayi:
+    eger kuvvet == 0:
+        don 1
+    don taban * us(taban, kuvvet - 1)
+
+yazdir(us(2, 10))
+yazdir(us(3, 4))
+%%%
+1024
+81
+```
+
+```alistirma
+`liste_toplami(l: liste<sayi>, i: sayi) -> sayi` fonksiyonunu özyinelemeyle yaz: listenin `i`'nci öğesinden sonuna kadar olan öğelerin toplamını döndürsün. `i` listenin uzunluğuna eşitse 0 döndür.
+%%%
+# buraya yaz
+
+yazdir(liste_toplami([4, 8, 15, 16, 23, 42], 0))
+%%%
+fonksiyon liste_toplami(l: liste<sayi>, i: sayi) -> sayi:
+    eger i == l.uzunluk():
+        don 0
+    don l[i] + liste_toplami(l, i + 1)
+
+yazdir(liste_toplami([4, 8, 15, 16, 23, 42], 0))
+%%%
+108
+```
@@ -0,0 +1,210 @@
+---
+baslik: Yapılar
+bolum: Kendi türlerin
+ozet: yapi ile ilgili verileri tek bir türde toplamak
+---
+
+Bir kitabın adı, yazarı, sayfa sayısı ve yılı birbirine aittir. Bunları dört ayrı değişkende ya da dört ayrı listede tutmak çabuk karışır. `yapi` ile kendi türünü tanımlar, bu bilgileri tek bir değerde toplarsın.
+
+## Yapı tanımlamak
+
+Yapının her alanına bir varsayılan değer verirsin; alanın türü bu değerden anlaşılır.
+
+```kbl
+yapi Kitap:
+    ad = ""
+    yazar = ""
+    sayfa = 0
+    yil = 0
+
+k = Kitap("Kuyucaklı Yusuf", "Sabahattin Ali", 232, 1937)
+yazdir(k.ad)
+yazdir(k.sayfa)
+yazdir(k)
+```
+```cikti
+Kuyucaklı Yusuf
+232
+Kitap(ad: Kuyucaklı Yusuf, yazar: Sabahattin Ali, sayfa: 232, yil: 1937)
+```
+
+`Kitap(...)` yeni bir nesne oluşturur; değerler alanların tanım sırasıyla verilir. Alanlara `nesne.alan` diye ulaşırsın.
+
+## Nesne oluşturmanın yolları
+
+Boş bir nesne oluşturup alanları sonra da doldurabilir, ya da yalnız bazı alanları adıyla verebilirsin. Verilmeyen alanlar varsayılan değerinde kalır.
+
+```kbl
+yapi Kitap:
+    ad = ""
+    yazar = ""
+    sayfa = 0
+
+k1 = Kitap()
+k1.ad = "Çalıkuşu"
+k1.sayfa = 544
+yazdir(k1)
+
+k2 = Kitap(ad="İnce Memed", yazar="Yaşar Kemal")
+yazdir(k2)
+```
+```cikti
+Kitap(ad: Çalıkuşu, yazar: , sayfa: 544)
+Kitap(ad: İnce Memed, yazar: Yaşar Kemal, sayfa: 0)
+```
+
+## Metotlar
+
+Yapının içine fonksiyon yazabilirsin; bunlara **metot** denir. Yapı metotları alanlara doğrudan adıyla ulaşır.
+
+```kbl
+yapi Urun:
+    ad = ""
+    fiyat = 0.0
+    adet = 0
+
+    fonksiyon tutar() -> ondalik:
+        don fiyat * adet
+
+    fonksiyon etiket() -> metin:
+        don f"{ad} x{adet}: {tutar():.2f} TL"
+
+u = Urun("Defter", 24.5, 3)
+yazdir(u.tutar())
+yazdir(u.etiket())
+u.adet = 5
+yazdir(u.etiket())
+```
+```cikti
+73.5
+Defter x3: 73.50 TL
+Defter x5: 122.50 TL
+```
+
+## Nesne listesi
+
+Yapılar listelerde tutulabilir. Böylece bir tabloyu çok rahat işlersin.
+
+```kbl
+yapi Ogrenci:
+    ad = ""
+    puan = 0
+
+sinif_listesi = [Ogrenci("Ayşe", 88), Ogrenci("Mehmet", 64), Ogrenci("Elif", 92)]
+sinif_listesi.ekle(Ogrenci("Can", 47))
+
+en_iyi = sinif_listesi[0]
+dongu o icinde sinif_listesi:
+    durum = "geçti" eger o.puan >= 50 degilse "kaldı"
+    yazdir(f"{o.ad:<8}{o.puan:>4}  {durum}")
+    eger o.puan > en_iyi.puan:
+        en_iyi = o
+yazdir(f"En yüksek puan: {en_iyi.ad} ({en_iyi.puan})")
+```
+```cikti
+Ayşe      88  geçti
+Mehmet    64  geçti
+Elif      92  geçti
+Can       47  kaldı
+En yüksek puan: Elif (92)
+```
+
+## Karşılaştırmak
+
+İki yapı nesnesi, bütün alanları eşitse eşittir.
+
+```kbl
+yapi Nokta:
+    x = 0
+    y = 0
+
+a = Nokta(3, 4)
+b = Nokta(3, 4)
+c = Nokta(0, 4)
+yazdir(a == b)
+yazdir(a == c)
+```
+```cikti
+doğru
+yanlış
+```
+
+## Atama bir kopya oluşturur
+
+Bir yapı nesnesini başka bir değişkene atamak **kopyasını** oluşturur. Kopyayı değiştirmek aslını etkilemez.
+
+```kbl
+yapi Nokta:
+    x = 0
+    y = 0
+
+a = Nokta(1, 2)
+b = a
+b.x = 99
+yazdir(a.x)
+yazdir(b.x)
+```
+```cikti
+1
+99
+```
+
+> **Dikkat:** Aynı kural fonksiyonlar için de geçerli: bir fonksiyona yapı verirsen fonksiyon kopyasını değiştirir. Nesnenin kendisini değiştirmek istiyorsan işi yapının **metodu** olarak yaz (bir sonraki ders), ya da değiştirilmiş nesneyi döndürüp yeniden ata.
+
+> **İpucu:** Tür adlarını büyük harfle başlat (`Kitap`, `Ogrenci`); değişken adlarını küçük harfle. `Hata`, `Liste`, `Metin` gibi bazı adlar dilin kendi türlerine ayrılmıştır, onları seçme.
+
+## Alıştırma
+
+```alistirma
+`Dikdortgen` adında, `en` ve `boy` alanları (varsayılan 0) ile `alan()` ve `cevre()` metotları olan bir yapı tanımla. `Dikdortgen(6, 4)` için alanı ve çevreyi aynı satırda yazdır.
+%%%
+# buraya yaz
+
+d = Dikdortgen(6, 4)
+yazdir(d.alan(), d.cevre())
+%%%
+yapi Dikdortgen:
+    en = 0
+    boy = 0
+
+    fonksiyon alan() -> sayi:
+        don en * boy
+
+    fonksiyon cevre() -> sayi:
+        don 2 * (en + boy)
+
+d = Dikdortgen(6, 4)
+yazdir(d.alan(), d.cevre())
+%%%
+24 20
+```
+
+```alistirma
+Verilen `Film` yapısıyla bir liste oluşturulmuş. 1990'dan sonra çıkan filmlerin adlarını ve hepsinin toplam süresini yazdır.
+%%%
+yapi Film:
+    ad = ""
+    yil = 0
+    sure = 0
+
+filmler = [Film("Eşkıya", 1996, 128), Film("Selvi Boylum Al Yazmalım", 1977, 90), Film("Kış Uykusu", 2014, 196)]
+toplam_sure = 0
+# buraya yaz
+%%%
+yapi Film:
+    ad = ""
+    yil = 0
+    sure = 0
+
+filmler = [Film("Eşkıya", 1996, 128), Film("Selvi Boylum Al Yazmalım", 1977, 90), Film("Kış Uykusu", 2014, 196)]
+toplam_sure = 0
+dongu f icinde filmler:
+    eger f.yil > 1990:
+        yazdir(f.ad)
+    toplam_sure += f.sure
+yazdir(f"Toplam süre: {toplam_sure} dakika")
+%%%
+Eşkıya
+Kış Uykusu
+Toplam süre: 414 dakika
+```
@@ -0,0 +1,231 @@
+---
+baslik: Sınıflar ve metotlar
+bolum: Kendi türlerin
+ozet: sinif, kurucu (kur), self ile metotlar ve kalıtım
+---
+
+Yapı veriyi bir arada tutar. Bir banka hesabı ise yalnız veri değildir: para yatırılır, çekilir, yetersiz bakiyede işlem reddedilir. Davranışı olan nesneler için `sinif` kullanırsın.
+
+## Sınıf, kurucu ve self
+
+`sinif` tanımı yapıya benzer. Farkları:
+
+- `fonksiyon kur(self, ...)` bir **kurucudur**: nesne oluşturulurken çalışır.
+- Metotların ilk parametresi `self`'tir: "bu nesnenin kendisi" demektir. Alanlara `self.alan` ile ulaşırsın.
+
+```kbl
+sinif Hesap:
+    sahip = ""
+    bakiye = 0.0
+
+    fonksiyon kur(self, kisi: metin, ilk: ondalik):
+        self.sahip = kisi
+        self.bakiye = ilk
+
+    fonksiyon yatir(self, miktar: ondalik):
+        self.bakiye += miktar
+
+    fonksiyon ozet(self) -> metin:
+        don f"{self.sahip}: {self.bakiye:.2f} TL"
+
+h = Hesap("Ayşe", 100.0)
+h.yatir(50.0)
+yazdir(h.ozet())
+```
+```cikti
+Ayşe: 150.00 TL
+```
+
+`Hesap("Ayşe", 100.0)` yazınca `kur(self, "Ayşe", 100.0)` çağrılır.
+
+## Metot nesneyi kalıcı olarak değiştirir
+
+Metot kendi nesnesinin alanlarını değiştirdiğinde değişiklik kalıcıdır. Bir metot ayrıca değer de döndürebilir.
+
+```kbl
+sinif Hesap:
+    bakiye = 0.0
+
+    fonksiyon kur(self, ilk: ondalik):
+        self.bakiye = ilk
+
+    fonksiyon cek(self, miktar: ondalik) -> mantik:
+        eger miktar > self.bakiye:
+            don yanlis
+        self.bakiye -= miktar
+        don dogru
+
+h = Hesap(100.0)
+yazdir(h.cek(30.0))
+yazdir(h.cek(500.0))
+yazdir(h.bakiye)
+```
+```cikti
+doğru
+yanlış
+70.0
+```
+
+## Her nesnenin kendi alanları vardır
+
+Aynı sınıftan oluşturulan nesneler birbirinden bağımsızdır.
+
+```kbl
+sinif Sayac:
+    adet = 0
+
+    fonksiyon kur(self, baslangic: sayi):
+        self.adet = baslangic
+
+    fonksiyon artir(self):
+        self.adet += 1
+
+a = Sayac(0)
+b = Sayac(10)
+a.artir()
+a.artir()
+b.artir()
+yazdir(f"a: {a.adet}, b: {b.adet}")
+```
+```cikti
+a: 2, b: 11
+```
+
+## Metot başka bir nesne alabilir
+
+```kbl
+yapi Kitap:
+    ad = ""
+    sayfa = 0
+
+sinif Okuyucu:
+    ad = ""
+    okunan_sayfa = 0
+    kitap_sayisi = 0
+
+    fonksiyon kur(self, isim: metin):
+        self.ad = isim
+
+    fonksiyon bitirdi(self, k: Kitap):
+        self.okunan_sayfa += k.sayfa
+        self.kitap_sayisi += 1
+
+    fonksiyon rapor(self) -> metin:
+        don f"{self.ad}: {self.kitap_sayisi} kitap, {self.okunan_sayfa} sayfa"
+
+elif = Okuyucu("Elif")
+elif.bitirdi(Kitap("Çalıkuşu", 544))
+elif.bitirdi(Kitap("Kuyucaklı Yusuf", 232))
+yazdir(elif.rapor())
+```
+```cikti
+Elif: 2 kitap, 776 sayfa
+```
+
+> **Dikkat:** Kurucunun adı mutlaka `kur`, ilk parametresi `self` olmalıdır. Parametre adını alanla aynı seçmek yerine farklı bir ad ver (`self.ad = isim`); kod daha kolay okunur.
+
+## Kalıtım
+
+Bir sınıf başka bir sınıfın alanlarını ve metotlarını devralabilir. Taban sınıfın adı parantez içinde yazılır. Türev sınıf bir metodu yeniden tanımlarsa (geçersiz kılma) kendi sürümü kullanılır.
+
+```kbl
+sinif Hayvan:
+    ad = ""
+
+    fonksiyon kur(self, isim: metin):
+        self.ad = isim
+
+    fonksiyon ses(self) -> metin:
+        don "..."
+
+    fonksiyon tanit(self) -> metin:
+        don f"Ben {self.ad}."
+
+sinif Kedi(Hayvan):
+    fonksiyon ses(self) -> metin:
+        don "Miyav!"
+
+k = Kedi("Tekir")
+yazdir(k.tanit())
+yazdir(k.ses())
+```
+```cikti
+Ben Tekir.
+Miyav!
+```
+
+`Kedi`'nin kendi `kur`'u yok; `Hayvan`'ınkini devraldı. `tanit` de devralındı, `ses` ise yeniden tanımlandı.
+
+> **İpucu:** Kalıtımda türev sınıfın kendi alanları ve kurucusu varsa, kurucusunun ilk satırında `ust.kur(...)` ile taban sınıfı kurar. Başlangıçta kalıtıma çok yaslanma; çoğu iş için yapılar ve basit sınıflar yeter.
+
+## Alıştırma
+
+```alistirma
+`Termometre` sınıfı yaz: `olcumler` alanı (boş sayı listesi, `liste<sayi> = []`), `ekle(self, d: sayi)` metodu ve ortalamayı döndüren `ortalama(self) -> ondalik` metodu olsun. Verilen ölçümlerle ortalamayı 1 basamakla yazdır.
+%%%
+# buraya yaz
+
+t = Termometre()
+t.ekle(18)
+t.ekle(24)
+t.ekle(27)
+yazdir(f"{t.ortalama():.1f}")
+%%%
+sinif Termometre:
+    olcumler: liste<sayi> = []
+
+    fonksiyon ekle(self, d: sayi):
+        self.olcumler.ekle(d)
+
+    fonksiyon ortalama(self) -> ondalik:
+        toplam = 0
+        dongu o icinde self.olcumler:
+            toplam += o
+        don toplam / self.olcumler.uzunluk()
+
+t = Termometre()
+t.ekle(18)
+t.ekle(24)
+t.ekle(27)
+yazdir(f"{t.ortalama():.1f}")
+%%%
+23.0
+```
+
+```alistirma
+Verilen `Hesap` sınıfına `cek(self, miktar: sayi) -> mantik` metodunu ekle: bakiye yetmezse `yanlis` döndürsün ve bakiyeye dokunmasın. Programın çıktısı aşağıdaki gibi olmalı.
+%%%
+sinif Hesap:
+    bakiye = 0
+
+    fonksiyon kur(self, ilk: sayi):
+        self.bakiye = ilk
+
+    # buraya yaz
+
+h = Hesap(200)
+yazdir(h.cek(150))
+yazdir(h.cek(100))
+yazdir(h.bakiye)
+%%%
+sinif Hesap:
+    bakiye = 0
+
+    fonksiyon kur(self, ilk: sayi):
+        self.bakiye = ilk
+
+    fonksiyon cek(self, miktar: sayi) -> mantik:
+        eger miktar > self.bakiye:
+            don yanlis
+        self.bakiye -= miktar
+        don dogru
+
+h = Hesap(200)
+yazdir(h.cek(150))
+yazdir(h.cek(100))
+yazdir(h.bakiye)
+%%%
+doğru
+yanlış
+50
+```
@@ -0,0 +1,158 @@
+---
+baslik: Sayılabilir türler
+bolum: Kendi türlerin
+ozet: sayilabilir ile sınırlı seçenekleri güvenle tutmak
+---
+
+Bir siparişin durumu "hazırlanıyor", "kargoda" ya da "teslim edildi" olabilir; başka bir şey olamaz. Bunu metinle tutarsan bir gün biri `"kargda"` yazar ve hata gözden kaçar. `sayilabilir`, bir değişkenin alabileceği değerleri baştan sayar; yanlış yazılan bir değer program çalışmadan yakalanır.
+
+## Tanımlamak ve kullanmak
+
+Her üye kendi satırına yazılır. Üyeye `Tur.UYE` diye ulaşırsın.
+
+```kbl
+sayilabilir Durum:
+    HAZIRLANIYOR
+    KARGODA
+    TESLIM_EDILDI
+
+siparis = Durum.KARGODA
+yazdir(siparis)
+eger siparis == Durum.KARGODA:
+    yazdir("Siparişin yolda.")
+```
+```cikti
+KARGODA
+Siparişin yolda.
+```
+
+Yazdırınca üyenin adı görünür.
+
+## Yanlış üye derlenmez
+
+```kbl goster
+sayilabilir Renk:
+    KIRMIZI
+    MAVI
+
+r = Renk.MOR     # derleme hatası: Renk'in MOR diye bir üyesi yok
+```
+
+Bu, sayılabilir türlerin asıl yararıdır: yazım hatası programın çalıştığı ana değil, derlendiği ana yakalanır.
+
+## Seçeneğe göre karar vermek
+
+Sayılabilir değerler `eger / degilse eger` ile çok iyi anlaşır. Bir trafik ışığının sıradaki rengini bulalım.
+
+```kbl
+sayilabilir Isik:
+    KIRMIZI
+    SARI
+    YESIL
+
+fonksiyon sonraki(i: Isik) -> Isik:
+    eger i == Isik.KIRMIZI:
+        don Isik.YESIL
+    degilse eger i == Isik.YESIL:
+        don Isik.SARI
+    don Isik.KIRMIZI
+
+isik = Isik.KIRMIZI
+dongu adim icinde 1..4:
+    yazdir(isik)
+    isik = sonraki(isik)
+```
+```cikti
+KIRMIZI
+YESIL
+SARI
+KIRMIZI
+```
+
+## Üyelerin sayı değerleri
+
+Her üyenin arkasında bir sayı vardır. İlk üye 0'dan başlar; istersen değeri kendin verirsin. Değer yazılmayan üye bir öncekinden devam eder. `sayi()` ile bu değeri alırsın.
+
+```kbl
+sayilabilir Oncelik:
+    DUSUK = 1
+    ORTA
+    YUKSEK = 10
+
+yazdir(sayi(Oncelik.DUSUK))
+yazdir(sayi(Oncelik.ORTA))
+yazdir(sayi(Oncelik.YUKSEK))
+yazdir(Oncelik.YUKSEK > Oncelik.ORTA)
+```
+```cikti
+1
+2
+10
+doğru
+```
+
+## Yapı alanı ve liste öğesi olarak
+
+Sayılabilir bir değer yapının alanı ya da listenin öğesi olabilir.
+
+```kbl
+sayilabilir Tur:
+    KEDI
+    KOPEK
+    KUS
+
+yapi Hayvan:
+    ad = ""
+    tur = Tur.KEDI
+
+barinak = [Hayvan("Pamuk", Tur.KEDI), Hayvan("Karabaş", Tur.KOPEK), Hayvan("Maviş", Tur.KUS), Hayvan("Tekir", Tur.KEDI)]
+kedi_sayisi = 0
+dongu h icinde barinak:
+    yazdir(f"{h.ad:<8}{h.tur}")
+    eger h.tur == Tur.KEDI:
+        kedi_sayisi += 1
+yazdir(f"{kedi_sayisi} kedi var.")
+```
+```cikti
+Pamuk   KEDI
+Karabaş KOPEK
+Maviş   KUS
+Tekir   KEDI
+2 kedi var.
+```
+
+> **Dikkat:** Sözlük değerleri sayılabilir tutamaz: `{"a": Tur.KEDI}` derlenmez. Böyle bir eşleme gerekiyorsa değeri bir yapının alanında tut.
+
+## Alıştırma
+
+```alistirma
+`Mevsim` adında `ILKBAHAR`, `YAZ`, `SONBAHAR`, `KIS` üyeli bir sayılabilir tür tanımla. `mevsim_bul(ay: sayi) -> Mevsim` fonksiyonu ay numarasına göre mevsimi döndürsün (12, 1, 2 kış; 3-5 ilkbahar; 6-8 yaz; 9-11 sonbahar). Verilen aylar için sonucu yazdır.
+%%%
+# buraya yaz
+
+dongu ay icinde [1, 4, 7, 10]:
+    yazdir(mevsim_bul(ay))
+%%%
+sayilabilir Mevsim:
+    ILKBAHAR
+    YAZ
+    SONBAHAR
+    KIS
+
+fonksiyon mevsim_bul(ay: sayi) -> Mevsim:
+    eger ay >= 3 ve ay <= 5:
+        don Mevsim.ILKBAHAR
+    degilse eger ay >= 6 ve ay <= 8:
+        don Mevsim.YAZ
+    degilse eger ay >= 9 ve ay <= 11:
+        don Mevsim.SONBAHAR
+    don Mevsim.KIS
+
+dongu ay icinde [1, 4, 7, 10]:
+    yazdir(mevsim_bul(ay))
+%%%
+KIS
+ILKBAHAR
+YAZ
+SONBAHAR
+```
@@ -0,0 +1,217 @@
+---
+baslik: Hata yönetimi: sonuc ve ?
+bolum: Hatalar ve dosyalar
+ozet: Başarı ya da hata döndüren fonksiyonlar, ? ile hata iletmek ve belki
+---
+
+Programlar her zaman yolunda gitmez: kullanıcı yaş yerine "otuz" yazar, bir sayı sıfıra bölünür, aranan kayıt bulunamaz. KabaLang'de beklenebilir hatalar **dönüş değeriyle** bildirilir: fonksiyon ya başarıyı ya da hatayı döndürür ve çağıran taraf ikisini de ele almak zorundadır.
+
+## sonuc: başarı ya da hata
+
+Dönüş türü `sonuc<sayi, Hata>` olan bir fonksiyon başarıda `tamam(deger)`, başarısızlıkta `hata("mesaj")` döndürür.
+
+```kbl
+fonksiyon bol(a: sayi, b: sayi) -> sonuc<sayi, Hata>:
+    eger b == 0:
+        don hata("sıfıra bölünemez")
+    don tamam(a // b)
+
+r = bol(20, 4)
+eger r.tamam_mi():
+    yazdir(f"Sonuç: {r.deger()}")
+
+h = bol(5, 0)
+eger h.hatali_mi():
+    yazdir("Hata: " + h.hata().mesaj())
+```
+```cikti
+Sonuç: 5
+Hata: sıfıra bölünemez
+```
+
+| Yazım | Anlamı |
+|---|---|
+| `tamam(deger)` | başarı döndür |
+| `hata("mesaj")` | hata döndür |
+| `.tamam_mi()` / `.hatali_mi()` | hangisi olduğunu sor |
+| `.deger()` | başarıdaki değeri al |
+| `.hata().mesaj()` | hatanın açıklamasını al |
+| `.deger_veya(yedek)` | hata varsa yedek değeri ver |
+
+## Yedek değerle devam etmek
+
+Hatanın nedeni seni ilgilendirmiyorsa `deger_veya()` ile bir yedek değer verirsin.
+
+```kbl
+fonksiyon bol(a: sayi, b: sayi) -> sonuc<sayi, Hata>:
+    eger b == 0:
+        don hata("sıfıra bölünemez")
+    don tamam(a // b)
+
+yazdir(bol(20, 4).deger_veya(0))
+yazdir(bol(20, 0).deger_veya(0))
+```
+```cikti
+5
+0
+```
+
+## Girdiyi denetleyen bir fonksiyon
+
+Kullanıcıdan gelen bir yaşı denetleyelim: boş olmasın, yalnız rakam içersin, gerçekçi olsun.
+
+```kbl
+fonksiyon yas_coz(girdi: metin) -> sonuc<sayi, Hata>:
+    temiz = girdi.kirp()
+    eger temiz.bos_mu():
+        don hata("yaş boş bırakılamaz")
+    dongu harf icinde temiz:
+        eger degil "0123456789".icerir(harf):
+            don hata(f"'{temiz}' bir sayı değil")
+    yas = sayi(temiz)
+    eger yas > 130:
+        don hata(f"{yas} yaş gerçekçi değil")
+    don tamam(yas)
+
+dongu g icinde ["34", " 7 ", "", "otuz", "250"]:
+    r = yas_coz(g)
+    eger r.tamam_mi():
+        yazdir(f"✓ {r.deger()}")
+    degilse:
+        yazdir(f"✗ {r.hata().mesaj()}")
+```
+```cikti
+✓ 34
+✓ 7
+✗ yaş boş bırakılamaz
+✗ 'otuz' bir sayı değil
+✗ 250 yaş gerçekçi değil
+```
+
+## ? ile hatayı yukarı iletmek
+
+Her çağrıdan sonra `eger hatali_mi()` yazmak yorucudur. Çağrının sonuna `?` koyarsan şu anlama gelir: "hata varsa bu fonksiyondan da aynı hatayla hemen çık; yoksa içindeki değeri ver."
+
+```kbl
+fonksiyon bol(a: sayi, b: sayi) -> sonuc<sayi, Hata>:
+    eger b == 0:
+        don hata("sıfıra bölünemez")
+    don tamam(a // b)
+
+fonksiyon kisi_basi(toplam: sayi, kisi: sayi, gun: sayi) -> sonuc<sayi, Hata>:
+    kisi_payi = bol(toplam, kisi)?
+    gunluk = bol(kisi_payi, gun)?
+    don tamam(gunluk)
+
+yazdir(kisi_basi(12000, 4, 5).deger())
+yazdir(kisi_basi(12000, 0, 5).hata().mesaj())
+```
+```cikti
+600
+sıfıra bölünemez
+```
+
+> **Dikkat:** `?`'yi yalnız dönüş türü kendisi de `sonuc` olan bir fonksiyonun içinde kullan. Hata ancak o zaman yukarı iletilebilir; programın ana akışında ya da dönüş türü olmayan bir fonksiyonda `?` yerine `tamam_mi()` / `deger_veya()` kullan.
+
+## Sonucu yok saymak yasaktır
+
+`sonuc` döndüren bir fonksiyonu çağırıp sonucu hiç kullanmazsan program derlenmez.
+
+```kbl goster
+fonksiyon kaydet() -> sonuc<sayi, Hata>:
+    don tamam(1)
+
+kaydet()    # hata: bu çağrı bir 'sonuc' döndürüyor ve sonuç yok sayılıyor
+```
+
+Sonucu bilerek atmak istiyorsan bunu açıkça yazarsın: `_ = kaydet()`.
+
+## belki: değer var ya da yok
+
+Hatanın bir nedeni yoksa, yalnız "bulundu / bulunamadı" ayrımı gerekiyorsa `belki<T>` kullanılır: `dolu(deger)` ya da `bos`.
+
+```kbl
+fonksiyon ilk_uzun_kelime(kelimeler: liste<metin>, en_az: sayi) -> belki<metin>:
+    dongu k icinde kelimeler:
+        eger k.uzunluk() >= en_az:
+            don dolu(k)
+    don bos
+
+liste_ = ["kar", "yağmur", "fırtına"]
+b = ilk_uzun_kelime(liste_, 6)
+eger b.var_mi():
+    yazdir(b.deger())
+yazdir(ilk_uzun_kelime(liste_, 10).deger_veya("yok"))
+```
+```cikti
+yağmur
+yok
+```
+
+## Alıştırma
+
+```alistirma
+`karekok_tam(n: sayi) -> sonuc<sayi, Hata>` fonksiyonunu yaz: n negatifse `"negatif sayının karekökü yok"` hatası döndürsün; değilse karesi n'yi geçmeyen en büyük tam sayıyı (`k * k <= n` olan en büyük k) döndürsün. Verilen değerler için sonucu ya da hata mesajını yazdır.
+%%%
+# buraya yaz
+
+dongu n icinde [49, 50, -4]:
+    r = karekok_tam(n)
+    eger r.tamam_mi():
+        yazdir(r.deger())
+    degilse:
+        yazdir(r.hata().mesaj())
+%%%
+fonksiyon karekok_tam(n: sayi) -> sonuc<sayi, Hata>:
+    eger n < 0:
+        don hata("negatif sayının karekökü yok")
+    k = 0
+    iken (k + 1) * (k + 1) <= n:
+        k += 1
+    don tamam(k)
+
+dongu n icinde [49, 50, -4]:
+    r = karekok_tam(n)
+    eger r.tamam_mi():
+        yazdir(r.deger())
+    degilse:
+        yazdir(r.hata().mesaj())
+%%%
+7
+7
+negatif sayının karekökü yok
+```
+
+```alistirma
+Verilen `stok_bul` fonksiyonunu kullanan `toplam_stok(a: metin, b: metin) -> sonuc<sayi, Hata>` fonksiyonunu `?` ile yaz: iki ürünün stoklarını toplayıp döndürsün.
+%%%
+fonksiyon stok_bul(urun: metin) -> sonuc<sayi, Hata>:
+    eger urun == "kalem":
+        don tamam(40)
+    eger urun == "defter":
+        don tamam(25)
+    don hata(f"{urun} bulunamadı")
+
+# buraya yaz
+
+yazdir(toplam_stok("kalem", "defter").deger())
+yazdir(toplam_stok("kalem", "silgi").hata().mesaj())
+%%%
+fonksiyon stok_bul(urun: metin) -> sonuc<sayi, Hata>:
+    eger urun == "kalem":
+        don tamam(40)
+    eger urun == "defter":
+        don tamam(25)
+    don hata(f"{urun} bulunamadı")
+
+fonksiyon toplam_stok(a: metin, b: metin) -> sonuc<sayi, Hata>:
+    x = stok_bul(a)?
+    y = stok_bul(b)?
+    don tamam(x + y)
+
+yazdir(toplam_stok("kalem", "defter").deger())
+yazdir(toplam_stok("kalem", "silgi").hata().mesaj())
+%%%
+65
+silgi bulunamadı
+```
@@ -0,0 +1,157 @@
+---
+baslik: Hata yakalama: dene ve yakala
+bolum: Hatalar ve dosyalar
+ozet: firlat, dene, yakala ve sonunda ile beklenmeyen durumlar
+---
+
+`sonuc` beklenebilir hatalar içindir. Bazı durumlarda ise program o noktada devam edemez: stokta olmayan bir ürün satılmaya çalışılır, listede olmayan bir sıra istenir. Böyle durumlarda hata **fırlatılır**; onu yakalayan bir `dene` bloğu yoksa program durur.
+
+## dene ve yakala
+
+`dene` bloğunda bir hata fırlatılırsa blok orada kesilir ve `yakala` bloğu çalışır. `yakala h:` hata mesajını `h` adıyla verir.
+
+```kbl
+dene:
+    yazdir("İşlem başlıyor")
+    firlat "bağlantı kurulamadı"
+    yazdir("Bu satır çalışmaz")
+yakala h:
+    yazdir("Yakalandı: " + h)
+yazdir("Program devam ediyor")
+```
+```cikti
+İşlem başlıyor
+Yakalandı: bağlantı kurulamadı
+Program devam ediyor
+```
+
+Hata olmazsa `yakala` bloğu hiç çalışmaz.
+
+## Fonksiyondan hata fırlatmak
+
+`firlat hata("mesaj")` fonksiyonu orada bitirir; hata, onu yakalayan ilk `dene` bloğuna kadar çıkar.
+
+```kbl
+fonksiyon stoktan_dus(stok: sayi, adet: sayi) -> sayi:
+    eger adet <= 0:
+        firlat hata(f"geçersiz adet: {adet}")
+    eger adet > stok:
+        firlat hata(f"stokta {stok} ürün var, {adet} istendi")
+    don stok - adet
+
+kalan = 10
+dongu istek icinde [3, 4, 0, 5]:
+    dene:
+        kalan = stoktan_dus(kalan, istek)
+        yazdir(f"{istek} adet satıldı, {kalan} kaldı")
+    yakala h:
+        yazdir(f"Satış yapılamadı: {h}")
+```
+```cikti
+3 adet satıldı, 7 kaldı
+4 adet satıldı, 3 kaldı
+Satış yapılamadı: geçersiz adet: 0
+Satış yapılamadı: stokta 3 ürün var, 5 istendi
+```
+
+## Dilin kendi fırlattığı hatalar
+
+Sıfıra bölme, listede olmayan bir sıra, sözlükte olmayan bir anahtar... Bunlar da fırlatılan hatalardır. Yakalanırlarsa program devam eder.
+
+```kbl
+sehirler = ["Rize", "Artvin"]
+dene:
+    yazdir(sehirler[5])
+yakala:
+    yazdir("Listede 5. sırada şehir yok.")
+
+bolen = 0
+dene:
+    yazdir(100 // bolen)
+yakala:
+    yazdir("Sıfıra bölme yakalandı.")
+```
+```cikti
+Listede 5. sırada şehir yok.
+Sıfıra bölme yakalandı.
+```
+
+`yakala`'dan sonra ad yazmazsan hata mesajı kullanılmaz, yalnız yakalanır.
+
+> **Dikkat:** Yakalanmayan bir hata programı o satırda durdurur ve altındaki hiçbir şey çalışmaz. Ama her şeyi `dene` içine sarmak da hatayı gizler. Beklenen durumlar (geçersiz girdi gibi) için `sonuc`, gerçekten olağandışı durumlar için `firlat` kullan.
+
+## sonunda: her durumda çalışan blok
+
+`sonunda:` bloğu, hata olsa da olmasa da en son çalışır. Temizlik işleri (dosyayı kapatmak, "işlem bitti" demek) için kullanılır.
+
+```kbl
+dongu bolen icinde [5, 0]:
+    dene:
+        yazdir(f"100 / {bolen} = {100 // bolen}")
+    yakala:
+        yazdir("bölme yapılamadı")
+    sonunda:
+        yazdir("--- işlem tamam")
+```
+```cikti
+100 / 5 = 20
+--- işlem tamam
+bölme yapılamadı
+--- işlem tamam
+```
+
+## Hangi yolu seçmeli?
+
+| Durum | Yol |
+|---|---|
+| Kullanıcı yanlış değer girdi, kayıt bulunamadı | `sonuc` / `belki` döndür |
+| Programın o noktada devam etmesi anlamsız | `firlat` |
+| Bir hatayı yakalayıp programı sürdürmek | `dene` / `yakala` |
+
+## Alıştırma
+
+```alistirma
+`yas_kontrol(yas: sayi) -> sayi` fonksiyonu yaş 0'dan küçükse `"yaş negatif olamaz"` hatası fırlatsın, değilse yaşı döndürsün. Verilen her yaş için `dene/yakala` ile ya `Yaş: 25` ya da `Hata: yaş negatif olamaz` yazdır.
+%%%
+# buraya yaz
+
+dongu y icinde [25, -3]:
+    dene:
+        yazdir(f"Yaş: {yas_kontrol(y)}")
+    yakala h:
+        yazdir(f"Hata: {h}")
+%%%
+fonksiyon yas_kontrol(yas: sayi) -> sayi:
+    eger yas < 0:
+        firlat hata("yaş negatif olamaz")
+    don yas
+
+dongu y icinde [25, -3]:
+    dene:
+        yazdir(f"Yaş: {yas_kontrol(y)}")
+    yakala h:
+        yazdir(f"Hata: {h}")
+%%%
+Yaş: 25
+Hata: yaş negatif olamaz
+```
+
+```alistirma
+`fiyat` sözlüğünde olmayan bir ürünü okumak hata fırlatır. `sepet` listesindeki her ürün için `dene/yakala` ile fiyatı yazdır; bulunamayan ürün için `muz: fiyat yok` yaz.
+%%%
+fiyat = {"elma": 30, "armut": 45}
+sepet = ["elma", "muz", "armut"]
+# buraya yaz
+%%%
+fiyat = {"elma": 30, "armut": 45}
+sepet = ["elma", "muz", "armut"]
+dongu urun icinde sepet:
+    dene:
+        yazdir(f"{urun}: {fiyat[urun]} TL")
+    yakala:
+        yazdir(f"{urun}: fiyat yok")
+%%%
+elma: 30 TL
+muz: fiyat yok
+armut: 45 TL
+```
@@ -0,0 +1,161 @@
+---
+baslik: Kullanıcıdan girdi
+bolum: Hatalar ve dosyalar
+ozet: konsol.satir_oku ve konsol.sayi_oku ile klavyeden okumak
+---
+
+Şimdiye kadar bütün değerleri koda kendin yazdın. Gerçek programlar kullanıcıyla konuşur: adını sorar, bir sayı ister, cevaba göre davranır. Bunun için `konsol` modülünü kullanırsın.
+
+> **Not:** Bu dersteki örneklerin altında bir **girdi** bloğu var: oradaki satırlar, kullanıcı klavyeden yazıp Enter'a basmış gibi programa verilir. Bu yüzden çıktıda yazılan cevap da görünür.
+
+## Bir satır okumak
+
+`kullan kaba.sistem` yazıp `konsol.satir_oku()` ile bir satır okursun. `konsol.yaz()` soruyu yazar ama satırı bitirmez; cevap sorunun yanında görünür.
+
+```kbl
+kullan kaba.sistem
+konsol.yaz("Adın: ")
+ad = konsol.satir_oku().deger_veya("misafir").kirp()
+yazdir(f"Merhaba {ad}!")
+```
+```girdi
+Ayşe
+```
+```cikti
+Adın: Ayşe
+Merhaba Ayşe!
+```
+
+`satir_oku()` bir `belki<metin>` döndürür: girdi bitmişse ortada okunacak satır yoktur. `deger_veya("misafir")` satır varsa onu, yoksa `"misafir"`i verir. `kirp()` ise baştaki ve sondaki boşlukları atar.
+
+## Sayı okumak
+
+`konsol.sayi_oku("soru")` soruyu yazar, satırı okur ve tam sayıya çevirmeyi dener. Sonuç bir `sonuc`'tur: ya sayı ya hata.
+
+```kbl
+kullan kaba.sistem
+r = konsol.sayi_oku("Doğum yılın: ")
+eger r.tamam_mi():
+    yazdir(f"2026'da {2026 - r.deger()} yaşına giriyorsun.")
+degilse:
+    yazdir("Okunamadı: " + r.hata().mesaj())
+```
+```girdi
+2011
+```
+```cikti
+Doğum yılın: 2011
+2026'da 15 yaşına giriyorsun.
+```
+
+Kullanıcı sayı yerine yazı girerse program çökmez; hatayı sen ele alırsın.
+
+```kbl
+kullan kaba.sistem
+r = konsol.sayi_oku("Kaç kitap okudun? ")
+eger r.tamam_mi():
+    yazdir(f"{r.deger()} kitap, harika!")
+degilse:
+    yazdir("Okunamadı: " + r.hata().mesaj())
+```
+```girdi
+on iki
+```
+```cikti
+Kaç kitap okudun? on iki
+Okunamadı: 'on iki' bir tam sayı değil
+```
+
+> **Dikkat:** Kullanıcıdan gelen sayıyı `sayi(satir)` ile çevirme: `sayi("on iki")` hata vermez, sessizce 0 döndürür. Tam sayı için `konsol.sayi_oku` kullan; böylece yanlış girdiyi fark edersin.
+
+## Ondalık sayı okumak
+
+Ondalık sayı için satırı okuyup `ondalik()` ile çevirirsin.
+
+```kbl
+kullan kaba.sistem
+konsol.yaz("Boyun (m): ")
+boy = ondalik(konsol.satir_oku().deger_veya("0").kirp())
+konsol.yaz("Kilon (kg): ")
+kilo = ondalik(konsol.satir_oku().deger_veya("0").kirp())
+yazdir(f"Vücut kitle indeksin: {kilo / (boy * boy):.1f}")
+```
+```girdi
+1.70
+65
+```
+```cikti
+Boyun (m): 1.70
+Kilon (kg): 65
+Vücut kitle indeksin: 22.5
+```
+
+## Birden çok girdi: küçük bir hesap makinesi
+
+```kbl
+kullan kaba.sistem
+a = konsol.sayi_oku("Birinci sayı: ").deger_veya(0)
+b = konsol.sayi_oku("İkinci sayı: ").deger_veya(0)
+yazdir(f"{a} + {b} = {a + b}")
+yazdir(f"{a} x {b} = {a * b}")
+```
+```girdi
+12
+7
+```
+```cikti
+Birinci sayı: 12
+İkinci sayı: 7
+12 + 7 = 19
+12 x 7 = 84
+```
+
+> **İpucu:** Örneği **Dene** ile açıp kendi sayılarınla çalıştır. Girdi okuyan programlarda IDE senden cevap bekler.
+
+## Alıştırma
+
+Alıştırmalar girdi verilmeden denetlendiği için burada klavyeden okumak yerine, kullanıcının yazdığı satırların bir listede durduğunu varsayıyoruz. Okuma kısmını örneklerde **Dene** ile kendin dene.
+
+```alistirma
+`girdiler` listesi kullanıcının yazdığı satırları tutuyor; satırlarda fazladan boşluk olabilir. Her satırı temizle ve şehir adını büyük harfle `İZMİR'den selam!` biçiminde yazdır.
+%%%
+girdiler = ["  İzmir ", "rize", " Iğdır"]
+dongu satir icinde girdiler:
+    # buraya yaz
+%%%
+girdiler = ["  İzmir ", "rize", " Iğdır"]
+dongu satir icinde girdiler:
+    sehir = satir.kirp()
+    yazdir(f"{sehir.buyut()}'den selam!")
+%%%
+İZMİR'den selam!
+RİZE'den selam!
+IĞDIR'den selam!
+```
+
+```alistirma
+`girdiler` listesindeki her satır bir yaş olmalı. Yalnız rakamlardan oluşan satırları sayıya çevirip topla; geçersiz satırlar için tırnak içinde `geçersiz: 'on beş'` biçiminde yazdır. En sonda toplamı yazdır.
+%%%
+girdiler = ["14", "on beş", "16", "", "17a"]
+toplam = 0
+# buraya yaz
+yazdir(f"Toplam: {toplam}")
+%%%
+girdiler = ["14", "on beş", "16", "", "17a"]
+toplam = 0
+dongu satir icinde girdiler:
+    gecerli = degil satir.bos_mu()
+    dongu harf icinde satir:
+        eger degil "0123456789".icerir(harf):
+            gecerli = yanlis
+    eger gecerli:
+        toplam += sayi(satir)
+    degilse:
+        yazdir(f"geçersiz: '{satir}'")
+yazdir(f"Toplam: {toplam}")
+%%%
+geçersiz: 'on beş'
+geçersiz: ''
+geçersiz: '17a'
+Toplam: 30
+```
@@ -0,0 +1,135 @@
+---
+baslik: Dosyalar
+bolum: Hatalar ve dosyalar
+ozet: Dosyaya yazmak, sonuna eklemek, geri okumak ve JSON ile saklamak
+---
+
+Program bittiğinde değişkenlerdeki her şey kaybolur. Bilgiyi saklamak için dosyaya yazarsın; program bir sonraki çalışmada onu geri okuyabilir. Dosya işlemleri `dosya` modülündedir; `kullan kaba.sistem` ile gelir.
+
+> **Not:** Bu dersteki örnekler çalıştıkları klasörde dosya oluşturur. Her örnek önce yazar, sonra aynı programda geri okur.
+
+## Yazmak ve okumak
+
+`dosya.yaz(yol, metin)` dosyayı oluşturur; dosya varsa içeriğini **silip** yeniden yazar. `dosya.oku(yol)` bütün dosyayı tek bir metin olarak verir.
+
+```kbl
+kullan kaba.sistem
+dosya.yaz("selam.txt", "Merhaba dosya!\n")
+icerik = dosya.oku("selam.txt")
+yazdir(icerik)
+```
+```cikti
+Merhaba dosya!
+```
+
+Her satırın sonuna `\n` koyarsın; yoksa satırlar yan yana birleşir.
+
+## Sonuna eklemek
+
+`dosya.ekle(yol, metin)` var olan içeriğe dokunmadan sonuna ekler.
+
+```kbl
+kullan kaba.sistem
+dosya.yaz("gunluk.txt", "Pazartesi: 5 km koştum\n")
+dosya.ekle("gunluk.txt", "Salı: dinlendim\n")
+dosya.ekle("gunluk.txt", "Çarşamba: 7 km koştum\n")
+yazdir(dosya.oku("gunluk.txt"))
+```
+```cikti
+Pazartesi: 5 km koştum
+Salı: dinlendim
+Çarşamba: 7 km koştum
+```
+
+> **Dikkat:** Bir kayıt eklemek istiyorken `dosya.yaz` kullanırsan dosyadaki eski her şey silinir. Eklemek için `dosya.ekle` kullan.
+
+## Satır satır işlemek
+
+Okuduğun metni `kirp()` ile sondaki `\n`'den arındırıp `bol("\n")` ile satırlara ayırırsın. Her satırı da `;` gibi bir ayraçla bölüp alanlara ulaşırsın.
+
+```kbl
+kullan kaba.sistem
+dosya.yaz("alisveris.txt", "ekmek;2;12.50\n")
+dosya.ekle("alisveris.txt", "süt;1;34.90\n")
+dosya.ekle("alisveris.txt", "domates;3;18.75\n")
+
+toplam = 0.0
+dongu satir icinde dosya.oku("alisveris.txt").kirp().bol("\n"):
+    parca = satir.bol(";")
+    adet = sayi(parca[1])
+    tutar = adet * ondalik(parca[2])
+    toplam += tutar
+    yazdir(f"{parca[0]:<10}{adet:>3}{tutar:>9.2f}")
+yazdir(f"{'Toplam':<13}{toplam:>9.2f} TL")
+```
+```cikti
+ekmek       2    25.00
+süt         1    34.90
+domates     3    56.25
+Toplam          116.15 TL
+```
+
+## Dosya var mı?
+
+Olmayan bir dosyayı okumak hata vermez, boş metin döndürür. Bu yüzden önce `dosya.var_mi()` ile sorarsın. `dosya.sil()` dosyayı siler.
+
+```kbl
+kullan kaba.sistem
+dosya.yaz("gecici.txt", "deneme\n")
+yazdir(dosya.var_mi("gecici.txt"))
+dosya.sil("gecici.txt")
+yazdir(dosya.var_mi("gecici.txt"))
+
+eger degil dosya.var_mi("ayarlar.txt"):
+    yazdir("ayarlar.txt yok, varsayılanlar kullanılacak.")
+```
+```cikti
+doğru
+yanlış
+ayarlar.txt yok, varsayılanlar kullanılacak.
+```
+
+## JSON ile saklamak
+
+JSON, sözlük ve listeleri metne çevirmenin yaygın bir biçimidir; başka programlar da okuyabilir. `json.uret()` bir sözlüğü metne çevirir, `json.coz()` metni geri çözer.
+
+```kbl
+kullan kaba.sistem
+ayarlar = {"tema": "koyu", "yazi_boyutu": 14}
+dosya.yaz("ayarlar.json", json.uret(ayarlar))
+yazdir(dosya.oku("ayarlar.json"))
+
+okunan = json.coz(dosya.oku("ayarlar.json"))
+yazdir(f"Tema: {metin(okunan['tema'])}")
+yazdir(f"Yazı boyutu + 2: {sayi(okunan['yazi_boyutu']) + 2}")
+```
+```cikti
+{"tema":"koyu","yazi_boyutu":14}
+Tema: koyu
+Yazı boyutu + 2: 16
+```
+
+JSON'dan çözülen değerin türü derleme anında bilinmez; `metin()` ve `sayi()` ile hangi türde kullanacağını açıkça söylersin.
+
+> **İpucu:** Bozuk olabilecek bir dosyayı çözmeden önce `json.gecerli_mi(metin)` ile denetle; geçerli değilse `yanlis` döner.
+
+## Alıştırma
+
+```alistirma
+`notlar.txt` dosyasına üç satır yaz: `Ayşe;88`, `Can;47`, `Elif;92` (ilkini `yaz`, diğerlerini `ekle` ile). Sonra dosyayı okuyup her satırı bölerek notların ortalamasını 1 basamakla `Ortalama: 75.7` biçiminde yazdır.
+%%%
+kullan kaba.sistem
+# buraya yaz
+%%%
+kullan kaba.sistem
+dosya.yaz("notlar.txt", "Ayşe;88\n")
+dosya.ekle("notlar.txt", "Can;47\n")
+dosya.ekle("notlar.txt", "Elif;92\n")
+toplam = 0
+satirlar = dosya.oku("notlar.txt").kirp().bol("\n")
+dongu satir icinde satirlar:
+    toplam += sayi(satir.bol(";")[1])
+yazdir(f"Ortalama: {toplam / satirlar.uzunluk():.1f}")
+%%%
+Ortalama: 75.7
+```
@@ -0,0 +1,169 @@
+---
+baslik: Modüller
+bolum: Hatalar ve dosyalar
+ozet: kullan ile hazır kütüphaneleri programına katmak
+---
+
+Karekök almak, bir listeyi toplamak, metnin özetini çıkarmak gibi işleri her seferinde sıfırdan yazmazsın. KabaLang'in standart kütüphanesi bu işleri **modüller** halinde hazır sunar. `kullan` ile bir modülü programına katarsın.
+
+## kullan
+
+`kullan kaba.sistem` yazınca `matematik`, `dosya`, `konsol`, `json`, `kripto`, `zaman`, `rastgele` gibi modüller birlikte gelir. Bir modülün fonksiyonu `modul.fonksiyon()` diye çağrılır.
+
+```kbl
+kullan kaba.sistem
+yazdir(matematik.karekok(144.0))
+yazdir(matematik.mutlak(-17))
+yazdir(f"{matematik.pi:.4f}")
+```
+```cikti
+12.0
+17
+3.1416
+```
+
+> **İpucu:** `kullan` satırlarını dosyanın en başına yaz. Hangi yetenekleri kullandığını okuyana hemen gösterir.
+
+## matematik
+
+| Fonksiyon | Ne yapar | Örnek | Sonuç |
+|---|---|---|---|
+| `matematik.karekok(x)` | karekök | `karekok(9.0)` | `3.0` |
+| `matematik.mutlak(x)` | mutlak değer | `mutlak(-3)` | `3` |
+| `matematik.yuvarla(x)` | en yakın tam değere yuvarla | `yuvarla(2.5)` | `3.0` |
+| `matematik.taban(x)` | aşağı yuvarla | `taban(3.7)` | `3.0` |
+| `matematik.tavan(x)` | yukarı yuvarla | `tavan(3.2)` | `4.0` |
+| `matematik.us(a, b)` | a üzeri b | `us(2.0, 10.0)` | `1024.0` |
+| `matematik.pi` | π sayısı | | `3.14159…` |
+
+```kbl
+kullan kaba.sistem
+yazdir(matematik.yuvarla(2.5))
+yazdir(matematik.taban(3.7))
+yazdir(matematik.tavan(3.2))
+yazdir(matematik.us(2.0, 10.0))
+```
+```cikti
+3.0
+3.0
+4.0
+1024.0
+```
+
+`yuvarla`, `taban` ve `tavan` sonucu `ondalik` olarak verir. Tam sayı gerekiyorsa `sayi(matematik.tavan(x))` yazarsın.
+
+Gerçek bir örnek: dairenin alanı ve bir dik üçgenin hipotenüsü.
+
+```kbl
+kullan kaba.sistem
+yaricap = 2.5
+yazdir(f"Alan: {matematik.pi * yaricap * yaricap:.2f}")
+a = 3.0
+b = 4.0
+yazdir(f"Hipotenüs: {matematik.karekok(a * a + b * b)}")
+```
+```cikti
+Alan: 19.63
+Hipotenüs: 5.0
+```
+
+## koleksiyon
+
+`kullan kaba.koleksiyon` listelerle çalışan hazır fonksiyonları getirir. Bunları *Liste işlemleri* dersinde görmüştün.
+
+```kbl
+kullan kaba.koleksiyon
+satislar = [120, 340, 90, 410, 250]
+yazdir(koleksiyon.topla(satislar))
+yazdir(koleksiyon.en_buyuk(satislar))
+yazdir(koleksiyon.sirali(satislar))
+```
+```cikti
+1210
+410
+[90, 120, 250, 340, 410]
+```
+
+## kripto
+
+`kripto` metinlerin özetini (hash) çıkarır ve base64 kodlaması yapar. Özet, bir metnin parmak izidir: metin bir harf bile değişse özet tümden değişir.
+
+```kbl
+kullan kaba.sistem
+yazdir(kripto.sha256("merhaba").bastan(16))
+yazdir(kripto.sha256("Merhaba").bastan(16))
+kod = kripto.base64_kodla("KabaLang")
+yazdir(kod)
+yazdir(kripto.base64_coz(kod))
+```
+```cikti
+4c6bcdd55f3153e1
+7fdc9f4717c5fe66
+S2FiYUxhbmc=
+KabaLang
+```
+
+## Diğer modüller
+
+| Modül | Ne için |
+|---|---|
+| `dosya` | dosya okuma/yazma (*Dosyalar* dersi) |
+| `konsol` | klavyeden okuma (*Kullanıcıdan girdi* dersi) |
+| `json` | JSON üretme ve çözme |
+| `zaman` | saat, tarih, süre ölçümü |
+| `rastgele` | rastgele sayı ve seçim |
+
+`zaman` ve `rastgele` her çalıştırmada farklı sonuç verir. Örneğin `rastgele.sayi(1, 6)` bir zar atar, `zaman.saat()` şu anki saati verir. Kendi bilgisayarında **Dene** ile çalıştırıp her seferinde değiştiğini gör:
+
+```kbl goster
+kullan kaba.sistem
+yazdir("Saat: " + zaman.saat())
+yazdir(f"Zar: {rastgele.sayi(1, 6)}")
+```
+
+> **Dikkat:** Modül adlarını değişken adı olarak kullanma. `dosya = "notlar.txt"` gibi bir atama, `dosya` modülünü gölgeleyip kafa karıştırıcı hatalara yol açar; `dosya_adi` gibi bir ad seç.
+
+## Tebrikler!
+
+Temel dersleri bitirdin: değişkenler, koşullar, döngüler, listeler, sözlükler, fonksiyonlar, kendi türlerin, hata yönetimi ve dosyalar. Artık **Örnekler** bölümündeki daha büyük programları okuyabilir, kendi küçük projelerine başlayabilirsin.
+
+## Alıştırma
+
+```alistirma
+`alanlar` listesindeki her sayı bir karenin alanı. `matematik.karekok` ile her karenin kenar uzunluğunu bulup `Alan 49.0 → kenar 7.0` biçiminde yazdır.
+%%%
+kullan kaba.sistem
+alanlar = [49.0, 2.25, 100.0]
+# buraya yaz
+%%%
+kullan kaba.sistem
+alanlar = [49.0, 2.25, 100.0]
+dongu a icinde alanlar:
+    yazdir(f"Alan {a} → kenar {matematik.karekok(a)}")
+%%%
+Alan 49.0 → kenar 7.0
+Alan 2.25 → kenar 1.5
+Alan 100.0 → kenar 10.0
+```
+
+```alistirma
+`fiyatlar` listesindeki her fiyatı `matematik.tavan` ile yukarı yuvarla, `sayi()` ile tam sayıya çevirip listeye ekle ve `koleksiyon.topla` ile yuvarlanmış fiyatların toplamını bul. Önce yuvarlanmış listeyi, sonra toplamı yazdır.
+%%%
+kullan kaba.sistem
+kullan kaba.koleksiyon
+fiyatlar = [12.3, 7.8, 19.01]
+yuvarlanmis = []
+# buraya yaz
+%%%
+kullan kaba.sistem
+kullan kaba.koleksiyon
+fiyatlar = [12.3, 7.8, 19.01]
+yuvarlanmis = []
+dongu f icinde fiyatlar:
+    yuvarlanmis.ekle(sayi(matematik.tavan(f)))
+yazdir(yuvarlanmis)
+yazdir(koleksiyon.topla(yuvarlanmis))
+%%%
+[13, 8, 20]
+41
+```
@@ -0,0 +1,90 @@
+# Ders dosyası biçimi
+
+Online IDE'nin **Dersler** bölümü bu dizindeki `NN-ad.md` dosyalarından üretilir
+(dosya adı sırası = ders sırası). Her ders tek dosyadır.
+
+⚠️ Yayına almadan önce `hazirla.py` her çalıştırılabilir kod bloğunu ve her
+alıştırmanın çözümünü **gerçekten derleyip çalıştırır** ve çıktıyı dosyada
+yazanla karşılaştırır. Tutmayan ders listeye girmez.
+
+## Başlık bilgisi
+
+```
+---
+baslik: Değişkenler
+bolum: Temeller
+ozet: Değerlere ad vermek, türler ve atama
+---
+```
+
+`bolum` aynı olan dersler yan çubukta aynı başlık altında toplanır.
+
+## Metin
+
+Düz paragraf, `## Alt başlık`, `### Küçük başlık`, **kalın**, *eğik*,
+`satır içi kod`, [bağlantı](https://…), `-` ya da `1.` ile listeler,
+`| a | b |` tabloları (ikinci satır `|---|---|`).
+
+Not kutusu: `>` ile başlayan satırlar. İlk sözcük türü belirler:
+
+```
+> **İpucu:** …        (bilgi)
+> **Dikkat:** …       (uyarı)
+> **Not:** …          (nötr)
+```
+
+## Kod örneği
+
+Kod bloğu `kbl` dilinde yazılır. Hemen ardından gelen `cikti` bloğu beklenen
+çıktıdır; ikisi birlikte doğrulanır ve sayfada "Dene" düğmesiyle gösterilir.
+
+    ```kbl
+    yazdir("Merhaba")
+    ```
+    ```cikti
+    Merhaba
+    ```
+
+Program girdi okuyorsa `girdi` bloğu `cikti`dan önce gelir; satırlar sırayla
+standart girdiye verilir:
+
+    ```kbl
+    kullan kaba.sistem
+    konsol.yaz("Adın: ")
+    ad = konsol.satir_oku().deger_veya("misafir").kirp()
+    yazdir(f"Merhaba {ad}")
+    ```
+    ```girdi
+    Ayşe
+    ```
+    ```cikti
+    Adın: Ayşe
+    Merhaba Ayşe
+    ```
+
+(Program uçbirimde çalışır; verilen girdi, kullanıcı yazmış gibi ekranda da görünür.)
+
+Doğrulanmayacak blok (ör. bilerek hatalı kod, yalnız gösterim):
+`kbl goster`. Bu blokta "Dene" düğmesi yine vardır.
+
+## Alıştırma
+
+Dersin sonunda bir ya da birkaç alıştırma. Bölümler `%%%` satırıyla ayrılır:
+soru (markdown) · başlangıç kodu · çözüm · beklenen çıktı. Çözüm çalıştırılıp
+beklenen çıktıyla karşılaştırılır; öğrencinin kodu da aynı çıktıyı verince
+alıştırma tamamlanmış sayılır.
+
+    ```alistirma
+    `sayi` değişkeninin karesini ekrana yazdır.
+    %%%
+    sayi = 7
+    # buraya yaz
+    %%%
+    sayi = 7
+    yazdir(sayi * sayi)
+    %%%
+    49
+    ```
+
+Karşılaştırmada satır sonlarındaki boşluklar ve en sondaki boş satırlar yok
+sayılır.
@@ -0,0 +1,51 @@
+# Merhaba: ekrana yazı yazmak, metinler, f-string ve yorum satırları
+#
+# Bir KabaLang programı yukarıdan aşağıya, satır satır çalışır.
+# "#" işaretinden sonra gelen her şey yorumdur: derleyici onu okumaz,
+# yalnız kodu okuyan insanlar için yazılır.
+
+# yazdir(...) parantez içindekini ekrana yazar ve satırı bitirir.
+yazdir("Merhaba, dünya!")
+
+# Metinler çift tırnak arasına yazılır. Türkçe harfler olduğu gibi çalışır.
+yazdir("Çağlayan, ılık bir İstanbul sabahında şiir okuyor.")
+
+# Boş bir yazdir() araya boş satır koyar.
+yazdir()
+
+# Metinler + ile uç uca eklenir.
+yazdir("Programlamaya " + "hoş geldiniz.")
+
+# Bir değere ad verip sonra o adla kullanabiliriz.
+# Buna değişken denir; ayrıntısı bir sonraki derste.
+ad = "Ayşe"
+sehir = "Eskişehir"
+
+# f"..." biçimli metindir: süslü parantez içindeki ad, değeriyle değiştirilir.
+yazdir(f"{ad}, {sehir} şehrinden selam gönderiyor.")
+
+# Süslü parantezin içine bir hesap da yazılabilir.
+yazdir(f"Bir günde {24 * 60} dakika, bir haftada {7 * 24} saat vardır.")
+yazdir()
+
+# Bazı karakterler ters eğik çizgiyle yazılır:
+#   \n  yeni satır      \t  sekme (boşluk atlar)      \"  tırnak işareti
+yazdir("Birinci satır\nİkinci satır")
+yazdir("Ad:\tAyşe\nŞehir:\t" + sehir)
+yazdir("Öğretmen \"tahtaya bakın\" dedi.")
+yazdir()
+
+# Uçbirimde renkli yazı için ANSI kodları kullanılır.
+# \033[32m yeşile, \033[33m sarıya geçer; \033[1m kalın yazar; \033[0m her şeyi sıfırlar.
+# Rengi sıfırlamayı unutursan sonraki bütün satırlar da renkli kalır.
+yazdir("\033[32mYeşil\033[0m, \033[33msarı\033[0m ve \033[1mkalın\033[0m yazı.")
+yazdir()
+
+# Küçük bir kartvizit. tekrarla(n) bir metni n kez yan yana koyar;
+# {ad:<12} değeri 12 karakterlik alana sola yaslayarak yazar.
+cizgi = "─".tekrarla(30)
+yazdir(cizgi)
+yazdir(f"  {'Ad':<12}{ad}")
+yazdir(f"  {'Şehir':<12}{sehir}")
+yazdir(f"  {'Dil':<12}KabaLang")
+yazdir(cizgi)
@@ -0,0 +1,94 @@
+# Değişkenler: sayı, ondalık, metin ve mantık türleri, dönüşümler ve aritmetik
+#
+# Değişken, bir değere verilen addır. "ad = değer" yazınca değer o ada bağlanır.
+# Türü yazmak gerekmez; KabaLang değere bakıp türü kendisi anlar.
+
+# ── Dört temel tür ─────────────────────────────────────────────
+ogrenci = "Mehmet"      # metin   : tırnak içindeki yazı
+yas = 17                # sayi    : tam sayı
+boy = 1.74              # ondalik : virgüllü sayı (Türkçedeki virgül yerine nokta yazılır)
+mezun = yanlis          # mantik  : dogru ya da yanlis
+
+yazdir(f"Öğrenci: {ogrenci}, yaş: {yas}, boy: {boy} m, mezun: {mezun}")
+
+# Değişkene yeni bir değer atanabilir; eski değer unutulur.
+yas = 18
+mezun = dogru
+yazdir(f"Bir yıl sonra: yaş {yas}, mezun: {mezun}")
+
+# Uzun sayılarda basamakları _ ile ayırmak okumayı kolaylaştırır.
+nufus = 85_000_000
+yazdir(f"Nüfus: {nufus}  (binlik ayırıcıyla: {nufus:,})")
+
+# degismez ile tanımlanan değer bir daha değiştirilemez.
+# PI = 3 yazmaya kalkarsan derleyici programı çalıştırmadan durdurur.
+degismez PI = 3.14159
+yazdir()
+
+# ── Aritmetik ─────────────────────────────────────────────────
+a = 17
+b = 5
+yazdir(f"{a} + {b}  = {a + b}")
+yazdir(f"{a} - {b}  = {a - b}")
+yazdir(f"{a} * {b}  = {a * b}")
+yazdir(f"{a} / {b}  = {a / b}")      # / her zaman ondalık sonuç verir
+yazdir(f"{a} // {b} = {a // b}")     # // tam bölme: küsuratı atar
+yazdir(f"{a} % {b}  = {a % b}")      # % bölümden kalan
+yazdir(f"2 ** 10 = {2 ** 10}")       # ** üs alma
+yazdir()
+
+# İşlem önceliği matematikteki gibidir; parantez önceliği değiştirir.
+yazdir(f"2 + 3 * 4   = {2 + 3 * 4}")
+yazdir(f"(2 + 3) * 4 = {(2 + 3) * 4}")
+
+# Kısaltmalar: x += 5, "x = x + 5" demektir. -= ve *= de aynı mantıkla çalışır.
+puan = 10
+puan += 5
+puan *= 2
+yazdir(f"Puan: {puan}")
+yazdir()
+
+# ── // ve % ile gerçek bir hesap ───────────────────────────────
+# Toplam saniyeyi saat, dakika ve saniyeye ayıralım.
+toplam_saniye = 10_000
+saat = toplam_saniye // 3600
+dakika = (toplam_saniye % 3600) // 60
+saniye = toplam_saniye % 60
+# {dakika:02} sayıyı iki basamağa tamamlar: 6 yerine 06 yazar.
+yazdir(f"{toplam_saniye} saniye = {saat} saat {dakika:02} dakika {saniye:02} saniye")
+
+# Dairenin alanı: ondalık sayılarla hesap. {alan:.2f} virgülden sonra iki basamak yazar.
+yaricap = 2.5
+alan = PI * yaricap * yaricap
+yazdir(f"Yarıçapı {yaricap} olan dairenin alanı: {alan:.2f}")
+yazdir()
+
+# ── Tür dönüşümü ──────────────────────────────────────────────
+# Türler kendiliğinden birbirine dönüşmez; dönüşümü açıkça yazarız.
+metin_sayi = "42"
+gercek_sayi = sayi(metin_sayi)          # metinden tam sayıya
+yazdir(f"sayi(\"42\") + 8 = {gercek_sayi + 8}")
+
+fiyat = ondalik("19.90")                # metinden ondalığa
+yazdir(f"ondalik(\"19.90\") * 3 = {fiyat * 3:.2f}")
+
+yazdir(f"sayi(3.99) = {sayi(3.99)}  (küsurat atılır, yuvarlanmaz)")
+yazdir(f"ondalik(7) / 2 = {ondalik(7) / 2}")
+
+# Bir sayıyı metne + ile eklemek için önce metin() ile çeviririz.
+yazdir("Sınıfta " + metin(24) + " öğrenci var.")
+
+# Dikkat: sayıya benzemeyen bir metin hata vermez, 0'a dönüşür.
+# Kullanıcıdan gelen sayıları denetlemenin yolu bir sonraki derste.
+yazdir(f"sayi(\"on iki\") = {sayi('on iki')}")
+yazdir()
+
+# ── Küçük bir alışveriş hesabı ─────────────────────────────────
+adet = 3
+birim_fiyat = 249.90
+kdv_orani = 0.20
+ara_toplam = adet * birim_fiyat
+kdv = ara_toplam * kdv_orani
+yazdir(f"Ara toplam : {ara_toplam:>9.2f} TL")
+yazdir(f"KDV (%20)  : {kdv:>9.2f} TL")
+yazdir(f"Toplam     : {ara_toplam + kdv:>9.2f} TL")
@@ -0,0 +1,85 @@
+# Girdi: kullanıcıdan satır okumak, sayıya çevirmek ve okunanla hesap yapmak
+#
+# Bu program beş satır okur: ad, doğum yılı, kilo, boy ve kitap sayısı.
+# IDE'de girdiler aynı klasördeki girdi.txt dosyasından gelir; her satır,
+# kullanıcının yazıp Enter'a bastığı bir cevap gibidir.
+# Uçbirimde çalıştırırsan soruları görür, cevapları kendin yazarsın.
+
+kullan kaba.sistem
+
+# Soruları yalnız karşıda gerçekten bir insan varsa yazdıralım. Girdi bir
+# dosyadan geliyorsa sorular kimseye hitap etmez, çıktıyı kalabalıklaştırır.
+# etkilesimli_mi() bunu söyler: dogru ise klavyeden, yanlis ise dosyadan okuyoruz.
+etkilesimli = konsol.etkilesimli_mi()
+
+# ── 1. Bir satır metin okumak ─────────────────────────────────
+# konsol.yaz() yazdir() gibidir ama satırı bitirmez; imleç sorunun yanında kalır.
+eger etkilesimli:
+    konsol.yaz("Adınız: ")
+
+# satir_oku() bir satır okur. Ama girdi bitmiş de olabilir; bu yüzden sonuç
+# "ya bir satır ya hiçbir şey" taşıyan bir kutudur. deger_veya("misafir")
+# kutuda satır varsa onu, yoksa "misafir"i verir. kirp() baştaki ve sondaki
+# boşlukları atar.
+ad = konsol.satir_oku().deger_veya("misafir").kirp()
+
+# ── 2. Bir tam sayı okumak ve denetlemek ──────────────────────
+eger etkilesimli:
+    konsol.yaz("Doğum yılınız: ")
+
+# sayi_oku() satırı okur ve tam sayıya çevirmeyi dener. Sonuç iki şeyden biridir:
+# başarı (içinde sayı) ya da hata (içinde nedeni). tamam_mi() hangisi olduğunu söyler.
+# (Burada soruyu yukarıda kendimiz yazdığımız için sayi_oku'ya boş istem veriyoruz.)
+yil_sonucu = konsol.sayi_oku("")
+
+# Başarılıysa sayıyı deger() ile kutudan çıkarırız; değilse 2000 ile devam ederiz.
+dogum_yili = 2000
+eger yil_sonucu.tamam_mi():
+    dogum_yili = yil_sonucu.deger()
+
+# ── 3. Ondalık sayı okumak ────────────────────────────────────
+eger etkilesimli:
+    konsol.yaz("Kilonuz (kg): ")
+kilo = ondalik(konsol.satir_oku().deger_veya("0").kirp())
+
+eger etkilesimli:
+    konsol.yaz("Boyunuz (m): ")
+boy = ondalik(konsol.satir_oku().deger_veya("0").kirp())
+
+# ── 4. Hatalı bir girdi ───────────────────────────────────────
+eger etkilesimli:
+    konsol.yaz("Bu ay kaç kitap okudunuz? ")
+kitap_sonucu = konsol.sayi_oku("")
+
+# ── Okunanlarla hesap ─────────────────────────────────────────
+# Bu yılı saatten alıyoruz: zaman.bicimlendir("%Y") "2026" gibi bir metin verir.
+bu_yil = sayi(zaman.bicimlendir("%Y"))
+yas = bu_yil - dogum_yili
+
+# Vücut kitle indeksi: kilo / (boy * boy)
+vki = kilo / (boy * boy)
+
+yazdir(f"Merhaba {ad}!")
+yazdir(f"Adınız boşluk dahil {ad.uzunluk()} karakter.")
+
+eger yil_sonucu.tamam_mi():
+    yazdir(f"{dogum_yili} doğumlusunuz; bu yıl {yas} yaşına giriyorsunuz.")
+degilse:
+    yazdir("Doğum yılı okunamadı: " + yil_sonucu.hata().mesaj())
+
+yazdir(f"Kilo {kilo} kg, boy {boy} m  →  vücut kitle indeksi {vki:.1f}")
+
+# "on iki" bir sayı değil: sayi_oku bunu hata olarak bildirir, program çökmez.
+eger kitap_sonucu.tamam_mi():
+    yazdir(f"Bu ay {kitap_sonucu.deger()} kitap okumuşsunuz.")
+degilse:
+    yazdir("Kitap sayısı anlaşılamadı: " + kitap_sonucu.hata().mesaj())
+    yazdir("  (Rakamla yazmayı deneyin, örneğin 12.)")
+
+# ── Girdinin sonu ─────────────────────────────────────────────
+# Beş satırın hepsini okuduk. Bir kez daha okumaya kalkarsak kutu boş gelir:
+# bos_mu() "okunacak satır kalmadı" demektir. Bu, boş bir satırla aynı şey değildir;
+# yalnız Enter'a basılan satır, içi boş bir metin olarak gelir.
+fazla = konsol.satir_oku()
+eger fazla.bos_mu():
+    yazdir("Girdi bitti; okunacak başka satır yok.")
@@ -0,0 +1,5 @@
+Ayşe Yılmaz
+1998
+68.5
+1.65
+on iki
@@ -0,0 +1,101 @@
+# Koşullar: eger, degilse eger, degilse; karşılaştırma ve ve/veya/degil
+#
+# Program bazen bir şeyi yalnız belli bir durumda yapmalıdır.
+# "eger koşul:" satırının altındaki girintili kod, koşul doğruysa çalışır.
+# Girinti (satır başındaki 4 boşluk) hangi satırların bloğa ait olduğunu gösterir.
+
+# ── Karşılaştırma işleçleri ───────────────────────────────────
+# Her karşılaştırmanın sonucu bir mantık değeridir: dogru ya da yanlis.
+#   ==  eşit mi        !=  farklı mı
+#   <   küçük mü       <=  küçük ya da eşit mi
+#   >   büyük mü       >=  büyük ya da eşit mi
+yazdir(f"7 > 3   : {7 > 3}")
+yazdir(f"7 == 3  : {7 == 3}")
+yazdir(f"7 != 3  : {7 != 3}")
+yazdir(f"\"elma\" == \"Elma\" : {'elma' == 'Elma'}   (büyük/küçük harf fark eder)")
+yazdir()
+
+# ── eger / degilse ────────────────────────────────────────────
+sicaklik = 31
+
+eger sicaklik > 30:
+    yazdir(f"Hava {sicaklik} derece: sıcak, bol su için.")
+degilse:
+    yazdir(f"Hava {sicaklik} derece: serin.")
+
+# ── degilse eger: birden çok seçenek ──────────────────────────
+# Koşullar yukarıdan aşağı denenir; DOĞRU çıkan İLK dal çalışır, gerisi atlanır.
+# Bu yüzden sıralama önemlidir: önce en büyük eşiği soruyoruz.
+puan = 77
+
+eger puan >= 85:
+    harf = "AA"
+degilse eger puan >= 70:
+    harf = "BA"
+degilse eger puan >= 60:
+    harf = "BB"
+degilse eger puan >= 50:
+    harf = "CC"
+degilse:
+    harf = "FF"
+
+yazdir(f"{puan} puan → harf notu {harf}")
+yazdir()
+
+# ── ve / veya / degil ─────────────────────────────────────────
+# ve    : iki taraf da doğruysa doğru
+# veya  : taraflardan en az biri doğruysa doğru
+# degil : doğruyu yanlışa, yanlışı doğruya çevirir
+yas = 16
+veli_izni = dogru
+
+eger yas >= 18 veya veli_izni:
+    yazdir(f"{yas} yaşında: geziye katılabilir.")
+degilse:
+    yazdir(f"{yas} yaşında: veli izni gerekli.")
+
+# Artık yıl kuralı: 4'e bölünür ve 100'e bölünmez, YA DA 400'e bölünür.
+# Uzun koşulları parantezle gruplamak hem doğru çalışmasını hem okunmasını sağlar.
+yil = 2024
+artik = (yil % 4 == 0 ve yil % 100 != 0) veya yil % 400 == 0
+eger artik:
+    yazdir(f"{yil} artık yıl: şubat 29 gün.")
+degilse:
+    yazdir(f"{yil} artık yıl değil: şubat 28 gün.")
+
+eger degil artik:
+    yazdir("Bu satır görünmez, çünkü yıl artık yıl.")
+yazdir()
+
+# ── İç içe koşul ──────────────────────────────────────────────
+# Bir eger bloğunun içine başka bir eger yazılabilir. Her düzey 4 boşluk daha içeride.
+kullanici = "ayse"
+parola = "kirmizi-kalem"
+
+eger kullanici == "ayse":
+    eger parola == "kirmizi-kalem":
+        yazdir("Giriş başarılı. Hoş geldin, Ayşe.")
+    degilse:
+        yazdir("Parola yanlış.")
+degilse:
+    yazdir("Böyle bir kullanıcı yok.")
+
+# ── Küçük bir hesap: kargo ücreti ─────────────────────────────
+# Sepet 500 TL ve üstüyse kargo ücretsiz; değilse ağırlığa göre ücret.
+sepet = 420.0
+agirlik_kg = 3.2
+
+eger sepet >= 500.0:
+    kargo = 0.0
+degilse eger agirlik_kg <= 1.0:
+    kargo = 39.90
+degilse eger agirlik_kg <= 5.0:
+    kargo = 59.90
+degilse:
+    kargo = 89.90
+
+yazdir()
+yazdir(f"Sepet {sepet:.2f} TL, {agirlik_kg} kg → kargo {kargo:.2f} TL")
+eger kargo > 0.0:
+    eksik = 500.0 - sepet
+    yazdir(f"\033[33m{eksik:.2f} TL'lik ürün daha eklerseniz kargo ücretsiz.\033[0m")
@@ -0,0 +1,96 @@
+# Döngüler: dongu ... icinde, sayı aralıkları, iken, kir ve devam
+#
+# Döngü, bir kod bloğunu tekrar tekrar çalıştırır. KabaLang'de iki türü var:
+#   dongu x icinde ...  : bir listenin ya da aralığın her öğesi için bir kez
+#   iken koşul:         : koşul doğru olduğu sürece
+
+# ── Bir listenin üzerinden geçmek ─────────────────────────────
+# Her turda sehir değişkeni sıradaki öğeyi alır.
+sehirler = ["Ankara", "İzmir", "Trabzon", "Van"]
+dongu sehir icinde sehirler:
+    yazdir(f"• {sehir}")
+yazdir()
+
+# ── Sayı aralığı: 1..5 ────────────────────────────────────────
+# 1..5 aralığı 1, 2, 3, 4, 5 demektir; üst sınır DAHİLDİR.
+toplam = 0
+dongu i icinde 1..5:
+    toplam += i
+    yazdir(f"i = {i}, şimdiye kadarki toplam = {toplam}")
+yazdir()
+
+# Aralığın sınırları değişken de olabilir.
+n = 6
+konsol.yaz(f"7'nin ilk {n} katı:")
+dongu i icinde 1..n:
+    konsol.yaz(f" {7 * i}")
+yazdir()
+yazdir()
+
+# ── İç içe döngü: çarpım tablosu ──────────────────────────────
+# Dıştaki döngünün her turunda içteki döngü baştan sona çalışır.
+# {deger:4} sayıyı 4 karakterlik alana sağa yaslar; sütunlar böyle hizalanır.
+dongu satir icinde 1..5:
+    cizelge = ""
+    dongu sutun icinde 1..5:
+        cizelge = cizelge + f"{satir * sutun:4}"
+    yazdir(cizelge)
+yazdir()
+
+# ── iken: koşul doğru olduğu sürece ───────────────────────────
+# Aralık yalnız ileri sayar (5..1 boştur); geri saymak için iken kullanılır.
+# Koşulu bir gün yanlış yapacak satırı (burada sayac -= 1) unutmak döngüyü sonsuz yapar.
+sayac = 5
+iken sayac > 0:
+    konsol.yaz(f"{sayac}... ")
+    sayac -= 1
+yazdir("kalkış!")
+
+# Kaç turda biteceğini bilmediğimiz işler için iken uygundur.
+# Yıllık %40 faizle 10.000 TL kaç yılda iki katını geçer?
+para = 10_000.0
+yil = 0
+iken para < 20_000.0:
+    para = para * 1.40
+    yil += 1
+yazdir(f"{yil} yıl sonra para {para:,.2f} TL oldu; iki katını geçti.")
+yazdir()
+
+# ── devam: bu turu atla ───────────────────────────────────────
+# devam'a gelince turun geri kalanı atlanır, döngü bir sonraki öğeyle sürer.
+konsol.yaz("1-20 arası 3'e bölünmeyen tek sayılar:")
+dongu i icinde 1..20:
+    eger i % 2 == 0:
+        devam            # çift sayıysa geç
+    eger i % 3 == 0:
+        devam            # 3'e bölünüyorsa geç
+    konsol.yaz(f" {i}")
+yazdir()
+
+# ── kir: döngüden tümden çık ──────────────────────────────────
+# Aradığımızı bulunca aramaya devam etmenin anlamı yok.
+notlar = [62, 48, 91, 77, 35, 88]
+dongu notu icinde notlar:
+    eger notu < 50:
+        yazdir(f"İlk başarısız not bulundu: {notu}")
+        kir
+yazdir()
+
+# ── Hepsi bir arada: asal sayılar ─────────────────────────────
+# Bir sayı, 1 ve kendisinden başka böleni yoksa asaldır.
+# Her aday için 2'den başlayıp bölen arıyoruz; bölen bulunca kir ile çıkıyoruz.
+asal_sayisi = 0
+konsol.yaz("50'ye kadar asal sayılar:")
+dongu aday icinde 2..50:
+    asal = dogru
+    bolen = 2
+    iken bolen * bolen <= aday:
+        eger aday % bolen == 0:
+            asal = yanlis
+            kir          # yalnız içteki iken döngüsünden çıkar
+        bolen += 1
+    eger asal:
+        konsol.yaz(f" {aday}")
+        asal_sayisi += 1
+yazdir()
+yazdir(f"Toplam {asal_sayisi} asal sayı.")
@@ -0,0 +1,100 @@
+# Fonksiyonlar: parametre, dönüş değeri, tür belirtme, varsayılan değer ve özyineleme
+#
+# Fonksiyon, bir işi yapan ve bir adı olan kod bloğudur. Bir kez yazılır,
+# istendiği kadar çağrılır. Tanımı "fonksiyon ad(parametreler):" ile başlar.
+#
+# Fonksiyonları dosyanın başına, değişkenlerden önce yazıyoruz. Bunun bir nedeni
+# var: bir fonksiyonun içinde, kendisinden ÖNCE tanımlanmış bir değişkenle aynı
+# adı kullanırsan fonksiyon o değişkeni değiştirir. Başta tanımlanan fonksiyonun
+# içindeki adlar yalnız ona ait kalır.
+
+# ── En basit fonksiyon: parametresiz, değer döndürmeyen ───────
+fonksiyon ayrac():
+    yazdir("─".tekrarla(44))
+
+# ── Parametre almak ───────────────────────────────────────────
+# Çağırırken parantez içine verilen değer, parametrenin (ad) yerine geçer.
+fonksiyon selamla(ad):
+    yazdir(f"Merhaba {ad}, hoş geldin.")
+
+# ── Değer döndürmek: don ──────────────────────────────────────
+# don, sonucu çağıran yere geri verir ve fonksiyonu orada bitirir.
+# Parametre ve dönüş türünü yazmak zorunlu değil; yazarsan derleyici denetler:
+# dikdortgen_alani("üç", 4) yazan biri program çalışmadan uyarılır.
+fonksiyon dikdortgen_alani(en: sayi, boy: sayi) -> sayi:
+    don en * boy
+
+fonksiyon ortalama(a: ondalik, b: ondalik, c: ondalik) -> ondalik:
+    don (a + b + c) / 3.0
+
+# ── Varsayılan değerli parametre ──────────────────────────────
+# Çağıran kdv vermezse 20 kullanılır. Varsayılanlı parametreler en sona yazılır.
+fonksiyon kdvli_fiyat(fiyat: ondalik, kdv: sayi = 20) -> ondalik:
+    don fiyat * (1.0 + ondalik(kdv) / 100.0)
+
+# ── Mantık döndüren fonksiyon ve birden çok don ───────────────
+# Cevabı belli olduğu anda don ile çıkmak kodu sadeleştirir.
+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
+
+# ── Fonksiyon başka bir fonksiyonu çağırabilir ────────────────
+fonksiyon asallari_yaz(baslangic: sayi, bitis: sayi):
+    bulunan = ""
+    dongu sayi_adayi icinde baslangic..bitis:
+        eger asal_mi(sayi_adayi):
+            bulunan = bulunan + f" {sayi_adayi}"
+    yazdir(f"{baslangic}-{bitis} arası asallar:{bulunan}")
+
+# ── Özyineleme: kendini çağıran fonksiyon ─────────────────────
+# n! = n × (n-1)!  ve  1! = 1. Her çağrı problemi biraz küçültür;
+# n <= 1 olunca durur. Bu durma koşulu olmazsa fonksiyon kendini sonsuza dek çağırırdı.
+fonksiyon faktoriyel(n: sayi) -> sayi:
+    eger n <= 1:
+        don 1
+    don n * faktoriyel(n - 1)
+
+# Bir sayının basamakları toplamı: 4729 → 4 + 7 + 2 + 9 = 22
+# Son basamak n % 10, geri kalanı n // 10.
+fonksiyon basamak_toplami(n: sayi) -> sayi:
+    eger n < 10:
+        don n
+    don n % 10 + basamak_toplami(n // 10)
+
+
+# ════════════════ Program buradan başlıyor ════════════════
+ayrac()
+selamla("Zeynep")
+selamla("Mehmet")
+ayrac()
+
+yazdir(f"3 x 4 dikdörtgenin alanı: {dikdortgen_alani(3, 4)}")
+
+# Fonksiyonun sonucu bir değişkene atanabilir ya da doğrudan kullanılabilir.
+ort = ortalama(72.0, 85.0, 90.0)
+yazdir(f"72, 85 ve 90'ın ortalaması: {ort:.2f}")
+
+yazdir(f"100 TL, KDV %20 ile : {kdvli_fiyat(100.0):.2f} TL")
+yazdir(f"100 TL, KDV %10 ile : {kdvli_fiyat(100.0, 10):.2f} TL")
+# Parametreyi adıyla vermek, çok parametreli çağrıları okunur yapar.
+yazdir(f"100 TL, KDV %1 ile  : {kdvli_fiyat(100.0, kdv=1):.2f} TL")
+ayrac()
+
+dongu n icinde [1, 2, 17, 21, 97]:
+    eger asal_mi(n):
+        yazdir(f"{n} asaldır")
+    degilse:
+        yazdir(f"{n} asal değildir")
+asallari_yaz(50, 80)
+ayrac()
+
+dongu n icinde 1..10:
+    yazdir(f"{n:2}! = {faktoriyel(n):>9,}")
+yazdir(f"4729 sayısının basamakları toplamı: {basamak_toplami(4729)}")
+ayrac()
@@ -0,0 +1,126 @@
+# Listeler: oluşturma, ekleme, silme, dilimleme, sıralama ve döngüyle gezme
+#
+# Liste, değerleri sırayla tutan bir kaptır. Köşeli parantezle yazılır,
+# öğeler virgülle ayrılır. Bir listedeki öğelerin hepsi aynı türde olmalıdır.
+
+# Listeyi alan bir fonksiyon. Önemli bir ayrıntı: fonksiyona verilen liste
+# KOPYALANIR. Fonksiyon kendi kopyasını değiştirir; değişikliği görmek için
+# sonucu döndürüp yeniden atarız (aşağıda: notlar = yuvarla(notlar)).
+fonksiyon yuvarla(liste: liste<sayi>) -> liste<sayi>:
+    i = 0
+    iken i < liste.uzunluk():
+        eger liste[i] % 5 != 0:
+            liste[i] = liste[i] + (5 - liste[i] % 5)   # bir üst 5'in katına
+        i += 1
+    don liste
+
+
+# ── Oluşturma ve okuma ────────────────────────────────────────
+meyveler = ["elma", "armut", "kiraz", "muz"]
+yazdir(f"Liste       : {meyveler}")
+yazdir(f"Öğe sayısı  : {meyveler.uzunluk()}")
+
+# Öğelere sıra numarasıyla (indeks) ulaşılır. Sayma 0'dan başlar.
+# Negatif indeks sondan sayar: -1 son öğe, -2 sondan ikinci.
+yazdir(f"İlk öğe     : {meyveler[0]}")
+yazdir(f"İkinci öğe  : {meyveler[1]}")
+yazdir(f"Son öğe     : {meyveler[-1]}")
+
+# Bir öğe yerinde değiştirilebilir.
+meyveler[3] = "incir"
+yazdir(f"Değiştirdik : {meyveler}")
+yazdir()
+
+# ── Ekleme, arama, silme ──────────────────────────────────────
+meyveler.ekle("üzüm")                       # sona ekler
+meyveler.ekle("çilek")
+yazdir(f"Ekledik     : {meyveler}")
+
+yazdir(f"kiraz var mı?    : {meyveler.icerir('kiraz')}")
+yazdir(f"kirazın indeksi  : {meyveler.bul('kiraz')}")      # bul() indeksi verir
+yazdir(f"karpuzun indeksi : {meyveler.bul('karpuz')}  (listede yoksa -1)")
+
+# sil(i) i'NCİ SIRADAKİ öğeyi siler (değere göre değil, konuma göre).
+# Bir değeri silmek için önce bul() ile yerini buluruz.
+konum = meyveler.bul("armut")
+meyveler.sil(konum)
+yazdir(f"armut gitti : {meyveler}")
+yazdir()
+
+# ── Dilimleme ─────────────────────────────────────────────────
+# l[a..b] a'dan b'ye kadar olan öğeleri yeni bir liste olarak verir (b dahil).
+# l.dilim(a, adet) a'dan başlayıp adet tane öğe alır.
+sayilar = [10, 20, 30, 40, 50, 60, 70]
+yazdir(f"sayilar[1..3]       : {sayilar[1..3]}")
+yazdir(f"sayilar.dilim(4, 2) : {sayilar.dilim(4, 2)}")
+yazdir()
+
+# ── Sıralama ──────────────────────────────────────────────────
+# sirala() listeyi yerinde, küçükten büyüğe dizer.
+# Metinler Türk alfabesine göre sıralanır: Ç, C'den sonra; İ, I'dan sonra gelir.
+isimler = ["Zeynep", "Ömer", "Can", "Çağla", "İlker", "Işıl", "Ahmet"]
+isimler.sirala()
+yazdir(f"Sıralı isimler : {isimler}")
+
+# Ters çevirmek için listeyi sondan başa gezip yeni bir listeye ekleriz.
+ters = []
+i = isimler.uzunluk() - 1
+iken i >= 0:
+    ters.ekle(isimler[i])
+    i -= 1
+yazdir(f"Tersten       : {ters}")
+
+# birlestir(ayrac) metin listesini tek bir metne çevirir.
+yazdir(f"Virgülle      : {isimler.birlestir(', ')}")
+yazdir()
+
+# ── Döngüyle gezme ve hesap ───────────────────────────────────
+notlar = [72, 95, 48, 88, 61, 79, 53]
+
+# Sıra numarası gerekiyorsa indeksle geziyoruz.
+i = 0
+iken i < notlar.uzunluk():
+    yazdir(f"  {i + 1}. öğrenci: {notlar[i]}")
+    i += 1
+
+# Toplam, en büyük ve en küçük: hepsini tek bir döngüde bulabiliriz.
+toplam = 0
+en_yuksek = notlar[0]
+en_dusuk = notlar[0]
+dongu n icinde notlar:
+    toplam += n
+    eger n > en_yuksek:
+        en_yuksek = n
+    eger n < en_dusuk:
+        en_dusuk = n
+yazdir(f"Toplam {toplam}, ortalama {toplam / notlar.uzunluk():.1f}, en yüksek {en_yuksek}, en düşük {en_dusuk}")
+
+# Boş bir listeyle başlayıp koşula uyanları toplamak çok sık yapılan bir iştir.
+gecenler = []
+kalanlar = []
+dongu n icinde notlar:
+    eger n >= 60:
+        gecenler.ekle(n)
+    degilse:
+        kalanlar.ekle(n)
+yazdir(f"Geçenler ({gecenler.uzunluk()}): {gecenler}")
+yazdir(f"Kalanlar ({kalanlar.uzunluk()}): {kalanlar}")
+yazdir()
+
+# ── Fonksiyona liste vermek ───────────────────────────────────
+yuvarlanmis = yuvarla(notlar)
+yazdir(f"Yuvarlanmış kopya : {yuvarlanmis}")
+yazdir(f"Asıl liste        : {notlar}   (değişmedi)")
+notlar = yuvarla(notlar)
+yazdir(f"Yeniden atayınca  : {notlar}")
+yazdir()
+
+# ── Liste içinde liste: tablo ─────────────────────────────────
+# Her satır bir liste; tablo[satır][sütun] diye okunur.
+tablo = [[3, 8, 1], [9, 4, 7], [2, 6, 5]]
+dongu satir icinde tablo:
+    satir_toplami = 0
+    dongu hucre icinde satir:
+        satir_toplami += hucre
+    yazdir(f"  {satir}  → satır toplamı {satir_toplami}")
+yazdir(f"Ortadaki hücre tablo[1][1] = {tablo[1][1]}")
@@ -0,0 +1,102 @@
+# Sözlükler: anahtar-değer çiftleri, ekleme, sorgulama, gezme ve kelime sayımı
+#
+# Sözlük, her değeri bir anahtarla eşleştiren kaptır. Listede öğeye sıra
+# numarasıyla ulaşırken sözlükte anahtarla ulaşırız: plaka["Ankara"] gibi.
+# Süslü parantezle yazılır: {anahtar: değer, anahtar: değer}.
+
+# ── Oluşturma ve okuma ────────────────────────────────────────
+plaka = {"İstanbul": 34, "Ankara": 6, "İzmir": 35}
+yazdir(f"Sözlük             : {plaka}")
+yazdir(f"Ankara'nın plakası : {plaka['Ankara']:02}")
+yazdir(f"Kaç şehir var      : {plaka.uzunluk()}")
+yazdir()
+
+# ── Ekleme ve güncelleme ──────────────────────────────────────
+# Olmayan bir anahtara değer atamak yeni çift ekler; var olana atamak değeri değiştirir.
+plaka["Bursa"] = 16
+plaka["Trabzon"] = 61
+plaka["İzmir"] = 35
+yazdir(f"Eklemeden sonra: {plaka}")
+
+# ── Sorgulama ─────────────────────────────────────────────────
+# Sözlükte olmayan bir anahtarı okumak programı hatayla durdurur.
+# Emin değilsek önce var_mi() ile soruyoruz.
+dongu sehir icinde ["Trabzon", "Konya"]:
+    eger plaka.var_mi(sehir):
+        yazdir(f"{sehir}: {plaka[sehir]}")
+    degilse:
+        yazdir(f"{sehir}: sözlükte yok")
+
+# ── Silme ─────────────────────────────────────────────────────
+# Sözlükte sil() ANAHTARA göre siler (listede konuma göre silerdi).
+plaka.sil("Bursa")
+yazdir(f"Bursa silindi, kalan {plaka.uzunluk()} şehir")
+yazdir()
+
+# ── Gezme ─────────────────────────────────────────────────────
+# anahtarlar() bütün anahtarları bir liste olarak verir.
+# Bu liste eklenme sırasında değildir; harflerin bilgisayardaki kod sırasına
+# göre dizilir ve bu sırada İ, Ş, Ö gibi harfler Z'den sonra gelir (yukarıda
+# Trabzon, İstanbul'dan önce yazıldı). Türk alfabesine göre gezmek için
+# anahtar listesini alıp sirala() ile sıralıyoruz.
+sehirler = plaka.anahtarlar()
+sehirler.sirala()
+yazdir("Şehir       Plaka")
+dongu sehir icinde sehirler:
+    yazdir(f"{sehir:<12}{plaka[sehir]:>5}")
+yazdir()
+
+# ── Metinden metne sözlük: küçük bir sözlük uygulaması ────────
+ingilizce = {
+    "kitap": "book",
+    "kalem": "pencil",
+    "okul": "school",
+    "öğretmen": "teacher"
+}
+cumle = ["öğretmen", "okul", "kitap", "defter"]
+ceviri = []
+dongu kelime icinde cumle:
+    eger ingilizce.var_mi(kelime):
+        ceviri.ekle(ingilizce[kelime])
+    degilse:
+        ceviri.ekle(f"?{kelime}?")      # bilinmeyen kelimeyi işaretle
+yazdir(f"{cumle.birlestir(' ')}  →  {ceviri.birlestir(' ')}")
+yazdir()
+
+# ── Sayım: hangi kelime kaç kez geçiyor? ──────────────────────
+# Sözlüğün en sık kullanıldığı iş budur. Her kelime için:
+# daha önce gördüysek sayısını bir artırırız, görmediysek 1 ile başlatırız.
+metin_parcasi = "bir elma bir armut iki elma bir kiraz üç elma iki armut"
+sayim = {}
+dongu kelime icinde metin_parcasi.bol(" "):
+    eger sayim.var_mi(kelime):
+        sayim[kelime] = sayim[kelime] + 1
+    degilse:
+        sayim[kelime] = 1
+
+yazdir(f"Metin: \"{metin_parcasi}\"")
+yazdir(f"{sayim.uzunluk()} farklı kelime bulundu:")
+
+# En sık geçen kelimeyi de aynı gezintide bulalım.
+# Eşitlik olursa ilk karşılaşılan kalır, çünkü yalnız daha BÜYÜK adet yerini alır.
+en_sik = ""
+en_cok = 0
+dongu kelime icinde sayim.anahtarlar():
+    adet = sayim[kelime]
+    # Her kelime için adedi kadar ▇ çizerek küçük bir çubuk grafik yapıyoruz.
+    yazdir(f"  {kelime:<7}{adet:>2}  " + "▇".tekrarla(adet))
+    eger adet > en_cok:
+        en_cok = adet
+        en_sik = kelime
+yazdir(f"En sık geçen: \"{en_sik}\" ({en_cok} kez)")
+yazdir()
+
+# ── Not defteri: öğrenci → not ────────────────────────────────
+notlar = {"Ayşe": 88, "Mehmet": 64, "Elif": 92, "Can": 47, "Deniz": 75}
+toplam = 0
+gecen = 0
+dongu ogrenci icinde notlar.anahtarlar():
+    toplam += notlar[ogrenci]
+    eger notlar[ogrenci] >= 50:
+        gecen += 1
+yazdir(f"Sınıf ortalaması {toplam / notlar.uzunluk():.1f}; {notlar.uzunluk()} öğrenciden {gecen} kişi geçti.")
@@ -0,0 +1,98 @@
+# Metinler: Türkçe büyük/küçük harf, bölme, birleştirme, arama ve uzunluk
+#
+# Metin (string) bir harf dizisidir. KabaLang metinleri Türkçe kurallara göre
+# işler: "i" büyüyünce "İ", "I" küçülünce "ı" olur. Birçok dilde bu yanlış çalışır.
+
+# Bir metni tersine çeviren fonksiyon: harfleri tek tek gezip her birini başa ekler.
+fonksiyon ters_cevir(m: metin) -> metin:
+    sonuc = ""
+    dongu harf icinde m:
+        sonuc = harf + sonuc
+    don sonuc
+
+# Boşlukları ve büyük/küçük farkını atınca tersi kendisine eşit mi?
+fonksiyon palindrom_mu(m: metin) -> mantik:
+    sade = m.kucult().degistir(" ", "")
+    don sade == ters_cevir(sade)
+
+
+# ── Türkçe büyük/küçük harf ───────────────────────────────────
+sehir = "istanbul"
+yazdir(f"\"{sehir}\".buyut()     → {sehir.buyut()}")
+yazdir(f"\"IĞDIR\".kucult()        → {'IĞDIR'.kucult()}")
+yazdir(f"\"ılık İğne\".buyut()     → {'ılık İğne'.buyut()}")
+yazdir(f"\"ŞİŞLİ ÖĞÜT\".kucult()   → {'ŞİŞLİ ÖĞÜT'.kucult()}")
+
+# Büyük/küçük harfe aldırmadan karşılaştırmak için iki tarafı da küçültürüz.
+girilen = "İZMİR"
+eger girilen.kucult() == "izmir":
+    yazdir(f"\"{girilen}\" ile \"izmir\" aynı şehir")
+yazdir()
+
+# ── Uzunluk ve harflere erişim ────────────────────────────────
+# uzunluk() harf sayısını verir; ş, ğ, İ gibi harfler de tek harf sayılır.
+kelime = "Şanlıurfa"
+yazdir(f"\"{kelime}\" {kelime.uzunluk()} harf")
+yazdir(f"İlk harf: {kelime[0]}, son harf: {kelime[-1]}, 0..3 arası: {kelime[0..3]}")
+yazdir(f"bastan(5): {kelime.bastan(5)}, sondan(4): {kelime.sondan(4)}, dilim(2, 3): {kelime.dilim(2, 3)}")
+yazdir()
+
+# ── Temizleme, arama, değiştirme ──────────────────────────────
+# kirp() baştaki ve sondaki boşlukları siler; kullanıcı girdisinde çok işe yarar.
+ham = "   Merhaba Dünya   "
+yazdir(f"[{ham}] → [{ham.kirp()}]")
+
+cumle = "Ankara Türkiye'nin başkentidir"
+yazdir(f"\"başkent\" geçiyor mu?   {cumle.icerir('başkent')}")
+yazdir(f"\"Ankara\" ile mi başlıyor? {cumle.ile_baslar('Ankara')}")
+yazdir(f"\"dir\" ile mi bitiyor?    {cumle.ile_biter('dir')}")
+yazdir(f"\"Türkiye\" hangi konumda başlıyor? {cumle.bul('Türkiye')}  (0'dan sayarak; yoksa -1)")
+yazdir(f"Değiştir: {cumle.degistir('Ankara', 'Bursa').degistir('başkentidir', 'dördüncü büyük şehridir')}")
+yazdir()
+
+# ── Bölme ve birleştirme ──────────────────────────────────────
+# bol(ayrac) metni parçalara ayırıp liste verir; birlestir(ayrac) tersini yapar.
+satir = "Ayşe;Kaya;Eskişehir;34"
+alanlar = satir.bol(";")
+yazdir(f"Bölündü : {alanlar}  ({alanlar.uzunluk()} parça)")
+yazdir(f"Ad soyad: {alanlar[0]} {alanlar[1].buyut()}")
+yazdir(f"Birleşti: {alanlar.birlestir(' | ')}")
+
+# Bir cümleyi kelimelere ayırıp her kelimenin ilk harfini büyütelim.
+baslik = "yaşlı ırmak ile genç irmik"
+kelimeler = baslik.bol(" ")
+duzgun = []
+dongu k icinde kelimeler:
+    duzgun.ekle(k.bastan(1).buyut() + k.dilim(1, k.uzunluk() - 1))
+yazdir(f"Başlık biçimi: {duzgun.birlestir(' ')}")
+yazdir()
+
+# ── Harf harf gezme ───────────────────────────────────────────
+# dongu harf icinde metin: her turda bir harf gelir.
+metin_ornegi = "Çalışkan öğrenciler ödevlerini erken bitirir"
+unlu = 0
+bosluk = 0
+dongu harf icinde metin_ornegi.kucult():
+    eger "aeıioöuü".icerir(harf):
+        unlu += 1
+    degilse eger harf == " ":
+        bosluk += 1
+yazdir(f"\"{metin_ornegi}\"")
+yazdir(f"  {metin_ornegi.uzunluk()} karakter, {unlu} ünlü, {bosluk + 1} kelime")
+
+dongu aday icinde ["Ey Edip Adanada pide ye", "Kayak", "Kalem"]:
+    eger palindrom_mu(aday):
+        yazdir(f"  \"{aday}\" tersten de aynı okunur")
+    degilse:
+        yazdir(f"  \"{aday}\" tersten \"{ters_cevir(aday)}\" olur")
+yazdir()
+
+# ── Tekrarlama ve hizalama ────────────────────────────────────
+# tekrarla(n) metni n kez yan yana koyar. f-string içinde
+# {x:<10} sola, {x:>10} sağa, {x:^10} ortaya yaslar.
+yazdir("=".tekrarla(32))
+yazdir(f"{'ŞEHİR':^32}")
+yazdir("=".tekrarla(32))
+dongu ad icinde ["Rize", "Muğla", "Çanakkale"]:
+    yazdir(f"{ad:<14}|{ad.buyut():>17}")
+yazdir("=".tekrarla(32))
@@ -0,0 +1,132 @@
+# Yapılar ve sınıflar: kendi türünü tanımlamak, metotlar ve nesne listeleri
+#
+# Bir kitabın adı, yazarı, sayfa sayısı ve yılı birbirine aittir. Bunları dört
+# ayrı değişkende tutmak yerine tek bir "Kitap" türünde toplarız.
+#   yapi  : ilgili verileri (alanları) ve onlarla çalışan fonksiyonları bir arada tutar
+#   sinif : yapıya ek olarak kurucu (kur) ve self ile çalışan metotlar sunar
+
+# ── yapi: alanlar ve metotlar ─────────────────────────────────
+# Her alana bir varsayılan değer verilir; alanın türü bu değerden anlaşılır.
+# Yapının içindeki fonksiyonlara metot denir. Metotlar alanlara doğrudan adıyla ulaşır.
+yapi Kitap:
+    ad = ""
+    yazar = ""
+    sayfa = 0
+    yil = 0
+
+    fonksiyon ozet() -> metin:
+        don f"{ad} ({yazar}, {yil})"
+
+    fonksiyon okuma_suresi(gunluk_sayfa: sayi) -> sayi:
+        # Kalan sayfaları da saymak için yukarı yuvarlıyoruz.
+        don (sayfa + gunluk_sayfa - 1) // gunluk_sayfa
+
+# ── sayilabilir: sınırlı seçenekler ───────────────────────────
+# Bir değişken yalnız belli değerleri alabiliyorsa sayilabilir kullanılır.
+# Yanlış yazılan bir üye (Durum.KAYIP gibi) program çalışmadan yakalanır.
+sayilabilir Durum:
+    RAFTA
+    ODUNCTE
+
+# ── sinif: kurucu ve self ─────────────────────────────────────
+# kur(self, ...) nesne oluşturulurken çalışır. self "bu nesnenin kendisi" demektir;
+# self.ad, bu okuyucunun adı alanıdır.
+sinif Okuyucu:
+    ad = ""
+    okunan_sayfa = 0
+    kitap_sayisi = 0
+
+    fonksiyon kur(self, ad_: metin):
+        self.ad = ad_
+
+    # Metot nesnenin kendi alanlarını değiştirir; değişiklik kalıcıdır.
+    fonksiyon bitirdi(self, k: Kitap):
+        self.okunan_sayfa = self.okunan_sayfa + k.sayfa
+        self.kitap_sayisi = self.kitap_sayisi + 1
+
+    fonksiyon rapor(self) -> metin:
+        don f"{self.ad}: {self.kitap_sayisi} kitap, toplam {self.okunan_sayfa} sayfa"
+
+
+# ════════════════ Program buradan başlıyor ════════════════
+
+# ── Nesne oluşturmak ──────────────────────────────────────────
+# Yol 1: boş nesne oluşturup alanları tek tek doldurmak.
+k1 = Kitap()
+k1.ad = "Çalıkuşu"
+k1.yazar = "Reşat Nuri Güntekin"
+k1.sayfa = 544
+k1.yil = 1922
+
+# Yol 2: alanları tanım sırasıyla vermek (ad, yazar, sayfa, yil).
+k2 = Kitap("Kuyucaklı Yusuf", "Sabahattin Ali", 232, 1937)
+
+yazdir(k1.ozet())
+yazdir(k2.ozet())
+yazdir(f"{k2.ad} günde 20 sayfayla {k2.okuma_suresi(20)} günde biter.")
+
+# Yapıyı doğrudan yazdırınca bütün alanları görünür.
+yazdir(k2)
+yazdir()
+
+# ── Nesne listesi ─────────────────────────────────────────────
+raf = [k1, k2]
+raf.ekle(Kitap("İnce Memed", "Yaşar Kemal", 436, 1955))
+raf.ekle(Kitap("Tutunamayanlar", "Oğuz Atay", 724, 1972))
+raf.ekle(Kitap("Saatleri Ayarlama Enstitüsü", "Ahmet Hamdi Tanpınar", 382, 1961))
+
+yazdir(f"{'Kitap':<30}{'Yazar':<22}{'Yıl':>5}{'Sayfa':>7}")
+yazdir("─".tekrarla(64))
+dongu k icinde raf:
+    yazdir(f"{k.ad:<30}{k.yazar:<22}{k.yil:>5}{k.sayfa:>7}")
+yazdir()
+
+# Listedeki nesnelerin alanlarıyla hesap: en kalın kitap ve toplam sayfa.
+en_kalin = raf[0]
+toplam_sayfa = 0
+dongu k icinde raf:
+    toplam_sayfa += k.sayfa
+    eger k.sayfa > en_kalin.sayfa:
+        en_kalin = k
+yazdir(f"Raftaki {raf.uzunluk()} kitap toplam {toplam_sayfa:,} sayfa.")
+yazdir(f"En kalını: {en_kalin.ozet()}, {en_kalin.sayfa} sayfa")
+
+# Yıla göre sıralama: her adımda kalan kitapların en eskisini öne alıyoruz (seçmeli sıralama).
+i = 0
+iken i < raf.uzunluk():
+    en_eski = i
+    j = i + 1
+    iken j < raf.uzunluk():
+        eger raf[j].yil < raf[en_eski].yil:
+            en_eski = j
+        j += 1
+    gecici = raf[i]
+    raf[i] = raf[en_eski]
+    raf[en_eski] = gecici
+    i += 1
+
+yazdir("Yayın yılına göre:")
+dongu k icinde raf:
+    yazdir(f"  {k.yil}  {k.ad}")
+yazdir()
+
+# ── sayilabilir değerlerle çalışmak ───────────────────────────
+durum = Durum.RAFTA
+yazdir(f"{k2.ad}: {durum}")
+durum = Durum.ODUNCTE
+eger durum == Durum.ODUNCTE:
+    yazdir(f"{k2.ad} şu an ödünç verildi.")
+yazdir()
+
+# ── Sınıf nesnesiyle çalışmak ─────────────────────────────────
+# Okuyucu("Elif") yazınca kur(self, "Elif") çağrılır.
+elif = Okuyucu("Elif")
+emre = Okuyucu("Emre")
+
+elif.bitirdi(raf[0])
+elif.bitirdi(raf[2])
+emre.bitirdi(raf[4])
+
+# Her nesnenin kendi alanları vardır; Elif'in okuduğu Emre'yi etkilemez.
+yazdir(elif.rapor())
+yazdir(emre.rapor())
@@ -0,0 +1,116 @@
+# Hatalar: sonuc türüyle beklenen hatalar, ? ile yayma, dene/yakala/firlat
+#
+# Programlar her zaman yolunda gitmez: kullanıcı yanlış değer girer, bir sayı
+# sıfıra bölünür, listede olmayan bir sıra istenir. KabaLang'de iki yol vardır:
+#   sonuc<T, Hata>        : beklenebilir hatalar için. Fonksiyon ya başarıyı (tamam)
+#                           ya da hatayı (hata) döndürür; çağıran ikisini de ele almak zorundadır.
+#   dene / yakala / firlat : programın o noktada devam edemeyeceği durumlar için.
+
+# ── sonuc: başarı ya da hata döndüren fonksiyon ───────────────
+# Dönüş türü sonuc<sayi, Hata>: başarıda bir sayı, başarısızlıkta bir hata taşır.
+fonksiyon yas_coz(girdi: metin) -> sonuc<sayi, Hata>:
+    temiz = girdi.kirp()
+    eger temiz.bos_mu():
+        don hata("yaş boş bırakılamaz")
+    # Her karakter bir rakam mı?
+    dongu harf icinde temiz:
+        eger degil "0123456789".icerir(harf):
+            don hata(f"'{temiz}' bir sayı değil")
+    yas = sayi(temiz)
+    eger yas > 130:
+        don hata(f"{yas} yaş gerçekçi değil")
+    don tamam(yas)
+
+# ── ?: hatayı yukarı iletmek ──────────────────────────────────
+# yas_coz(...)? şunu der: sonuç hataysa bu fonksiyondan da AYNI hatayla hemen çık;
+# başarılıysa içindeki sayıyı ver. Her adımda eger yazmaktan kurtarır.
+# ? yalnız kendisi de sonuc döndüren bir fonksiyonun içinde kullanılabilir.
+fonksiyon yas_farki(birinci: metin, ikinci: metin) -> sonuc<sayi, Hata>:
+    a = yas_coz(birinci)?
+    b = yas_coz(ikinci)?
+    eger a > b:
+        don tamam(a - b)
+    don tamam(b - a)
+
+# ── firlat: devam edilemeyen durum ────────────────────────────
+# firlat çalışınca fonksiyon orada biter; hata, onu yakalayan ilk dene bloğuna kadar çıkar.
+fonksiyon stoktan_dus(stok: sayi, adet: sayi) -> sayi:
+    eger adet <= 0:
+        firlat hata(f"geçersiz adet: {adet}")
+    eger adet > stok:
+        firlat hata(f"stokta {stok} ürün var, {adet} istendi")
+    don stok - adet
+
+fonksiyon yesil(m: metin) -> metin:
+    don "\033[32m" + m + "\033[0m"
+
+fonksiyon kirmizi(m: metin) -> metin:
+    don "\033[31m" + m + "\033[0m"
+
+
+# ════════════════ Program buradan başlıyor ════════════════
+
+# ── sonuc'u kullanmak ─────────────────────────────────────────
+yazdir("Yaş girdilerini denetleyelim:")
+dongu girdi icinde ["34", "  7 ", "", "otuz", "250"]:
+    r = yas_coz(girdi)
+    # tamam_mi() / hatali_mi() hangisi olduğunu söyler.
+    # deger() başarıdaki sayıyı, hata().mesaj() hatanın açıklamasını verir.
+    eger r.tamam_mi():
+        yazdir(yesil("  ✓ ") + f"\"{girdi}\" → {r.deger()} yaş")
+    degilse:
+        yazdir(kirmizi("  ✗ ") + f"\"{girdi}\" → {r.hata().mesaj()}")
+
+# sonuc döndüren bir fonksiyonu çağırıp sonucu hiç kullanmamak derleme hatasıdır:
+# yas_coz("12") tek başına bir satırda yazılırsa program derlenmez.
+# Sonucu bilerek atmak istiyorsan bunu açıkça yazarsın: _ = yas_coz("12")
+yazdir()
+
+yazdir("Yaş farkları:")
+dongu ikili icinde [["40", "12"], ["40", "kırk"], ["", "12"]]:
+    f = yas_farki(ikili[0], ikili[1])
+    eger f.tamam_mi():
+        yazdir(f"  {ikili[0]} ile {ikili[1]} arası {f.deger()} yıl")
+    degilse:
+        yazdir(f"  hesaplanamadı: {f.hata().mesaj()}")
+yazdir()
+
+# ── dene / yakala ─────────────────────────────────────────────
+# dene bloğunda bir hata fırlatılırsa blok orada kesilir ve yakala bloğu çalışır.
+# yakala h: hata metnini h adıyla verir. Hata olmazsa yakala hiç çalışmaz.
+stok = 10
+dongu istek icinde [3, 4, 0, 5]:
+    dene:
+        stok = stoktan_dus(stok, istek)
+        yazdir(f"  {istek} adet satıldı, stokta {stok} kaldı")
+    yakala h:
+        yazdir(kirmizi("  satış yapılamadı: ") + h)
+yazdir()
+
+# ── Dilin kendi fırlattığı hatalar ────────────────────────────
+# Sıfıra bölme, listede olmayan bir sıra, sözlükte olmayan bir anahtar...
+# Yakalanmazlarsa program bu satırda durur. Yakalanırlarsa program devam eder.
+# Hata metni dosya adını ve satır numarasını da içerir; hatayı bulmanın ilk ipucu budur.
+bolen = 0
+dene:
+    yazdir(100 // bolen)
+yakala h:
+    yazdir("Bölme hatası yakalandı:")
+    yazdir(f"  {h}")
+
+sehirler = ["Rize", "Artvin"]
+dene:
+    yazdir(sehirler[5])
+yakala h:
+    yazdir("Liste hatası yakalandı:")
+    yazdir(f"  {h}")
+
+# yakala'dan sonra ad yazmazsak hata metni kullanılmaz, yalnız yakalanır.
+basarili = dogru
+dene:
+    firlat "bağlantı kurulamadı"
+yakala:
+    basarili = yanlis
+yazdir(f"İşlem başarılı mı? {basarili}")
+yazdir()
+yazdir("Bütün hatalar ele alındı; program sonuna kadar çalıştı.")
@@ -0,0 +1,107 @@
+# Dosyalar: metin ve JSON dosyasına yazmak, dosyayı geri okuyup işlemek
+#
+# Program bittiğinde değişkenlerdeki her şey kaybolur. Bilgiyi saklamak için
+# dosyaya yazarız; program bir sonraki çalışmada onu geri okuyabilir.
+# Bu ders çalıştığı klasörde iki dosya oluşturur: alisveris.txt ve sinif.json.
+# Program bitince dosyalar yerinde kalır; açıp içlerine bakabilirsin.
+
+kullan kaba.sistem
+
+degismez LISTE_DOSYASI = "alisveris.txt"
+degismez JSON_DOSYASI = "sinif.json"
+
+# ── 1. Metin dosyasına yazmak ─────────────────────────────────
+# dosya.yaz(yol, metin) dosyayı oluşturur; dosya zaten varsa içeriğini SİLİP yeniden yazar.
+# Her satırın sonuna \n koyuyoruz; yoksa bütün satırlar yan yana birleşirdi.
+# Satır biçimimiz: ürün;adet;birim fiyat
+dosya.yaz(LISTE_DOSYASI, "ekmek;2;12.50\n")
+
+# dosya.ekle(yol, metin) var olan içeriğe dokunmadan sonuna ekler.
+dosya.ekle(LISTE_DOSYASI, "süt;1;34.90\n")
+dosya.ekle(LISTE_DOSYASI, "domates;3;18.75\n")
+dosya.ekle(LISTE_DOSYASI, "peynir;1;149.00\n")
+
+yazdir(f"{LISTE_DOSYASI} yazıldı: {dosya.boyut(LISTE_DOSYASI)} bayt")
+
+# ── 2. Metin dosyasını okumak ─────────────────────────────────
+# dosya.oku(yol) bütün dosyayı tek bir metin olarak verir.
+# Olmayan bir dosyayı okumak hata vermez, boş metin döner; bu yüzden önce var_mi() ile soruyoruz.
+eger dosya.var_mi(LISTE_DOSYASI):
+    icerik = dosya.oku(LISTE_DOSYASI)
+
+    # kirp() sondaki \n'yi atar, bol("\n") metni satırlara ayırır.
+    satirlar = icerik.kirp().bol("\n")
+    yazdir(f"{satirlar.uzunluk()} satır okundu:")
+    yazdir()
+
+    toplam = 0.0
+    yazdir(f"  {'Ürün':<10}{'Adet':>5}{'Fiyat':>9}{'Tutar':>10}")
+    yazdir("  " + "─".tekrarla(34))
+    dongu satir icinde satirlar:
+        # Her satırı ; işaretinden bölüp parçaları uygun türe çeviriyoruz.
+        parca = satir.bol(";")
+        urun = parca[0]
+        adet = sayi(parca[1])
+        fiyat = ondalik(parca[2])
+        tutar = adet * fiyat
+        toplam += tutar
+        yazdir(f"  {urun:<10}{adet:>5}{fiyat:>9.2f}{tutar:>10.2f}")
+    yazdir("  " + "─".tekrarla(34))
+    yazdir(f"  {'Toplam':<24}{toplam:>10.2f} TL")
+yazdir()
+
+eger degil dosya.var_mi("olmayan-dosya.txt"):
+    yazdir("olmayan-dosya.txt bulunamadı (beklenen durum).")
+yazdir()
+
+# ── 3. JSON dosyasına yazmak ──────────────────────────────────
+# JSON, sözlük ve listeleri metne dönüştürmenin yaygın bir biçimidir; başka
+# programlar ve diller de okuyabilir. Önce bilgiyi sözlüklerle kuruyoruz.
+ogrenciler = {}
+ogrenciler["Ayşe"] = {"not": 88, "sehir": "Eskişehir"}
+ogrenciler["Mehmet"] = {"not": 64, "sehir": "Konya"}
+ogrenciler["Elif"] = {"not": 92, "sehir": "Trabzon"}
+ogrenciler["Can"] = {"not": 47, "sehir": "Mersin"}
+
+# Adı "sinif" koyamıyoruz: sinif dilin anahtar sözcüğü, değişken adı olamaz.
+sinif_bilgisi = {"ad": "9-A", "ogretmen": "Deniz Arslan", "ogrenciler": ogrenciler}
+
+# json.uret(sozluk, dogru) okunaklı, girintili bir JSON metni üretir.
+# (İkinci değer yazılmazsa her şey tek satıra sıkıştırılır.)
+# Anahtarlar dosyaya alfabetik sırayla yazılır.
+json_metni = json.uret(sinif_bilgisi, dogru)
+dosya.yaz(JSON_DOSYASI, json_metni)
+yazdir(f"{JSON_DOSYASI} yazıldı. İçeriği:")
+yazdir(json_metni)
+
+# ── 4. JSON dosyasını geri okumak ─────────────────────────────
+okunan = dosya.oku(JSON_DOSYASI)
+
+# Bozuk bir dosyayı çözmeye kalkmadan önce geçerli JSON olup olmadığını soruyoruz.
+eger json.gecerli_mi(okunan):
+    veri = json.coz(okunan)
+
+    # Çözülen veride anahtarlarla iç içe ilerlenir: veri["ogrenciler"]["Elif"]["not"].
+    # JSON'dan gelen değerin türü derleme anında bilinmez; sayi() ve metin() ile
+    # hangi türde kullanacağımızı açıkça söylüyoruz.
+    yazdir(f"Sınıf {metin(veri['ad'])}, öğretmen {metin(veri['ogretmen'])}")
+
+    toplam_not = 0
+    sayac = 0
+    dongu ad icinde veri["ogrenciler"].anahtarlar():
+        kayit = veri["ogrenciler"][ad]
+        notu = sayi(kayit["not"])
+        toplam_not += notu
+        sayac += 1
+        durum = "geçti"
+        eger notu < 50:
+            durum = "kaldı"
+        yazdir(f"  {ad:<8}{metin(kayit['sehir']):<11}{notu:>4}  {durum}")
+    yazdir(f"Ortalama: {toplam_not / sayac:.1f}")
+degilse:
+    yazdir(f"{JSON_DOSYASI} geçerli bir JSON değil.")
+
+# Bozuk JSON örneği: süslü parantez kapanmamış.
+bozuk = "{\"ad\": \"9-A\""
+yazdir()
+yazdir(f"{bozuk} geçerli JSON mu? {json.gecerli_mi(bozuk)}")
@@ -17,6 +17,10 @@ kullan kaba.sistem

 SORU = "Bir sonraki KabaLang örneği ne olsun?"
 PORT = 8473
+# Barındıran ortam (ör. Online IDE) portu PORT ortam değişkeniyle verir.
+port_ortam = cevre.al("PORT")
+eger port_ortam != "":
+    PORT = sayi(port_ortam)

 db = cevre.al("ANKET_DB")
 eger db == "":
@@ -18,6 +18,10 @@ kullan kaba.sistem
 ALFABE = "abcdefghjkmnpqrstuvwxyz23456789"
 KOD_UZUNLUGU = 6
 PORT = 8472
+# Barındıran ortam (ör. Online IDE) portu PORT ortam değişkeniyle verir.
+port_ortam = cevre.al("PORT")
+eger port_ortam != "":
+    PORT = sayi(port_ortam)

 db = cevre.al("KISALT_DB")
 eger db == "":
@@ -143,7 +143,12 @@ fonksiyon kaldir(istek):
    don web.yanit("", 204)

 # Tek iş parçacığı: SQLite'a yazan işleyiciler sırayla koşar.
-sunucu = web.sunucu(8471, "127.0.0.1", 1)
+# Barındıran ortam (ör. Online IDE) portu PORT ortam değişkeniyle verir.
+port = 8471
+port_ortam = cevre.al("PORT")
+eger port_ortam != "":
+    port = sayi(port_ortam)
+sunucu = web.sunucu(port, "127.0.0.1", 1)
 sunucu.hatalar_json()
 sunucu.govde_siniri(16384)

@@ -154,5 +159,5 @@ sunucu.guncelle("/api/gorevler/{id}", guncelle)
 # DELETE yöntemi `sunucu.kaldir` ile bağlanır
 sunucu.kaldir("/api/gorevler/{id}", kaldir)

-yazdir("📋 Pano hazır — http://127.0.0.1:8471")
+yazdir("📋 Pano hazır — http://127.0.0.1:" + metin(port))
 sunucu.basla()