Dersler ve Temeller; web örnekleri PORT ortam değişkenini okur
- dersler/: 29 kısa ders (açıklama, çalıştırılabilir örnek, alıştırma). Her örneğin ve alıştırma çözümünün çıktısı Online IDE'nin hazırlık adımında gerçekten koşulup dosyadakiyle karşılaştırılır; biçim dersler/BICIM.md. - temeller/: tek konulu 12 başlangıç programı. - web/anket, web/kisalt, web/pano: port PORT ortam değişkeninden okunur (Online IDE önizlemesi 8080 verir), yoksa eski sabit port. - README: öğrenme bölümü, Online IDE bağlantısı.
This commit is contained in:
@@ -0,0 +1,51 @@
|
||||
# Merhaba: ekrana yazı yazmak, metinler, f-string ve yorum satırları
|
||||
#
|
||||
# Bir KabaLang programı yukarıdan aşağıya, satır satır çalışır.
|
||||
# "#" işaretinden sonra gelen her şey yorumdur: derleyici onu okumaz,
|
||||
# yalnız kodu okuyan insanlar için yazılır.
|
||||
|
||||
# yazdir(...) parantez içindekini ekrana yazar ve satırı bitirir.
|
||||
yazdir("Merhaba, dünya!")
|
||||
|
||||
# Metinler çift tırnak arasına yazılır. Türkçe harfler olduğu gibi çalışır.
|
||||
yazdir("Çağlayan, ılık bir İstanbul sabahında şiir okuyor.")
|
||||
|
||||
# Boş bir yazdir() araya boş satır koyar.
|
||||
yazdir()
|
||||
|
||||
# Metinler + ile uç uca eklenir.
|
||||
yazdir("Programlamaya " + "hoş geldiniz.")
|
||||
|
||||
# Bir değere ad verip sonra o adla kullanabiliriz.
|
||||
# Buna değişken denir; ayrıntısı bir sonraki derste.
|
||||
ad = "Ayşe"
|
||||
sehir = "Eskişehir"
|
||||
|
||||
# f"..." biçimli metindir: süslü parantez içindeki ad, değeriyle değiştirilir.
|
||||
yazdir(f"{ad}, {sehir} şehrinden selam gönderiyor.")
|
||||
|
||||
# Süslü parantezin içine bir hesap da yazılabilir.
|
||||
yazdir(f"Bir günde {24 * 60} dakika, bir haftada {7 * 24} saat vardır.")
|
||||
yazdir()
|
||||
|
||||
# Bazı karakterler ters eğik çizgiyle yazılır:
|
||||
# \n yeni satır \t sekme (boşluk atlar) \" tırnak işareti
|
||||
yazdir("Birinci satır\nİkinci satır")
|
||||
yazdir("Ad:\tAyşe\nŞehir:\t" + sehir)
|
||||
yazdir("Öğretmen \"tahtaya bakın\" dedi.")
|
||||
yazdir()
|
||||
|
||||
# Uçbirimde renkli yazı için ANSI kodları kullanılır.
|
||||
# \033[32m yeşile, \033[33m sarıya geçer; \033[1m kalın yazar; \033[0m her şeyi sıfırlar.
|
||||
# Rengi sıfırlamayı unutursan sonraki bütün satırlar da renkli kalır.
|
||||
yazdir("\033[32mYeşil\033[0m, \033[33msarı\033[0m ve \033[1mkalın\033[0m yazı.")
|
||||
yazdir()
|
||||
|
||||
# Küçük bir kartvizit. tekrarla(n) bir metni n kez yan yana koyar;
|
||||
# {ad:<12} değeri 12 karakterlik alana sola yaslayarak yazar.
|
||||
cizgi = "─".tekrarla(30)
|
||||
yazdir(cizgi)
|
||||
yazdir(f" {'Ad':<12}{ad}")
|
||||
yazdir(f" {'Şehir':<12}{sehir}")
|
||||
yazdir(f" {'Dil':<12}KabaLang")
|
||||
yazdir(cizgi)
|
||||
@@ -0,0 +1,94 @@
|
||||
# Değişkenler: sayı, ondalık, metin ve mantık türleri, dönüşümler ve aritmetik
|
||||
#
|
||||
# Değişken, bir değere verilen addır. "ad = değer" yazınca değer o ada bağlanır.
|
||||
# Türü yazmak gerekmez; KabaLang değere bakıp türü kendisi anlar.
|
||||
|
||||
# ── Dört temel tür ─────────────────────────────────────────────
|
||||
ogrenci = "Mehmet" # metin : tırnak içindeki yazı
|
||||
yas = 17 # sayi : tam sayı
|
||||
boy = 1.74 # ondalik : virgüllü sayı (Türkçedeki virgül yerine nokta yazılır)
|
||||
mezun = yanlis # mantik : dogru ya da yanlis
|
||||
|
||||
yazdir(f"Öğrenci: {ogrenci}, yaş: {yas}, boy: {boy} m, mezun: {mezun}")
|
||||
|
||||
# Değişkene yeni bir değer atanabilir; eski değer unutulur.
|
||||
yas = 18
|
||||
mezun = dogru
|
||||
yazdir(f"Bir yıl sonra: yaş {yas}, mezun: {mezun}")
|
||||
|
||||
# Uzun sayılarda basamakları _ ile ayırmak okumayı kolaylaştırır.
|
||||
nufus = 85_000_000
|
||||
yazdir(f"Nüfus: {nufus} (binlik ayırıcıyla: {nufus:,})")
|
||||
|
||||
# degismez ile tanımlanan değer bir daha değiştirilemez.
|
||||
# PI = 3 yazmaya kalkarsan derleyici programı çalıştırmadan durdurur.
|
||||
degismez PI = 3.14159
|
||||
yazdir()
|
||||
|
||||
# ── Aritmetik ─────────────────────────────────────────────────
|
||||
a = 17
|
||||
b = 5
|
||||
yazdir(f"{a} + {b} = {a + b}")
|
||||
yazdir(f"{a} - {b} = {a - b}")
|
||||
yazdir(f"{a} * {b} = {a * b}")
|
||||
yazdir(f"{a} / {b} = {a / b}") # / her zaman ondalık sonuç verir
|
||||
yazdir(f"{a} // {b} = {a // b}") # // tam bölme: küsuratı atar
|
||||
yazdir(f"{a} % {b} = {a % b}") # % bölümden kalan
|
||||
yazdir(f"2 ** 10 = {2 ** 10}") # ** üs alma
|
||||
yazdir()
|
||||
|
||||
# İşlem önceliği matematikteki gibidir; parantez önceliği değiştirir.
|
||||
yazdir(f"2 + 3 * 4 = {2 + 3 * 4}")
|
||||
yazdir(f"(2 + 3) * 4 = {(2 + 3) * 4}")
|
||||
|
||||
# Kısaltmalar: x += 5, "x = x + 5" demektir. -= ve *= de aynı mantıkla çalışır.
|
||||
puan = 10
|
||||
puan += 5
|
||||
puan *= 2
|
||||
yazdir(f"Puan: {puan}")
|
||||
yazdir()
|
||||
|
||||
# ── // ve % ile gerçek bir hesap ───────────────────────────────
|
||||
# Toplam saniyeyi saat, dakika ve saniyeye ayıralım.
|
||||
toplam_saniye = 10_000
|
||||
saat = toplam_saniye // 3600
|
||||
dakika = (toplam_saniye % 3600) // 60
|
||||
saniye = toplam_saniye % 60
|
||||
# {dakika:02} sayıyı iki basamağa tamamlar: 6 yerine 06 yazar.
|
||||
yazdir(f"{toplam_saniye} saniye = {saat} saat {dakika:02} dakika {saniye:02} saniye")
|
||||
|
||||
# Dairenin alanı: ondalık sayılarla hesap. {alan:.2f} virgülden sonra iki basamak yazar.
|
||||
yaricap = 2.5
|
||||
alan = PI * yaricap * yaricap
|
||||
yazdir(f"Yarıçapı {yaricap} olan dairenin alanı: {alan:.2f}")
|
||||
yazdir()
|
||||
|
||||
# ── Tür dönüşümü ──────────────────────────────────────────────
|
||||
# Türler kendiliğinden birbirine dönüşmez; dönüşümü açıkça yazarız.
|
||||
metin_sayi = "42"
|
||||
gercek_sayi = sayi(metin_sayi) # metinden tam sayıya
|
||||
yazdir(f"sayi(\"42\") + 8 = {gercek_sayi + 8}")
|
||||
|
||||
fiyat = ondalik("19.90") # metinden ondalığa
|
||||
yazdir(f"ondalik(\"19.90\") * 3 = {fiyat * 3:.2f}")
|
||||
|
||||
yazdir(f"sayi(3.99) = {sayi(3.99)} (küsurat atılır, yuvarlanmaz)")
|
||||
yazdir(f"ondalik(7) / 2 = {ondalik(7) / 2}")
|
||||
|
||||
# Bir sayıyı metne + ile eklemek için önce metin() ile çeviririz.
|
||||
yazdir("Sınıfta " + metin(24) + " öğrenci var.")
|
||||
|
||||
# Dikkat: sayıya benzemeyen bir metin hata vermez, 0'a dönüşür.
|
||||
# Kullanıcıdan gelen sayıları denetlemenin yolu bir sonraki derste.
|
||||
yazdir(f"sayi(\"on iki\") = {sayi('on iki')}")
|
||||
yazdir()
|
||||
|
||||
# ── Küçük bir alışveriş hesabı ─────────────────────────────────
|
||||
adet = 3
|
||||
birim_fiyat = 249.90
|
||||
kdv_orani = 0.20
|
||||
ara_toplam = adet * birim_fiyat
|
||||
kdv = ara_toplam * kdv_orani
|
||||
yazdir(f"Ara toplam : {ara_toplam:>9.2f} TL")
|
||||
yazdir(f"KDV (%20) : {kdv:>9.2f} TL")
|
||||
yazdir(f"Toplam : {ara_toplam + kdv:>9.2f} TL")
|
||||
@@ -0,0 +1,85 @@
|
||||
# Girdi: kullanıcıdan satır okumak, sayıya çevirmek ve okunanla hesap yapmak
|
||||
#
|
||||
# Bu program beş satır okur: ad, doğum yılı, kilo, boy ve kitap sayısı.
|
||||
# IDE'de girdiler aynı klasördeki girdi.txt dosyasından gelir; her satır,
|
||||
# kullanıcının yazıp Enter'a bastığı bir cevap gibidir.
|
||||
# Uçbirimde çalıştırırsan soruları görür, cevapları kendin yazarsın.
|
||||
|
||||
kullan kaba.sistem
|
||||
|
||||
# Soruları yalnız karşıda gerçekten bir insan varsa yazdıralım. Girdi bir
|
||||
# dosyadan geliyorsa sorular kimseye hitap etmez, çıktıyı kalabalıklaştırır.
|
||||
# etkilesimli_mi() bunu söyler: dogru ise klavyeden, yanlis ise dosyadan okuyoruz.
|
||||
etkilesimli = konsol.etkilesimli_mi()
|
||||
|
||||
# ── 1. Bir satır metin okumak ─────────────────────────────────
|
||||
# konsol.yaz() yazdir() gibidir ama satırı bitirmez; imleç sorunun yanında kalır.
|
||||
eger etkilesimli:
|
||||
konsol.yaz("Adınız: ")
|
||||
|
||||
# satir_oku() bir satır okur. Ama girdi bitmiş de olabilir; bu yüzden sonuç
|
||||
# "ya bir satır ya hiçbir şey" taşıyan bir kutudur. deger_veya("misafir")
|
||||
# kutuda satır varsa onu, yoksa "misafir"i verir. kirp() baştaki ve sondaki
|
||||
# boşlukları atar.
|
||||
ad = konsol.satir_oku().deger_veya("misafir").kirp()
|
||||
|
||||
# ── 2. Bir tam sayı okumak ve denetlemek ──────────────────────
|
||||
eger etkilesimli:
|
||||
konsol.yaz("Doğum yılınız: ")
|
||||
|
||||
# sayi_oku() satırı okur ve tam sayıya çevirmeyi dener. Sonuç iki şeyden biridir:
|
||||
# başarı (içinde sayı) ya da hata (içinde nedeni). tamam_mi() hangisi olduğunu söyler.
|
||||
# (Burada soruyu yukarıda kendimiz yazdığımız için sayi_oku'ya boş istem veriyoruz.)
|
||||
yil_sonucu = konsol.sayi_oku("")
|
||||
|
||||
# Başarılıysa sayıyı deger() ile kutudan çıkarırız; değilse 2000 ile devam ederiz.
|
||||
dogum_yili = 2000
|
||||
eger yil_sonucu.tamam_mi():
|
||||
dogum_yili = yil_sonucu.deger()
|
||||
|
||||
# ── 3. Ondalık sayı okumak ────────────────────────────────────
|
||||
eger etkilesimli:
|
||||
konsol.yaz("Kilonuz (kg): ")
|
||||
kilo = ondalik(konsol.satir_oku().deger_veya("0").kirp())
|
||||
|
||||
eger etkilesimli:
|
||||
konsol.yaz("Boyunuz (m): ")
|
||||
boy = ondalik(konsol.satir_oku().deger_veya("0").kirp())
|
||||
|
||||
# ── 4. Hatalı bir girdi ───────────────────────────────────────
|
||||
eger etkilesimli:
|
||||
konsol.yaz("Bu ay kaç kitap okudunuz? ")
|
||||
kitap_sonucu = konsol.sayi_oku("")
|
||||
|
||||
# ── Okunanlarla hesap ─────────────────────────────────────────
|
||||
# Bu yılı saatten alıyoruz: zaman.bicimlendir("%Y") "2026" gibi bir metin verir.
|
||||
bu_yil = sayi(zaman.bicimlendir("%Y"))
|
||||
yas = bu_yil - dogum_yili
|
||||
|
||||
# Vücut kitle indeksi: kilo / (boy * boy)
|
||||
vki = kilo / (boy * boy)
|
||||
|
||||
yazdir(f"Merhaba {ad}!")
|
||||
yazdir(f"Adınız boşluk dahil {ad.uzunluk()} karakter.")
|
||||
|
||||
eger yil_sonucu.tamam_mi():
|
||||
yazdir(f"{dogum_yili} doğumlusunuz; bu yıl {yas} yaşına giriyorsunuz.")
|
||||
degilse:
|
||||
yazdir("Doğum yılı okunamadı: " + yil_sonucu.hata().mesaj())
|
||||
|
||||
yazdir(f"Kilo {kilo} kg, boy {boy} m → vücut kitle indeksi {vki:.1f}")
|
||||
|
||||
# "on iki" bir sayı değil: sayi_oku bunu hata olarak bildirir, program çökmez.
|
||||
eger kitap_sonucu.tamam_mi():
|
||||
yazdir(f"Bu ay {kitap_sonucu.deger()} kitap okumuşsunuz.")
|
||||
degilse:
|
||||
yazdir("Kitap sayısı anlaşılamadı: " + kitap_sonucu.hata().mesaj())
|
||||
yazdir(" (Rakamla yazmayı deneyin, örneğin 12.)")
|
||||
|
||||
# ── Girdinin sonu ─────────────────────────────────────────────
|
||||
# Beş satırın hepsini okuduk. Bir kez daha okumaya kalkarsak kutu boş gelir:
|
||||
# bos_mu() "okunacak satır kalmadı" demektir. Bu, boş bir satırla aynı şey değildir;
|
||||
# yalnız Enter'a basılan satır, içi boş bir metin olarak gelir.
|
||||
fazla = konsol.satir_oku()
|
||||
eger fazla.bos_mu():
|
||||
yazdir("Girdi bitti; okunacak başka satır yok.")
|
||||
@@ -0,0 +1,5 @@
|
||||
Ayşe Yılmaz
|
||||
1998
|
||||
68.5
|
||||
1.65
|
||||
on iki
|
||||
@@ -0,0 +1,101 @@
|
||||
# Koşullar: eger, degilse eger, degilse; karşılaştırma ve ve/veya/degil
|
||||
#
|
||||
# Program bazen bir şeyi yalnız belli bir durumda yapmalıdır.
|
||||
# "eger koşul:" satırının altındaki girintili kod, koşul doğruysa çalışır.
|
||||
# Girinti (satır başındaki 4 boşluk) hangi satırların bloğa ait olduğunu gösterir.
|
||||
|
||||
# ── Karşılaştırma işleçleri ───────────────────────────────────
|
||||
# Her karşılaştırmanın sonucu bir mantık değeridir: dogru ya da yanlis.
|
||||
# == eşit mi != farklı mı
|
||||
# < küçük mü <= küçük ya da eşit mi
|
||||
# > büyük mü >= büyük ya da eşit mi
|
||||
yazdir(f"7 > 3 : {7 > 3}")
|
||||
yazdir(f"7 == 3 : {7 == 3}")
|
||||
yazdir(f"7 != 3 : {7 != 3}")
|
||||
yazdir(f"\"elma\" == \"Elma\" : {'elma' == 'Elma'} (büyük/küçük harf fark eder)")
|
||||
yazdir()
|
||||
|
||||
# ── eger / degilse ────────────────────────────────────────────
|
||||
sicaklik = 31
|
||||
|
||||
eger sicaklik > 30:
|
||||
yazdir(f"Hava {sicaklik} derece: sıcak, bol su için.")
|
||||
degilse:
|
||||
yazdir(f"Hava {sicaklik} derece: serin.")
|
||||
|
||||
# ── degilse eger: birden çok seçenek ──────────────────────────
|
||||
# Koşullar yukarıdan aşağı denenir; DOĞRU çıkan İLK dal çalışır, gerisi atlanır.
|
||||
# Bu yüzden sıralama önemlidir: önce en büyük eşiği soruyoruz.
|
||||
puan = 77
|
||||
|
||||
eger puan >= 85:
|
||||
harf = "AA"
|
||||
degilse eger puan >= 70:
|
||||
harf = "BA"
|
||||
degilse eger puan >= 60:
|
||||
harf = "BB"
|
||||
degilse eger puan >= 50:
|
||||
harf = "CC"
|
||||
degilse:
|
||||
harf = "FF"
|
||||
|
||||
yazdir(f"{puan} puan → harf notu {harf}")
|
||||
yazdir()
|
||||
|
||||
# ── ve / veya / degil ─────────────────────────────────────────
|
||||
# ve : iki taraf da doğruysa doğru
|
||||
# veya : taraflardan en az biri doğruysa doğru
|
||||
# degil : doğruyu yanlışa, yanlışı doğruya çevirir
|
||||
yas = 16
|
||||
veli_izni = dogru
|
||||
|
||||
eger yas >= 18 veya veli_izni:
|
||||
yazdir(f"{yas} yaşında: geziye katılabilir.")
|
||||
degilse:
|
||||
yazdir(f"{yas} yaşında: veli izni gerekli.")
|
||||
|
||||
# Artık yıl kuralı: 4'e bölünür ve 100'e bölünmez, YA DA 400'e bölünür.
|
||||
# Uzun koşulları parantezle gruplamak hem doğru çalışmasını hem okunmasını sağlar.
|
||||
yil = 2024
|
||||
artik = (yil % 4 == 0 ve yil % 100 != 0) veya yil % 400 == 0
|
||||
eger artik:
|
||||
yazdir(f"{yil} artık yıl: şubat 29 gün.")
|
||||
degilse:
|
||||
yazdir(f"{yil} artık yıl değil: şubat 28 gün.")
|
||||
|
||||
eger degil artik:
|
||||
yazdir("Bu satır görünmez, çünkü yıl artık yıl.")
|
||||
yazdir()
|
||||
|
||||
# ── İç içe koşul ──────────────────────────────────────────────
|
||||
# Bir eger bloğunun içine başka bir eger yazılabilir. Her düzey 4 boşluk daha içeride.
|
||||
kullanici = "ayse"
|
||||
parola = "kirmizi-kalem"
|
||||
|
||||
eger kullanici == "ayse":
|
||||
eger parola == "kirmizi-kalem":
|
||||
yazdir("Giriş başarılı. Hoş geldin, Ayşe.")
|
||||
degilse:
|
||||
yazdir("Parola yanlış.")
|
||||
degilse:
|
||||
yazdir("Böyle bir kullanıcı yok.")
|
||||
|
||||
# ── Küçük bir hesap: kargo ücreti ─────────────────────────────
|
||||
# Sepet 500 TL ve üstüyse kargo ücretsiz; değilse ağırlığa göre ücret.
|
||||
sepet = 420.0
|
||||
agirlik_kg = 3.2
|
||||
|
||||
eger sepet >= 500.0:
|
||||
kargo = 0.0
|
||||
degilse eger agirlik_kg <= 1.0:
|
||||
kargo = 39.90
|
||||
degilse eger agirlik_kg <= 5.0:
|
||||
kargo = 59.90
|
||||
degilse:
|
||||
kargo = 89.90
|
||||
|
||||
yazdir()
|
||||
yazdir(f"Sepet {sepet:.2f} TL, {agirlik_kg} kg → kargo {kargo:.2f} TL")
|
||||
eger kargo > 0.0:
|
||||
eksik = 500.0 - sepet
|
||||
yazdir(f"\033[33m{eksik:.2f} TL'lik ürün daha eklerseniz kargo ücretsiz.\033[0m")
|
||||
@@ -0,0 +1,96 @@
|
||||
# Döngüler: dongu ... icinde, sayı aralıkları, iken, kir ve devam
|
||||
#
|
||||
# Döngü, bir kod bloğunu tekrar tekrar çalıştırır. KabaLang'de iki türü var:
|
||||
# dongu x icinde ... : bir listenin ya da aralığın her öğesi için bir kez
|
||||
# iken koşul: : koşul doğru olduğu sürece
|
||||
|
||||
# ── Bir listenin üzerinden geçmek ─────────────────────────────
|
||||
# Her turda sehir değişkeni sıradaki öğeyi alır.
|
||||
sehirler = ["Ankara", "İzmir", "Trabzon", "Van"]
|
||||
dongu sehir icinde sehirler:
|
||||
yazdir(f"• {sehir}")
|
||||
yazdir()
|
||||
|
||||
# ── Sayı aralığı: 1..5 ────────────────────────────────────────
|
||||
# 1..5 aralığı 1, 2, 3, 4, 5 demektir; üst sınır DAHİLDİR.
|
||||
toplam = 0
|
||||
dongu i icinde 1..5:
|
||||
toplam += i
|
||||
yazdir(f"i = {i}, şimdiye kadarki toplam = {toplam}")
|
||||
yazdir()
|
||||
|
||||
# Aralığın sınırları değişken de olabilir.
|
||||
n = 6
|
||||
konsol.yaz(f"7'nin ilk {n} katı:")
|
||||
dongu i icinde 1..n:
|
||||
konsol.yaz(f" {7 * i}")
|
||||
yazdir()
|
||||
yazdir()
|
||||
|
||||
# ── İç içe döngü: çarpım tablosu ──────────────────────────────
|
||||
# Dıştaki döngünün her turunda içteki döngü baştan sona çalışır.
|
||||
# {deger:4} sayıyı 4 karakterlik alana sağa yaslar; sütunlar böyle hizalanır.
|
||||
dongu satir icinde 1..5:
|
||||
cizelge = ""
|
||||
dongu sutun icinde 1..5:
|
||||
cizelge = cizelge + f"{satir * sutun:4}"
|
||||
yazdir(cizelge)
|
||||
yazdir()
|
||||
|
||||
# ── iken: koşul doğru olduğu sürece ───────────────────────────
|
||||
# Aralık yalnız ileri sayar (5..1 boştur); geri saymak için iken kullanılır.
|
||||
# Koşulu bir gün yanlış yapacak satırı (burada sayac -= 1) unutmak döngüyü sonsuz yapar.
|
||||
sayac = 5
|
||||
iken sayac > 0:
|
||||
konsol.yaz(f"{sayac}... ")
|
||||
sayac -= 1
|
||||
yazdir("kalkış!")
|
||||
|
||||
# Kaç turda biteceğini bilmediğimiz işler için iken uygundur.
|
||||
# Yıllık %40 faizle 10.000 TL kaç yılda iki katını geçer?
|
||||
para = 10_000.0
|
||||
yil = 0
|
||||
iken para < 20_000.0:
|
||||
para = para * 1.40
|
||||
yil += 1
|
||||
yazdir(f"{yil} yıl sonra para {para:,.2f} TL oldu; iki katını geçti.")
|
||||
yazdir()
|
||||
|
||||
# ── devam: bu turu atla ───────────────────────────────────────
|
||||
# devam'a gelince turun geri kalanı atlanır, döngü bir sonraki öğeyle sürer.
|
||||
konsol.yaz("1-20 arası 3'e bölünmeyen tek sayılar:")
|
||||
dongu i icinde 1..20:
|
||||
eger i % 2 == 0:
|
||||
devam # çift sayıysa geç
|
||||
eger i % 3 == 0:
|
||||
devam # 3'e bölünüyorsa geç
|
||||
konsol.yaz(f" {i}")
|
||||
yazdir()
|
||||
|
||||
# ── kir: döngüden tümden çık ──────────────────────────────────
|
||||
# Aradığımızı bulunca aramaya devam etmenin anlamı yok.
|
||||
notlar = [62, 48, 91, 77, 35, 88]
|
||||
dongu notu icinde notlar:
|
||||
eger notu < 50:
|
||||
yazdir(f"İlk başarısız not bulundu: {notu}")
|
||||
kir
|
||||
yazdir()
|
||||
|
||||
# ── Hepsi bir arada: asal sayılar ─────────────────────────────
|
||||
# Bir sayı, 1 ve kendisinden başka böleni yoksa asaldır.
|
||||
# Her aday için 2'den başlayıp bölen arıyoruz; bölen bulunca kir ile çıkıyoruz.
|
||||
asal_sayisi = 0
|
||||
konsol.yaz("50'ye kadar asal sayılar:")
|
||||
dongu aday icinde 2..50:
|
||||
asal = dogru
|
||||
bolen = 2
|
||||
iken bolen * bolen <= aday:
|
||||
eger aday % bolen == 0:
|
||||
asal = yanlis
|
||||
kir # yalnız içteki iken döngüsünden çıkar
|
||||
bolen += 1
|
||||
eger asal:
|
||||
konsol.yaz(f" {aday}")
|
||||
asal_sayisi += 1
|
||||
yazdir()
|
||||
yazdir(f"Toplam {asal_sayisi} asal sayı.")
|
||||
@@ -0,0 +1,100 @@
|
||||
# Fonksiyonlar: parametre, dönüş değeri, tür belirtme, varsayılan değer ve özyineleme
|
||||
#
|
||||
# Fonksiyon, bir işi yapan ve bir adı olan kod bloğudur. Bir kez yazılır,
|
||||
# istendiği kadar çağrılır. Tanımı "fonksiyon ad(parametreler):" ile başlar.
|
||||
#
|
||||
# Fonksiyonları dosyanın başına, değişkenlerden önce yazıyoruz. Bunun bir nedeni
|
||||
# var: bir fonksiyonun içinde, kendisinden ÖNCE tanımlanmış bir değişkenle aynı
|
||||
# adı kullanırsan fonksiyon o değişkeni değiştirir. Başta tanımlanan fonksiyonun
|
||||
# içindeki adlar yalnız ona ait kalır.
|
||||
|
||||
# ── En basit fonksiyon: parametresiz, değer döndürmeyen ───────
|
||||
fonksiyon ayrac():
|
||||
yazdir("─".tekrarla(44))
|
||||
|
||||
# ── Parametre almak ───────────────────────────────────────────
|
||||
# Çağırırken parantez içine verilen değer, parametrenin (ad) yerine geçer.
|
||||
fonksiyon selamla(ad):
|
||||
yazdir(f"Merhaba {ad}, hoş geldin.")
|
||||
|
||||
# ── Değer döndürmek: don ──────────────────────────────────────
|
||||
# don, sonucu çağıran yere geri verir ve fonksiyonu orada bitirir.
|
||||
# Parametre ve dönüş türünü yazmak zorunlu değil; yazarsan derleyici denetler:
|
||||
# dikdortgen_alani("üç", 4) yazan biri program çalışmadan uyarılır.
|
||||
fonksiyon dikdortgen_alani(en: sayi, boy: sayi) -> sayi:
|
||||
don en * boy
|
||||
|
||||
fonksiyon ortalama(a: ondalik, b: ondalik, c: ondalik) -> ondalik:
|
||||
don (a + b + c) / 3.0
|
||||
|
||||
# ── Varsayılan değerli parametre ──────────────────────────────
|
||||
# Çağıran kdv vermezse 20 kullanılır. Varsayılanlı parametreler en sona yazılır.
|
||||
fonksiyon kdvli_fiyat(fiyat: ondalik, kdv: sayi = 20) -> ondalik:
|
||||
don fiyat * (1.0 + ondalik(kdv) / 100.0)
|
||||
|
||||
# ── Mantık döndüren fonksiyon ve birden çok don ───────────────
|
||||
# Cevabı belli olduğu anda don ile çıkmak kodu sadeleştirir.
|
||||
fonksiyon asal_mi(n: sayi) -> mantik:
|
||||
eger n < 2:
|
||||
don yanlis
|
||||
bolen = 2
|
||||
iken bolen * bolen <= n:
|
||||
eger n % bolen == 0:
|
||||
don yanlis
|
||||
bolen += 1
|
||||
don dogru
|
||||
|
||||
# ── Fonksiyon başka bir fonksiyonu çağırabilir ────────────────
|
||||
fonksiyon asallari_yaz(baslangic: sayi, bitis: sayi):
|
||||
bulunan = ""
|
||||
dongu sayi_adayi icinde baslangic..bitis:
|
||||
eger asal_mi(sayi_adayi):
|
||||
bulunan = bulunan + f" {sayi_adayi}"
|
||||
yazdir(f"{baslangic}-{bitis} arası asallar:{bulunan}")
|
||||
|
||||
# ── Özyineleme: kendini çağıran fonksiyon ─────────────────────
|
||||
# n! = n × (n-1)! ve 1! = 1. Her çağrı problemi biraz küçültür;
|
||||
# n <= 1 olunca durur. Bu durma koşulu olmazsa fonksiyon kendini sonsuza dek çağırırdı.
|
||||
fonksiyon faktoriyel(n: sayi) -> sayi:
|
||||
eger n <= 1:
|
||||
don 1
|
||||
don n * faktoriyel(n - 1)
|
||||
|
||||
# Bir sayının basamakları toplamı: 4729 → 4 + 7 + 2 + 9 = 22
|
||||
# Son basamak n % 10, geri kalanı n // 10.
|
||||
fonksiyon basamak_toplami(n: sayi) -> sayi:
|
||||
eger n < 10:
|
||||
don n
|
||||
don n % 10 + basamak_toplami(n // 10)
|
||||
|
||||
|
||||
# ════════════════ Program buradan başlıyor ════════════════
|
||||
ayrac()
|
||||
selamla("Zeynep")
|
||||
selamla("Mehmet")
|
||||
ayrac()
|
||||
|
||||
yazdir(f"3 x 4 dikdörtgenin alanı: {dikdortgen_alani(3, 4)}")
|
||||
|
||||
# Fonksiyonun sonucu bir değişkene atanabilir ya da doğrudan kullanılabilir.
|
||||
ort = ortalama(72.0, 85.0, 90.0)
|
||||
yazdir(f"72, 85 ve 90'ın ortalaması: {ort:.2f}")
|
||||
|
||||
yazdir(f"100 TL, KDV %20 ile : {kdvli_fiyat(100.0):.2f} TL")
|
||||
yazdir(f"100 TL, KDV %10 ile : {kdvli_fiyat(100.0, 10):.2f} TL")
|
||||
# Parametreyi adıyla vermek, çok parametreli çağrıları okunur yapar.
|
||||
yazdir(f"100 TL, KDV %1 ile : {kdvli_fiyat(100.0, kdv=1):.2f} TL")
|
||||
ayrac()
|
||||
|
||||
dongu n icinde [1, 2, 17, 21, 97]:
|
||||
eger asal_mi(n):
|
||||
yazdir(f"{n} asaldır")
|
||||
degilse:
|
||||
yazdir(f"{n} asal değildir")
|
||||
asallari_yaz(50, 80)
|
||||
ayrac()
|
||||
|
||||
dongu n icinde 1..10:
|
||||
yazdir(f"{n:2}! = {faktoriyel(n):>9,}")
|
||||
yazdir(f"4729 sayısının basamakları toplamı: {basamak_toplami(4729)}")
|
||||
ayrac()
|
||||
@@ -0,0 +1,126 @@
|
||||
# Listeler: oluşturma, ekleme, silme, dilimleme, sıralama ve döngüyle gezme
|
||||
#
|
||||
# Liste, değerleri sırayla tutan bir kaptır. Köşeli parantezle yazılır,
|
||||
# öğeler virgülle ayrılır. Bir listedeki öğelerin hepsi aynı türde olmalıdır.
|
||||
|
||||
# Listeyi alan bir fonksiyon. Önemli bir ayrıntı: fonksiyona verilen liste
|
||||
# KOPYALANIR. Fonksiyon kendi kopyasını değiştirir; değişikliği görmek için
|
||||
# sonucu döndürüp yeniden atarız (aşağıda: notlar = yuvarla(notlar)).
|
||||
fonksiyon yuvarla(liste: liste<sayi>) -> liste<sayi>:
|
||||
i = 0
|
||||
iken i < liste.uzunluk():
|
||||
eger liste[i] % 5 != 0:
|
||||
liste[i] = liste[i] + (5 - liste[i] % 5) # bir üst 5'in katına
|
||||
i += 1
|
||||
don liste
|
||||
|
||||
|
||||
# ── Oluşturma ve okuma ────────────────────────────────────────
|
||||
meyveler = ["elma", "armut", "kiraz", "muz"]
|
||||
yazdir(f"Liste : {meyveler}")
|
||||
yazdir(f"Öğe sayısı : {meyveler.uzunluk()}")
|
||||
|
||||
# Öğelere sıra numarasıyla (indeks) ulaşılır. Sayma 0'dan başlar.
|
||||
# Negatif indeks sondan sayar: -1 son öğe, -2 sondan ikinci.
|
||||
yazdir(f"İlk öğe : {meyveler[0]}")
|
||||
yazdir(f"İkinci öğe : {meyveler[1]}")
|
||||
yazdir(f"Son öğe : {meyveler[-1]}")
|
||||
|
||||
# Bir öğe yerinde değiştirilebilir.
|
||||
meyveler[3] = "incir"
|
||||
yazdir(f"Değiştirdik : {meyveler}")
|
||||
yazdir()
|
||||
|
||||
# ── Ekleme, arama, silme ──────────────────────────────────────
|
||||
meyveler.ekle("üzüm") # sona ekler
|
||||
meyveler.ekle("çilek")
|
||||
yazdir(f"Ekledik : {meyveler}")
|
||||
|
||||
yazdir(f"kiraz var mı? : {meyveler.icerir('kiraz')}")
|
||||
yazdir(f"kirazın indeksi : {meyveler.bul('kiraz')}") # bul() indeksi verir
|
||||
yazdir(f"karpuzun indeksi : {meyveler.bul('karpuz')} (listede yoksa -1)")
|
||||
|
||||
# sil(i) i'NCİ SIRADAKİ öğeyi siler (değere göre değil, konuma göre).
|
||||
# Bir değeri silmek için önce bul() ile yerini buluruz.
|
||||
konum = meyveler.bul("armut")
|
||||
meyveler.sil(konum)
|
||||
yazdir(f"armut gitti : {meyveler}")
|
||||
yazdir()
|
||||
|
||||
# ── Dilimleme ─────────────────────────────────────────────────
|
||||
# l[a..b] a'dan b'ye kadar olan öğeleri yeni bir liste olarak verir (b dahil).
|
||||
# l.dilim(a, adet) a'dan başlayıp adet tane öğe alır.
|
||||
sayilar = [10, 20, 30, 40, 50, 60, 70]
|
||||
yazdir(f"sayilar[1..3] : {sayilar[1..3]}")
|
||||
yazdir(f"sayilar.dilim(4, 2) : {sayilar.dilim(4, 2)}")
|
||||
yazdir()
|
||||
|
||||
# ── Sıralama ──────────────────────────────────────────────────
|
||||
# sirala() listeyi yerinde, küçükten büyüğe dizer.
|
||||
# Metinler Türk alfabesine göre sıralanır: Ç, C'den sonra; İ, I'dan sonra gelir.
|
||||
isimler = ["Zeynep", "Ömer", "Can", "Çağla", "İlker", "Işıl", "Ahmet"]
|
||||
isimler.sirala()
|
||||
yazdir(f"Sıralı isimler : {isimler}")
|
||||
|
||||
# Ters çevirmek için listeyi sondan başa gezip yeni bir listeye ekleriz.
|
||||
ters = []
|
||||
i = isimler.uzunluk() - 1
|
||||
iken i >= 0:
|
||||
ters.ekle(isimler[i])
|
||||
i -= 1
|
||||
yazdir(f"Tersten : {ters}")
|
||||
|
||||
# birlestir(ayrac) metin listesini tek bir metne çevirir.
|
||||
yazdir(f"Virgülle : {isimler.birlestir(', ')}")
|
||||
yazdir()
|
||||
|
||||
# ── Döngüyle gezme ve hesap ───────────────────────────────────
|
||||
notlar = [72, 95, 48, 88, 61, 79, 53]
|
||||
|
||||
# Sıra numarası gerekiyorsa indeksle geziyoruz.
|
||||
i = 0
|
||||
iken i < notlar.uzunluk():
|
||||
yazdir(f" {i + 1}. öğrenci: {notlar[i]}")
|
||||
i += 1
|
||||
|
||||
# Toplam, en büyük ve en küçük: hepsini tek bir döngüde bulabiliriz.
|
||||
toplam = 0
|
||||
en_yuksek = notlar[0]
|
||||
en_dusuk = notlar[0]
|
||||
dongu n icinde notlar:
|
||||
toplam += n
|
||||
eger n > en_yuksek:
|
||||
en_yuksek = n
|
||||
eger n < en_dusuk:
|
||||
en_dusuk = n
|
||||
yazdir(f"Toplam {toplam}, ortalama {toplam / notlar.uzunluk():.1f}, en yüksek {en_yuksek}, en düşük {en_dusuk}")
|
||||
|
||||
# Boş bir listeyle başlayıp koşula uyanları toplamak çok sık yapılan bir iştir.
|
||||
gecenler = []
|
||||
kalanlar = []
|
||||
dongu n icinde notlar:
|
||||
eger n >= 60:
|
||||
gecenler.ekle(n)
|
||||
degilse:
|
||||
kalanlar.ekle(n)
|
||||
yazdir(f"Geçenler ({gecenler.uzunluk()}): {gecenler}")
|
||||
yazdir(f"Kalanlar ({kalanlar.uzunluk()}): {kalanlar}")
|
||||
yazdir()
|
||||
|
||||
# ── Fonksiyona liste vermek ───────────────────────────────────
|
||||
yuvarlanmis = yuvarla(notlar)
|
||||
yazdir(f"Yuvarlanmış kopya : {yuvarlanmis}")
|
||||
yazdir(f"Asıl liste : {notlar} (değişmedi)")
|
||||
notlar = yuvarla(notlar)
|
||||
yazdir(f"Yeniden atayınca : {notlar}")
|
||||
yazdir()
|
||||
|
||||
# ── Liste içinde liste: tablo ─────────────────────────────────
|
||||
# Her satır bir liste; tablo[satır][sütun] diye okunur.
|
||||
tablo = [[3, 8, 1], [9, 4, 7], [2, 6, 5]]
|
||||
dongu satir icinde tablo:
|
||||
satir_toplami = 0
|
||||
dongu hucre icinde satir:
|
||||
satir_toplami += hucre
|
||||
yazdir(f" {satir} → satır toplamı {satir_toplami}")
|
||||
yazdir(f"Ortadaki hücre tablo[1][1] = {tablo[1][1]}")
|
||||
@@ -0,0 +1,102 @@
|
||||
# Sözlükler: anahtar-değer çiftleri, ekleme, sorgulama, gezme ve kelime sayımı
|
||||
#
|
||||
# Sözlük, her değeri bir anahtarla eşleştiren kaptır. Listede öğeye sıra
|
||||
# numarasıyla ulaşırken sözlükte anahtarla ulaşırız: plaka["Ankara"] gibi.
|
||||
# Süslü parantezle yazılır: {anahtar: değer, anahtar: değer}.
|
||||
|
||||
# ── Oluşturma ve okuma ────────────────────────────────────────
|
||||
plaka = {"İstanbul": 34, "Ankara": 6, "İzmir": 35}
|
||||
yazdir(f"Sözlük : {plaka}")
|
||||
yazdir(f"Ankara'nın plakası : {plaka['Ankara']:02}")
|
||||
yazdir(f"Kaç şehir var : {plaka.uzunluk()}")
|
||||
yazdir()
|
||||
|
||||
# ── Ekleme ve güncelleme ──────────────────────────────────────
|
||||
# Olmayan bir anahtara değer atamak yeni çift ekler; var olana atamak değeri değiştirir.
|
||||
plaka["Bursa"] = 16
|
||||
plaka["Trabzon"] = 61
|
||||
plaka["İzmir"] = 35
|
||||
yazdir(f"Eklemeden sonra: {plaka}")
|
||||
|
||||
# ── Sorgulama ─────────────────────────────────────────────────
|
||||
# Sözlükte olmayan bir anahtarı okumak programı hatayla durdurur.
|
||||
# Emin değilsek önce var_mi() ile soruyoruz.
|
||||
dongu sehir icinde ["Trabzon", "Konya"]:
|
||||
eger plaka.var_mi(sehir):
|
||||
yazdir(f"{sehir}: {plaka[sehir]}")
|
||||
degilse:
|
||||
yazdir(f"{sehir}: sözlükte yok")
|
||||
|
||||
# ── Silme ─────────────────────────────────────────────────────
|
||||
# Sözlükte sil() ANAHTARA göre siler (listede konuma göre silerdi).
|
||||
plaka.sil("Bursa")
|
||||
yazdir(f"Bursa silindi, kalan {plaka.uzunluk()} şehir")
|
||||
yazdir()
|
||||
|
||||
# ── Gezme ─────────────────────────────────────────────────────
|
||||
# anahtarlar() bütün anahtarları bir liste olarak verir.
|
||||
# Bu liste eklenme sırasında değildir; harflerin bilgisayardaki kod sırasına
|
||||
# göre dizilir ve bu sırada İ, Ş, Ö gibi harfler Z'den sonra gelir (yukarıda
|
||||
# Trabzon, İstanbul'dan önce yazıldı). Türk alfabesine göre gezmek için
|
||||
# anahtar listesini alıp sirala() ile sıralıyoruz.
|
||||
sehirler = plaka.anahtarlar()
|
||||
sehirler.sirala()
|
||||
yazdir("Şehir Plaka")
|
||||
dongu sehir icinde sehirler:
|
||||
yazdir(f"{sehir:<12}{plaka[sehir]:>5}")
|
||||
yazdir()
|
||||
|
||||
# ── Metinden metne sözlük: küçük bir sözlük uygulaması ────────
|
||||
ingilizce = {
|
||||
"kitap": "book",
|
||||
"kalem": "pencil",
|
||||
"okul": "school",
|
||||
"öğretmen": "teacher"
|
||||
}
|
||||
cumle = ["öğretmen", "okul", "kitap", "defter"]
|
||||
ceviri = []
|
||||
dongu kelime icinde cumle:
|
||||
eger ingilizce.var_mi(kelime):
|
||||
ceviri.ekle(ingilizce[kelime])
|
||||
degilse:
|
||||
ceviri.ekle(f"?{kelime}?") # bilinmeyen kelimeyi işaretle
|
||||
yazdir(f"{cumle.birlestir(' ')} → {ceviri.birlestir(' ')}")
|
||||
yazdir()
|
||||
|
||||
# ── Sayım: hangi kelime kaç kez geçiyor? ──────────────────────
|
||||
# Sözlüğün en sık kullanıldığı iş budur. Her kelime için:
|
||||
# daha önce gördüysek sayısını bir artırırız, görmediysek 1 ile başlatırız.
|
||||
metin_parcasi = "bir elma bir armut iki elma bir kiraz üç elma iki armut"
|
||||
sayim = {}
|
||||
dongu kelime icinde metin_parcasi.bol(" "):
|
||||
eger sayim.var_mi(kelime):
|
||||
sayim[kelime] = sayim[kelime] + 1
|
||||
degilse:
|
||||
sayim[kelime] = 1
|
||||
|
||||
yazdir(f"Metin: \"{metin_parcasi}\"")
|
||||
yazdir(f"{sayim.uzunluk()} farklı kelime bulundu:")
|
||||
|
||||
# En sık geçen kelimeyi de aynı gezintide bulalım.
|
||||
# Eşitlik olursa ilk karşılaşılan kalır, çünkü yalnız daha BÜYÜK adet yerini alır.
|
||||
en_sik = ""
|
||||
en_cok = 0
|
||||
dongu kelime icinde sayim.anahtarlar():
|
||||
adet = sayim[kelime]
|
||||
# Her kelime için adedi kadar ▇ çizerek küçük bir çubuk grafik yapıyoruz.
|
||||
yazdir(f" {kelime:<7}{adet:>2} " + "▇".tekrarla(adet))
|
||||
eger adet > en_cok:
|
||||
en_cok = adet
|
||||
en_sik = kelime
|
||||
yazdir(f"En sık geçen: \"{en_sik}\" ({en_cok} kez)")
|
||||
yazdir()
|
||||
|
||||
# ── Not defteri: öğrenci → not ────────────────────────────────
|
||||
notlar = {"Ayşe": 88, "Mehmet": 64, "Elif": 92, "Can": 47, "Deniz": 75}
|
||||
toplam = 0
|
||||
gecen = 0
|
||||
dongu ogrenci icinde notlar.anahtarlar():
|
||||
toplam += notlar[ogrenci]
|
||||
eger notlar[ogrenci] >= 50:
|
||||
gecen += 1
|
||||
yazdir(f"Sınıf ortalaması {toplam / notlar.uzunluk():.1f}; {notlar.uzunluk()} öğrenciden {gecen} kişi geçti.")
|
||||
@@ -0,0 +1,98 @@
|
||||
# Metinler: Türkçe büyük/küçük harf, bölme, birleştirme, arama ve uzunluk
|
||||
#
|
||||
# Metin (string) bir harf dizisidir. KabaLang metinleri Türkçe kurallara göre
|
||||
# işler: "i" büyüyünce "İ", "I" küçülünce "ı" olur. Birçok dilde bu yanlış çalışır.
|
||||
|
||||
# Bir metni tersine çeviren fonksiyon: harfleri tek tek gezip her birini başa ekler.
|
||||
fonksiyon ters_cevir(m: metin) -> metin:
|
||||
sonuc = ""
|
||||
dongu harf icinde m:
|
||||
sonuc = harf + sonuc
|
||||
don sonuc
|
||||
|
||||
# Boşlukları ve büyük/küçük farkını atınca tersi kendisine eşit mi?
|
||||
fonksiyon palindrom_mu(m: metin) -> mantik:
|
||||
sade = m.kucult().degistir(" ", "")
|
||||
don sade == ters_cevir(sade)
|
||||
|
||||
|
||||
# ── Türkçe büyük/küçük harf ───────────────────────────────────
|
||||
sehir = "istanbul"
|
||||
yazdir(f"\"{sehir}\".buyut() → {sehir.buyut()}")
|
||||
yazdir(f"\"IĞDIR\".kucult() → {'IĞDIR'.kucult()}")
|
||||
yazdir(f"\"ılık İğne\".buyut() → {'ılık İğne'.buyut()}")
|
||||
yazdir(f"\"ŞİŞLİ ÖĞÜT\".kucult() → {'ŞİŞLİ ÖĞÜT'.kucult()}")
|
||||
|
||||
# Büyük/küçük harfe aldırmadan karşılaştırmak için iki tarafı da küçültürüz.
|
||||
girilen = "İZMİR"
|
||||
eger girilen.kucult() == "izmir":
|
||||
yazdir(f"\"{girilen}\" ile \"izmir\" aynı şehir")
|
||||
yazdir()
|
||||
|
||||
# ── Uzunluk ve harflere erişim ────────────────────────────────
|
||||
# uzunluk() harf sayısını verir; ş, ğ, İ gibi harfler de tek harf sayılır.
|
||||
kelime = "Şanlıurfa"
|
||||
yazdir(f"\"{kelime}\" {kelime.uzunluk()} harf")
|
||||
yazdir(f"İlk harf: {kelime[0]}, son harf: {kelime[-1]}, 0..3 arası: {kelime[0..3]}")
|
||||
yazdir(f"bastan(5): {kelime.bastan(5)}, sondan(4): {kelime.sondan(4)}, dilim(2, 3): {kelime.dilim(2, 3)}")
|
||||
yazdir()
|
||||
|
||||
# ── Temizleme, arama, değiştirme ──────────────────────────────
|
||||
# kirp() baştaki ve sondaki boşlukları siler; kullanıcı girdisinde çok işe yarar.
|
||||
ham = " Merhaba Dünya "
|
||||
yazdir(f"[{ham}] → [{ham.kirp()}]")
|
||||
|
||||
cumle = "Ankara Türkiye'nin başkentidir"
|
||||
yazdir(f"\"başkent\" geçiyor mu? {cumle.icerir('başkent')}")
|
||||
yazdir(f"\"Ankara\" ile mi başlıyor? {cumle.ile_baslar('Ankara')}")
|
||||
yazdir(f"\"dir\" ile mi bitiyor? {cumle.ile_biter('dir')}")
|
||||
yazdir(f"\"Türkiye\" hangi konumda başlıyor? {cumle.bul('Türkiye')} (0'dan sayarak; yoksa -1)")
|
||||
yazdir(f"Değiştir: {cumle.degistir('Ankara', 'Bursa').degistir('başkentidir', 'dördüncü büyük şehridir')}")
|
||||
yazdir()
|
||||
|
||||
# ── Bölme ve birleştirme ──────────────────────────────────────
|
||||
# bol(ayrac) metni parçalara ayırıp liste verir; birlestir(ayrac) tersini yapar.
|
||||
satir = "Ayşe;Kaya;Eskişehir;34"
|
||||
alanlar = satir.bol(";")
|
||||
yazdir(f"Bölündü : {alanlar} ({alanlar.uzunluk()} parça)")
|
||||
yazdir(f"Ad soyad: {alanlar[0]} {alanlar[1].buyut()}")
|
||||
yazdir(f"Birleşti: {alanlar.birlestir(' | ')}")
|
||||
|
||||
# Bir cümleyi kelimelere ayırıp her kelimenin ilk harfini büyütelim.
|
||||
baslik = "yaşlı ırmak ile genç irmik"
|
||||
kelimeler = baslik.bol(" ")
|
||||
duzgun = []
|
||||
dongu k icinde kelimeler:
|
||||
duzgun.ekle(k.bastan(1).buyut() + k.dilim(1, k.uzunluk() - 1))
|
||||
yazdir(f"Başlık biçimi: {duzgun.birlestir(' ')}")
|
||||
yazdir()
|
||||
|
||||
# ── Harf harf gezme ───────────────────────────────────────────
|
||||
# dongu harf icinde metin: her turda bir harf gelir.
|
||||
metin_ornegi = "Çalışkan öğrenciler ödevlerini erken bitirir"
|
||||
unlu = 0
|
||||
bosluk = 0
|
||||
dongu harf icinde metin_ornegi.kucult():
|
||||
eger "aeıioöuü".icerir(harf):
|
||||
unlu += 1
|
||||
degilse eger harf == " ":
|
||||
bosluk += 1
|
||||
yazdir(f"\"{metin_ornegi}\"")
|
||||
yazdir(f" {metin_ornegi.uzunluk()} karakter, {unlu} ünlü, {bosluk + 1} kelime")
|
||||
|
||||
dongu aday icinde ["Ey Edip Adanada pide ye", "Kayak", "Kalem"]:
|
||||
eger palindrom_mu(aday):
|
||||
yazdir(f" \"{aday}\" tersten de aynı okunur")
|
||||
degilse:
|
||||
yazdir(f" \"{aday}\" tersten \"{ters_cevir(aday)}\" olur")
|
||||
yazdir()
|
||||
|
||||
# ── Tekrarlama ve hizalama ────────────────────────────────────
|
||||
# tekrarla(n) metni n kez yan yana koyar. f-string içinde
|
||||
# {x:<10} sola, {x:>10} sağa, {x:^10} ortaya yaslar.
|
||||
yazdir("=".tekrarla(32))
|
||||
yazdir(f"{'ŞEHİR':^32}")
|
||||
yazdir("=".tekrarla(32))
|
||||
dongu ad icinde ["Rize", "Muğla", "Çanakkale"]:
|
||||
yazdir(f"{ad:<14}|{ad.buyut():>17}")
|
||||
yazdir("=".tekrarla(32))
|
||||
@@ -0,0 +1,132 @@
|
||||
# Yapılar ve sınıflar: kendi türünü tanımlamak, metotlar ve nesne listeleri
|
||||
#
|
||||
# Bir kitabın adı, yazarı, sayfa sayısı ve yılı birbirine aittir. Bunları dört
|
||||
# ayrı değişkende tutmak yerine tek bir "Kitap" türünde toplarız.
|
||||
# yapi : ilgili verileri (alanları) ve onlarla çalışan fonksiyonları bir arada tutar
|
||||
# sinif : yapıya ek olarak kurucu (kur) ve self ile çalışan metotlar sunar
|
||||
|
||||
# ── yapi: alanlar ve metotlar ─────────────────────────────────
|
||||
# Her alana bir varsayılan değer verilir; alanın türü bu değerden anlaşılır.
|
||||
# Yapının içindeki fonksiyonlara metot denir. Metotlar alanlara doğrudan adıyla ulaşır.
|
||||
yapi Kitap:
|
||||
ad = ""
|
||||
yazar = ""
|
||||
sayfa = 0
|
||||
yil = 0
|
||||
|
||||
fonksiyon ozet() -> metin:
|
||||
don f"{ad} ({yazar}, {yil})"
|
||||
|
||||
fonksiyon okuma_suresi(gunluk_sayfa: sayi) -> sayi:
|
||||
# Kalan sayfaları da saymak için yukarı yuvarlıyoruz.
|
||||
don (sayfa + gunluk_sayfa - 1) // gunluk_sayfa
|
||||
|
||||
# ── sayilabilir: sınırlı seçenekler ───────────────────────────
|
||||
# Bir değişken yalnız belli değerleri alabiliyorsa sayilabilir kullanılır.
|
||||
# Yanlış yazılan bir üye (Durum.KAYIP gibi) program çalışmadan yakalanır.
|
||||
sayilabilir Durum:
|
||||
RAFTA
|
||||
ODUNCTE
|
||||
|
||||
# ── sinif: kurucu ve self ─────────────────────────────────────
|
||||
# kur(self, ...) nesne oluşturulurken çalışır. self "bu nesnenin kendisi" demektir;
|
||||
# self.ad, bu okuyucunun adı alanıdır.
|
||||
sinif Okuyucu:
|
||||
ad = ""
|
||||
okunan_sayfa = 0
|
||||
kitap_sayisi = 0
|
||||
|
||||
fonksiyon kur(self, ad_: metin):
|
||||
self.ad = ad_
|
||||
|
||||
# Metot nesnenin kendi alanlarını değiştirir; değişiklik kalıcıdır.
|
||||
fonksiyon bitirdi(self, k: Kitap):
|
||||
self.okunan_sayfa = self.okunan_sayfa + k.sayfa
|
||||
self.kitap_sayisi = self.kitap_sayisi + 1
|
||||
|
||||
fonksiyon rapor(self) -> metin:
|
||||
don f"{self.ad}: {self.kitap_sayisi} kitap, toplam {self.okunan_sayfa} sayfa"
|
||||
|
||||
|
||||
# ════════════════ Program buradan başlıyor ════════════════
|
||||
|
||||
# ── Nesne oluşturmak ──────────────────────────────────────────
|
||||
# Yol 1: boş nesne oluşturup alanları tek tek doldurmak.
|
||||
k1 = Kitap()
|
||||
k1.ad = "Çalıkuşu"
|
||||
k1.yazar = "Reşat Nuri Güntekin"
|
||||
k1.sayfa = 544
|
||||
k1.yil = 1922
|
||||
|
||||
# Yol 2: alanları tanım sırasıyla vermek (ad, yazar, sayfa, yil).
|
||||
k2 = Kitap("Kuyucaklı Yusuf", "Sabahattin Ali", 232, 1937)
|
||||
|
||||
yazdir(k1.ozet())
|
||||
yazdir(k2.ozet())
|
||||
yazdir(f"{k2.ad} günde 20 sayfayla {k2.okuma_suresi(20)} günde biter.")
|
||||
|
||||
# Yapıyı doğrudan yazdırınca bütün alanları görünür.
|
||||
yazdir(k2)
|
||||
yazdir()
|
||||
|
||||
# ── Nesne listesi ─────────────────────────────────────────────
|
||||
raf = [k1, k2]
|
||||
raf.ekle(Kitap("İnce Memed", "Yaşar Kemal", 436, 1955))
|
||||
raf.ekle(Kitap("Tutunamayanlar", "Oğuz Atay", 724, 1972))
|
||||
raf.ekle(Kitap("Saatleri Ayarlama Enstitüsü", "Ahmet Hamdi Tanpınar", 382, 1961))
|
||||
|
||||
yazdir(f"{'Kitap':<30}{'Yazar':<22}{'Yıl':>5}{'Sayfa':>7}")
|
||||
yazdir("─".tekrarla(64))
|
||||
dongu k icinde raf:
|
||||
yazdir(f"{k.ad:<30}{k.yazar:<22}{k.yil:>5}{k.sayfa:>7}")
|
||||
yazdir()
|
||||
|
||||
# Listedeki nesnelerin alanlarıyla hesap: en kalın kitap ve toplam sayfa.
|
||||
en_kalin = raf[0]
|
||||
toplam_sayfa = 0
|
||||
dongu k icinde raf:
|
||||
toplam_sayfa += k.sayfa
|
||||
eger k.sayfa > en_kalin.sayfa:
|
||||
en_kalin = k
|
||||
yazdir(f"Raftaki {raf.uzunluk()} kitap toplam {toplam_sayfa:,} sayfa.")
|
||||
yazdir(f"En kalını: {en_kalin.ozet()}, {en_kalin.sayfa} sayfa")
|
||||
|
||||
# Yıla göre sıralama: her adımda kalan kitapların en eskisini öne alıyoruz (seçmeli sıralama).
|
||||
i = 0
|
||||
iken i < raf.uzunluk():
|
||||
en_eski = i
|
||||
j = i + 1
|
||||
iken j < raf.uzunluk():
|
||||
eger raf[j].yil < raf[en_eski].yil:
|
||||
en_eski = j
|
||||
j += 1
|
||||
gecici = raf[i]
|
||||
raf[i] = raf[en_eski]
|
||||
raf[en_eski] = gecici
|
||||
i += 1
|
||||
|
||||
yazdir("Yayın yılına göre:")
|
||||
dongu k icinde raf:
|
||||
yazdir(f" {k.yil} {k.ad}")
|
||||
yazdir()
|
||||
|
||||
# ── sayilabilir değerlerle çalışmak ───────────────────────────
|
||||
durum = Durum.RAFTA
|
||||
yazdir(f"{k2.ad}: {durum}")
|
||||
durum = Durum.ODUNCTE
|
||||
eger durum == Durum.ODUNCTE:
|
||||
yazdir(f"{k2.ad} şu an ödünç verildi.")
|
||||
yazdir()
|
||||
|
||||
# ── Sınıf nesnesiyle çalışmak ─────────────────────────────────
|
||||
# Okuyucu("Elif") yazınca kur(self, "Elif") çağrılır.
|
||||
elif = Okuyucu("Elif")
|
||||
emre = Okuyucu("Emre")
|
||||
|
||||
elif.bitirdi(raf[0])
|
||||
elif.bitirdi(raf[2])
|
||||
emre.bitirdi(raf[4])
|
||||
|
||||
# Her nesnenin kendi alanları vardır; Elif'in okuduğu Emre'yi etkilemez.
|
||||
yazdir(elif.rapor())
|
||||
yazdir(emre.rapor())
|
||||
@@ -0,0 +1,116 @@
|
||||
# Hatalar: sonuc türüyle beklenen hatalar, ? ile yayma, dene/yakala/firlat
|
||||
#
|
||||
# Programlar her zaman yolunda gitmez: kullanıcı yanlış değer girer, bir sayı
|
||||
# sıfıra bölünür, listede olmayan bir sıra istenir. KabaLang'de iki yol vardır:
|
||||
# sonuc<T, Hata> : beklenebilir hatalar için. Fonksiyon ya başarıyı (tamam)
|
||||
# ya da hatayı (hata) döndürür; çağıran ikisini de ele almak zorundadır.
|
||||
# dene / yakala / firlat : programın o noktada devam edemeyeceği durumlar için.
|
||||
|
||||
# ── sonuc: başarı ya da hata döndüren fonksiyon ───────────────
|
||||
# Dönüş türü sonuc<sayi, Hata>: başarıda bir sayı, başarısızlıkta bir hata taşır.
|
||||
fonksiyon yas_coz(girdi: metin) -> sonuc<sayi, Hata>:
|
||||
temiz = girdi.kirp()
|
||||
eger temiz.bos_mu():
|
||||
don hata("yaş boş bırakılamaz")
|
||||
# Her karakter bir rakam mı?
|
||||
dongu harf icinde temiz:
|
||||
eger degil "0123456789".icerir(harf):
|
||||
don hata(f"'{temiz}' bir sayı değil")
|
||||
yas = sayi(temiz)
|
||||
eger yas > 130:
|
||||
don hata(f"{yas} yaş gerçekçi değil")
|
||||
don tamam(yas)
|
||||
|
||||
# ── ?: hatayı yukarı iletmek ──────────────────────────────────
|
||||
# yas_coz(...)? şunu der: sonuç hataysa bu fonksiyondan da AYNI hatayla hemen çık;
|
||||
# başarılıysa içindeki sayıyı ver. Her adımda eger yazmaktan kurtarır.
|
||||
# ? yalnız kendisi de sonuc döndüren bir fonksiyonun içinde kullanılabilir.
|
||||
fonksiyon yas_farki(birinci: metin, ikinci: metin) -> sonuc<sayi, Hata>:
|
||||
a = yas_coz(birinci)?
|
||||
b = yas_coz(ikinci)?
|
||||
eger a > b:
|
||||
don tamam(a - b)
|
||||
don tamam(b - a)
|
||||
|
||||
# ── firlat: devam edilemeyen durum ────────────────────────────
|
||||
# firlat çalışınca fonksiyon orada biter; hata, onu yakalayan ilk dene bloğuna kadar çıkar.
|
||||
fonksiyon stoktan_dus(stok: sayi, adet: sayi) -> sayi:
|
||||
eger adet <= 0:
|
||||
firlat hata(f"geçersiz adet: {adet}")
|
||||
eger adet > stok:
|
||||
firlat hata(f"stokta {stok} ürün var, {adet} istendi")
|
||||
don stok - adet
|
||||
|
||||
fonksiyon yesil(m: metin) -> metin:
|
||||
don "\033[32m" + m + "\033[0m"
|
||||
|
||||
fonksiyon kirmizi(m: metin) -> metin:
|
||||
don "\033[31m" + m + "\033[0m"
|
||||
|
||||
|
||||
# ════════════════ Program buradan başlıyor ════════════════
|
||||
|
||||
# ── sonuc'u kullanmak ─────────────────────────────────────────
|
||||
yazdir("Yaş girdilerini denetleyelim:")
|
||||
dongu girdi icinde ["34", " 7 ", "", "otuz", "250"]:
|
||||
r = yas_coz(girdi)
|
||||
# tamam_mi() / hatali_mi() hangisi olduğunu söyler.
|
||||
# deger() başarıdaki sayıyı, hata().mesaj() hatanın açıklamasını verir.
|
||||
eger r.tamam_mi():
|
||||
yazdir(yesil(" ✓ ") + f"\"{girdi}\" → {r.deger()} yaş")
|
||||
degilse:
|
||||
yazdir(kirmizi(" ✗ ") + f"\"{girdi}\" → {r.hata().mesaj()}")
|
||||
|
||||
# sonuc döndüren bir fonksiyonu çağırıp sonucu hiç kullanmamak derleme hatasıdır:
|
||||
# yas_coz("12") tek başına bir satırda yazılırsa program derlenmez.
|
||||
# Sonucu bilerek atmak istiyorsan bunu açıkça yazarsın: _ = yas_coz("12")
|
||||
yazdir()
|
||||
|
||||
yazdir("Yaş farkları:")
|
||||
dongu ikili icinde [["40", "12"], ["40", "kırk"], ["", "12"]]:
|
||||
f = yas_farki(ikili[0], ikili[1])
|
||||
eger f.tamam_mi():
|
||||
yazdir(f" {ikili[0]} ile {ikili[1]} arası {f.deger()} yıl")
|
||||
degilse:
|
||||
yazdir(f" hesaplanamadı: {f.hata().mesaj()}")
|
||||
yazdir()
|
||||
|
||||
# ── dene / yakala ─────────────────────────────────────────────
|
||||
# dene bloğunda bir hata fırlatılırsa blok orada kesilir ve yakala bloğu çalışır.
|
||||
# yakala h: hata metnini h adıyla verir. Hata olmazsa yakala hiç çalışmaz.
|
||||
stok = 10
|
||||
dongu istek icinde [3, 4, 0, 5]:
|
||||
dene:
|
||||
stok = stoktan_dus(stok, istek)
|
||||
yazdir(f" {istek} adet satıldı, stokta {stok} kaldı")
|
||||
yakala h:
|
||||
yazdir(kirmizi(" satış yapılamadı: ") + h)
|
||||
yazdir()
|
||||
|
||||
# ── Dilin kendi fırlattığı hatalar ────────────────────────────
|
||||
# Sıfıra bölme, listede olmayan bir sıra, sözlükte olmayan bir anahtar...
|
||||
# Yakalanmazlarsa program bu satırda durur. Yakalanırlarsa program devam eder.
|
||||
# Hata metni dosya adını ve satır numarasını da içerir; hatayı bulmanın ilk ipucu budur.
|
||||
bolen = 0
|
||||
dene:
|
||||
yazdir(100 // bolen)
|
||||
yakala h:
|
||||
yazdir("Bölme hatası yakalandı:")
|
||||
yazdir(f" {h}")
|
||||
|
||||
sehirler = ["Rize", "Artvin"]
|
||||
dene:
|
||||
yazdir(sehirler[5])
|
||||
yakala h:
|
||||
yazdir("Liste hatası yakalandı:")
|
||||
yazdir(f" {h}")
|
||||
|
||||
# yakala'dan sonra ad yazmazsak hata metni kullanılmaz, yalnız yakalanır.
|
||||
basarili = dogru
|
||||
dene:
|
||||
firlat "bağlantı kurulamadı"
|
||||
yakala:
|
||||
basarili = yanlis
|
||||
yazdir(f"İşlem başarılı mı? {basarili}")
|
||||
yazdir()
|
||||
yazdir("Bütün hatalar ele alındı; program sonuna kadar çalıştı.")
|
||||
@@ -0,0 +1,107 @@
|
||||
# Dosyalar: metin ve JSON dosyasına yazmak, dosyayı geri okuyup işlemek
|
||||
#
|
||||
# Program bittiğinde değişkenlerdeki her şey kaybolur. Bilgiyi saklamak için
|
||||
# dosyaya yazarız; program bir sonraki çalışmada onu geri okuyabilir.
|
||||
# Bu ders çalıştığı klasörde iki dosya oluşturur: alisveris.txt ve sinif.json.
|
||||
# Program bitince dosyalar yerinde kalır; açıp içlerine bakabilirsin.
|
||||
|
||||
kullan kaba.sistem
|
||||
|
||||
degismez LISTE_DOSYASI = "alisveris.txt"
|
||||
degismez JSON_DOSYASI = "sinif.json"
|
||||
|
||||
# ── 1. Metin dosyasına yazmak ─────────────────────────────────
|
||||
# dosya.yaz(yol, metin) dosyayı oluşturur; dosya zaten varsa içeriğini SİLİP yeniden yazar.
|
||||
# Her satırın sonuna \n koyuyoruz; yoksa bütün satırlar yan yana birleşirdi.
|
||||
# Satır biçimimiz: ürün;adet;birim fiyat
|
||||
dosya.yaz(LISTE_DOSYASI, "ekmek;2;12.50\n")
|
||||
|
||||
# dosya.ekle(yol, metin) var olan içeriğe dokunmadan sonuna ekler.
|
||||
dosya.ekle(LISTE_DOSYASI, "süt;1;34.90\n")
|
||||
dosya.ekle(LISTE_DOSYASI, "domates;3;18.75\n")
|
||||
dosya.ekle(LISTE_DOSYASI, "peynir;1;149.00\n")
|
||||
|
||||
yazdir(f"{LISTE_DOSYASI} yazıldı: {dosya.boyut(LISTE_DOSYASI)} bayt")
|
||||
|
||||
# ── 2. Metin dosyasını okumak ─────────────────────────────────
|
||||
# dosya.oku(yol) bütün dosyayı tek bir metin olarak verir.
|
||||
# Olmayan bir dosyayı okumak hata vermez, boş metin döner; bu yüzden önce var_mi() ile soruyoruz.
|
||||
eger dosya.var_mi(LISTE_DOSYASI):
|
||||
icerik = dosya.oku(LISTE_DOSYASI)
|
||||
|
||||
# kirp() sondaki \n'yi atar, bol("\n") metni satırlara ayırır.
|
||||
satirlar = icerik.kirp().bol("\n")
|
||||
yazdir(f"{satirlar.uzunluk()} satır okundu:")
|
||||
yazdir()
|
||||
|
||||
toplam = 0.0
|
||||
yazdir(f" {'Ürün':<10}{'Adet':>5}{'Fiyat':>9}{'Tutar':>10}")
|
||||
yazdir(" " + "─".tekrarla(34))
|
||||
dongu satir icinde satirlar:
|
||||
# Her satırı ; işaretinden bölüp parçaları uygun türe çeviriyoruz.
|
||||
parca = satir.bol(";")
|
||||
urun = parca[0]
|
||||
adet = sayi(parca[1])
|
||||
fiyat = ondalik(parca[2])
|
||||
tutar = adet * fiyat
|
||||
toplam += tutar
|
||||
yazdir(f" {urun:<10}{adet:>5}{fiyat:>9.2f}{tutar:>10.2f}")
|
||||
yazdir(" " + "─".tekrarla(34))
|
||||
yazdir(f" {'Toplam':<24}{toplam:>10.2f} TL")
|
||||
yazdir()
|
||||
|
||||
eger degil dosya.var_mi("olmayan-dosya.txt"):
|
||||
yazdir("olmayan-dosya.txt bulunamadı (beklenen durum).")
|
||||
yazdir()
|
||||
|
||||
# ── 3. JSON dosyasına yazmak ──────────────────────────────────
|
||||
# JSON, sözlük ve listeleri metne dönüştürmenin yaygın bir biçimidir; başka
|
||||
# programlar ve diller de okuyabilir. Önce bilgiyi sözlüklerle kuruyoruz.
|
||||
ogrenciler = {}
|
||||
ogrenciler["Ayşe"] = {"not": 88, "sehir": "Eskişehir"}
|
||||
ogrenciler["Mehmet"] = {"not": 64, "sehir": "Konya"}
|
||||
ogrenciler["Elif"] = {"not": 92, "sehir": "Trabzon"}
|
||||
ogrenciler["Can"] = {"not": 47, "sehir": "Mersin"}
|
||||
|
||||
# Adı "sinif" koyamıyoruz: sinif dilin anahtar sözcüğü, değişken adı olamaz.
|
||||
sinif_bilgisi = {"ad": "9-A", "ogretmen": "Deniz Arslan", "ogrenciler": ogrenciler}
|
||||
|
||||
# json.uret(sozluk, dogru) okunaklı, girintili bir JSON metni üretir.
|
||||
# (İkinci değer yazılmazsa her şey tek satıra sıkıştırılır.)
|
||||
# Anahtarlar dosyaya alfabetik sırayla yazılır.
|
||||
json_metni = json.uret(sinif_bilgisi, dogru)
|
||||
dosya.yaz(JSON_DOSYASI, json_metni)
|
||||
yazdir(f"{JSON_DOSYASI} yazıldı. İçeriği:")
|
||||
yazdir(json_metni)
|
||||
|
||||
# ── 4. JSON dosyasını geri okumak ─────────────────────────────
|
||||
okunan = dosya.oku(JSON_DOSYASI)
|
||||
|
||||
# Bozuk bir dosyayı çözmeye kalkmadan önce geçerli JSON olup olmadığını soruyoruz.
|
||||
eger json.gecerli_mi(okunan):
|
||||
veri = json.coz(okunan)
|
||||
|
||||
# Çözülen veride anahtarlarla iç içe ilerlenir: veri["ogrenciler"]["Elif"]["not"].
|
||||
# JSON'dan gelen değerin türü derleme anında bilinmez; sayi() ve metin() ile
|
||||
# hangi türde kullanacağımızı açıkça söylüyoruz.
|
||||
yazdir(f"Sınıf {metin(veri['ad'])}, öğretmen {metin(veri['ogretmen'])}")
|
||||
|
||||
toplam_not = 0
|
||||
sayac = 0
|
||||
dongu ad icinde veri["ogrenciler"].anahtarlar():
|
||||
kayit = veri["ogrenciler"][ad]
|
||||
notu = sayi(kayit["not"])
|
||||
toplam_not += notu
|
||||
sayac += 1
|
||||
durum = "geçti"
|
||||
eger notu < 50:
|
||||
durum = "kaldı"
|
||||
yazdir(f" {ad:<8}{metin(kayit['sehir']):<11}{notu:>4} {durum}")
|
||||
yazdir(f"Ortalama: {toplam_not / sayac:.1f}")
|
||||
degilse:
|
||||
yazdir(f"{JSON_DOSYASI} geçerli bir JSON değil.")
|
||||
|
||||
# Bozuk JSON örneği: süslü parantez kapanmamış.
|
||||
bozuk = "{\"ad\": \"9-A\""
|
||||
yazdir()
|
||||
yazdir(f"{bozuk} geçerli JSON mu? {json.gecerli_mi(bozuk)}")
|
||||
Reference in New Issue
Block a user