diff --git a/README.md b/README.md index cccd9c6..9f2778c 100644 --- a/README.md +++ b/README.md @@ -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 | |---|---|---| diff --git a/dersler/01-kabalang-giris.md b/dersler/01-kabalang-giris.md new file mode 100644 index 0000000..5cf6873 --- /dev/null +++ b/dersler/01-kabalang-giris.md @@ -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. +``` diff --git a/dersler/02-sozdizimi-girinti.md b/dersler/02-sozdizimi-girinti.md new file mode 100644 index 0000000..6df8697 --- /dev/null +++ b/dersler/02-sozdizimi-girinti.md @@ -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. +``` diff --git a/dersler/03-yorumlar.md b/dersler/03-yorumlar.md new file mode 100644 index 0000000..2ea21b7 --- /dev/null +++ b/dersler/03-yorumlar.md @@ -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. +``` diff --git a/dersler/04-degiskenler.md b/dersler/04-degiskenler.md new file mode 100644 index 0000000..76b40f2 --- /dev/null +++ b/dersler/04-degiskenler.md @@ -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 +``` diff --git a/dersler/05-veri-turleri.md b/dersler/05-veri-turleri.md new file mode 100644 index 0000000..420d052 --- /dev/null +++ b/dersler/05-veri-turleri.md @@ -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 +``` diff --git a/dersler/06-sayilar-aritmetik.md b/dersler/06-sayilar-aritmetik.md new file mode 100644 index 0000000..bf70cb0 --- /dev/null +++ b/dersler/06-sayilar-aritmetik.md @@ -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 +``` diff --git a/dersler/07-tur-donusumleri.md b/dersler/07-tur-donusumleri.md new file mode 100644 index 0000000..63fade9 --- /dev/null +++ b/dersler/07-tur-donusumleri.md @@ -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 +``` diff --git a/dersler/08-metinler.md b/dersler/08-metinler.md new file mode 100644 index 0000000..613aa39 --- /dev/null +++ b/dersler/08-metinler.md @@ -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 +``` diff --git a/dersler/09-metin-islemleri.md b/dersler/09-metin-islemleri.md new file mode 100644 index 0000000..196a53b --- /dev/null +++ b/dersler/09-metin-islemleri.md @@ -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 = " Ayse.Kaya@Ornek.com " +# buraya yaz +%%% +eposta = " Ayse.Kaya@Ornek.com " +temiz = eposta.kirp().kucult() +yazdir(temiz) +yazdir(temiz.icerir("@")) +%%% +ayse.kaya@ornek.com +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 +``` diff --git a/dersler/10-bicimlendirme.md b/dersler/10-bicimlendirme.md new file mode 100644 index 0000000..366eae3 --- /dev/null +++ b/dersler/10-bicimlendirme.md @@ -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 +``` diff --git a/dersler/11-mantik-karsilastirma.md b/dersler/11-mantik-karsilastirma.md new file mode 100644 index 0000000..715d1b0 --- /dev/null +++ b/dersler/11-mantik-karsilastirma.md @@ -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ış +``` diff --git a/dersler/12-kosullar.md b/dersler/12-kosullar.md new file mode 100644 index 0000000..1e4b0f8 --- /dev/null +++ b/dersler/12-kosullar.md @@ -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 +``` diff --git a/dersler/13-iken-dongusu.md b/dersler/13-iken-dongusu.md new file mode 100644 index 0000000..81a9f99 --- /dev/null +++ b/dersler/13-iken-dongusu.md @@ -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 +``` diff --git a/dersler/14-dongu-icinde.md b/dersler/14-dongu-icinde.md new file mode 100644 index 0000000..cb3ffba --- /dev/null +++ b/dersler/14-dongu-icinde.md @@ -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)) +%%% +* +** +*** +**** +***** +``` diff --git a/dersler/15-kir-devam.md b/dersler/15-kir-devam.md new file mode 100644 index 0000000..0d4eb45 --- /dev/null +++ b/dersler/15-kir-devam.md @@ -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 +``` diff --git a/dersler/16-listeler.md b/dersler/16-listeler.md new file mode 100644 index 0000000..35a4a5c --- /dev/null +++ b/dersler/16-listeler.md @@ -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 = []` 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] +``` diff --git a/dersler/17-liste-islemleri.md b/dersler/17-liste-islemleri.md new file mode 100644 index 0000000..3e8bda3 --- /dev/null +++ b/dersler/17-liste-islemleri.md @@ -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 +``` diff --git a/dersler/18-sozlukler.md b/dersler/18-sozlukler.md new file mode 100644 index 0000000..5eb3e4f --- /dev/null +++ b/dersler/18-sozlukler.md @@ -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 +``` diff --git a/dersler/19-fonksiyonlar.md b/dersler/19-fonksiyonlar.md new file mode 100644 index 0000000..1be340b --- /dev/null +++ b/dersler/19-fonksiyonlar.md @@ -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 +``` diff --git a/dersler/20-parametreler-donus.md b/dersler/20-parametreler-donus.md new file mode 100644 index 0000000..97fa12b --- /dev/null +++ b/dersler/20-parametreler-donus.md @@ -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: + 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) -> liste: + 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)` 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): + 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 +``` diff --git a/dersler/21-ozyineleme.md b/dersler/21-ozyineleme.md new file mode 100644 index 0000000..c54f149 --- /dev/null +++ b/dersler/21-ozyineleme.md @@ -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, 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, 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 +``` diff --git a/dersler/22-yapilar.md b/dersler/22-yapilar.md new file mode 100644 index 0000000..a58cf0c --- /dev/null +++ b/dersler/22-yapilar.md @@ -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 +``` diff --git a/dersler/23-siniflar.md b/dersler/23-siniflar.md new file mode 100644 index 0000000..a5d07f3 --- /dev/null +++ b/dersler/23-siniflar.md @@ -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 = []`), `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 = [] + + 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 +``` diff --git a/dersler/24-sayilabilir.md b/dersler/24-sayilabilir.md new file mode 100644 index 0000000..9b075cd --- /dev/null +++ b/dersler/24-sayilabilir.md @@ -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 +``` diff --git a/dersler/25-hata-yonetimi.md b/dersler/25-hata-yonetimi.md new file mode 100644 index 0000000..889b075 --- /dev/null +++ b/dersler/25-hata-yonetimi.md @@ -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` 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: + 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: + 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: + 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: + 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: + 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: + 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` kullanılır: `dolu(deger)` ya da `bos`. + +```kbl +fonksiyon ilk_uzun_kelime(kelimeler: liste, en_az: sayi) -> belki: + 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` 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: + 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` fonksiyonunu `?` ile yaz: iki ürünün stoklarını toplayıp döndürsün. +%%% +fonksiyon stok_bul(urun: metin) -> sonuc: + 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: + 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: + 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ı +``` diff --git a/dersler/26-istisnalar.md b/dersler/26-istisnalar.md new file mode 100644 index 0000000..9de1eac --- /dev/null +++ b/dersler/26-istisnalar.md @@ -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 +``` diff --git a/dersler/27-kullanici-girdisi.md b/dersler/27-kullanici-girdisi.md new file mode 100644 index 0000000..21223d9 --- /dev/null +++ b/dersler/27-kullanici-girdisi.md @@ -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` 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 +``` diff --git a/dersler/28-dosyalar.md b/dersler/28-dosyalar.md new file mode 100644 index 0000000..33ef363 --- /dev/null +++ b/dersler/28-dosyalar.md @@ -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 +``` diff --git a/dersler/29-moduller.md b/dersler/29-moduller.md new file mode 100644 index 0000000..41ae66a --- /dev/null +++ b/dersler/29-moduller.md @@ -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 +``` diff --git a/dersler/BICIM.md b/dersler/BICIM.md new file mode 100644 index 0000000..1830159 --- /dev/null +++ b/dersler/BICIM.md @@ -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. diff --git a/temeller/01-merhaba/merhaba.kbl b/temeller/01-merhaba/merhaba.kbl new file mode 100644 index 0000000..4da675d --- /dev/null +++ b/temeller/01-merhaba/merhaba.kbl @@ -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) diff --git a/temeller/02-degiskenler/degiskenler.kbl b/temeller/02-degiskenler/degiskenler.kbl new file mode 100644 index 0000000..42c5745 --- /dev/null +++ b/temeller/02-degiskenler/degiskenler.kbl @@ -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") diff --git a/temeller/03-girdi/girdi.kbl b/temeller/03-girdi/girdi.kbl new file mode 100644 index 0000000..077b4e8 --- /dev/null +++ b/temeller/03-girdi/girdi.kbl @@ -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.") diff --git a/temeller/03-girdi/girdi.txt b/temeller/03-girdi/girdi.txt new file mode 100644 index 0000000..1552540 --- /dev/null +++ b/temeller/03-girdi/girdi.txt @@ -0,0 +1,5 @@ +Ayşe Yılmaz +1998 +68.5 +1.65 +on iki diff --git a/temeller/04-kosullar/kosullar.kbl b/temeller/04-kosullar/kosullar.kbl new file mode 100644 index 0000000..cc08808 --- /dev/null +++ b/temeller/04-kosullar/kosullar.kbl @@ -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") diff --git a/temeller/05-donguler/donguler.kbl b/temeller/05-donguler/donguler.kbl new file mode 100644 index 0000000..7e50cac --- /dev/null +++ b/temeller/05-donguler/donguler.kbl @@ -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ı.") diff --git a/temeller/06-fonksiyonlar/fonksiyonlar.kbl b/temeller/06-fonksiyonlar/fonksiyonlar.kbl new file mode 100644 index 0000000..d4c7f9d --- /dev/null +++ b/temeller/06-fonksiyonlar/fonksiyonlar.kbl @@ -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() diff --git a/temeller/07-listeler/listeler.kbl b/temeller/07-listeler/listeler.kbl new file mode 100644 index 0000000..9b66389 --- /dev/null +++ b/temeller/07-listeler/listeler.kbl @@ -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) -> liste: + 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]}") diff --git a/temeller/08-sozlukler/sozlukler.kbl b/temeller/08-sozlukler/sozlukler.kbl new file mode 100644 index 0000000..727e962 --- /dev/null +++ b/temeller/08-sozlukler/sozlukler.kbl @@ -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.") diff --git a/temeller/09-metinler/metinler.kbl b/temeller/09-metinler/metinler.kbl new file mode 100644 index 0000000..df20f8a --- /dev/null +++ b/temeller/09-metinler/metinler.kbl @@ -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)) diff --git a/temeller/10-yapilar/yapilar.kbl b/temeller/10-yapilar/yapilar.kbl new file mode 100644 index 0000000..f8dfe52 --- /dev/null +++ b/temeller/10-yapilar/yapilar.kbl @@ -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()) diff --git a/temeller/11-hatalar/hatalar.kbl b/temeller/11-hatalar/hatalar.kbl new file mode 100644 index 0000000..3131601 --- /dev/null +++ b/temeller/11-hatalar/hatalar.kbl @@ -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 : 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: başarıda bir sayı, başarısızlıkta bir hata taşır. +fonksiyon yas_coz(girdi: metin) -> sonuc: + 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: + 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ı.") diff --git a/temeller/12-dosyalar/dosyalar.kbl b/temeller/12-dosyalar/dosyalar.kbl new file mode 100644 index 0000000..3a9e0e7 --- /dev/null +++ b/temeller/12-dosyalar/dosyalar.kbl @@ -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)}") diff --git a/web/anket/anket.kbl b/web/anket/anket.kbl index 55cc0b7..66b673a 100644 --- a/web/anket/anket.kbl +++ b/web/anket/anket.kbl @@ -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 == "": diff --git a/web/kisalt/kisalt.kbl b/web/kisalt/kisalt.kbl index 81ef0eb..1a0bb49 100644 --- a/web/kisalt/kisalt.kbl +++ b/web/kisalt/kisalt.kbl @@ -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 == "": diff --git a/web/pano/pano.kbl b/web/pano/pano.kbl index 7d9d91d..5ed43df 100644 --- a/web/pano/pano.kbl +++ b/web/pano/pano.kbl @@ -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()