``

Toplumsal güven ne işe yarar?

Güven, geleceğin belirsizliğini yönetmemizi sağlar. Her alışverişte satıcının geçmişini araştırmak, her sözleşmede karşı tarafı gözetlemek veya her sabah kullandığımız köprünün mühendislik hesaplarını doğrulamak zorunda kalsaydık toplumsal hayat kilitlenirdi.

Sosyolog Niklas Luhmann’a göre güven, toplumsal karmaşıklığı azaltan bir mekanizmadır. Anthony Giddens ise modern toplumlarda bireylerin yüzünü hiç görmedikleri uzmanlara ve kurumlara dayanan soyut sistemlerden söz eder. Banka hesabımızdaki sayı da aslında bu kurumsal güvenin dijital ifadesidir.

Basit bir modelle, bir işlemin beklenen faydasını şöyle gösterebiliriz:

Burada $p$ işlemin dürüst biçimde sonuçlanma olasılığı, $K$ beklenen kazanç, $Z$ olası zarar ve $D$ doğrulama maliyetidir. Geleneksel kurumlar $p$ değerini hukuk ve itibarla yükseltirken blockchain, kriptografik kanıtlarla $D$ ve manipülasyon ihtimalini azaltmaya çalışır.

Kurumsal güven ve blockchain güveni

Blockchain’in toplumsal güven kuramlarıyla örtüştüğü nokta, davranışları öngörülebilir hâle getirmesidir. Akıllı sözleşme belirli koşullarda aynı sonucu üretir; dağıtık kayıt ise geçmişin tek taraflı değiştirilmesini zorlaştırır. Böylece tanımadığımız kişilerle iş birliği yapabiliriz.

Çelişki ise “güvensiz sistem” söyleminde ortaya çıkar. Toplum yalnızca doğru kayıt üretmekten ibaret değildir. Adalet, niyet, merhamet ve istisna gibi kavramlar algoritmik kesinliğe kolayca sığmaz. Kod, “ödeme gecikti” durumunu görebilir; fakat gecikmenin deprem nedeniyle yaşandığını kendiliğinden anlayamaz.

Kod gerçekten hakem olabilir mi?

Aşağıdaki basitleştirilmiş Solidity sözleşmesi, tarafların ödeme sırasında birbirine değil kurala güvenmesini sağlar:

contract Escrow {
    address public buyer;
    address payable public seller;

    constructor(address payable _seller) {
        buyer = msg.sender;
        seller = _seller;
    }

    function approveDelivery() external {
        require(msg.sender == buyer, "Yalnizca alici onaylayabilir");
        seller.transfer(address(this).balance);
    }

    receive() external payable {}
}

Bu kod parayı emanette tutar ve alıcı teslimatı onayladığında satıcıya aktarır. Aracı banka ortadan kalkmıştır; fakat güven kaybolmamıştır. Kullanıcılar derleyiciye, blokzincir ağına, sözleşmenin hatasız olduğuna ve alıcının dürüst onay vereceğine güvenir. Fiziksel teslimat bilgisini zincire taşıyan bir oracle kullanılırsa bu kez oracle yeni güven merkezi olur.

Merkeziyetsizlik iktidarı yok eder mi?

Merkeziyetsizlik, iktidarı otomatik olarak dağıtmaz. Büyük madencilik havuzları, doğrulayıcılar, token sahipleri ve geliştiriciler karar süreçlerinde diğer kullanıcılardan daha etkili olabilir. “Bir kişi, bir oy” yerine “bir token, bir oy” kullanıldığında ekonomik eşitsizlik doğrudan siyasal güce dönüşebilir.

Bu nedenle blockchain’in gerçek vaadi güvenmeden güvenmek değil, güven ilişkilerini görünür, denetlenebilir ve alternatifli hâle getirmektir. Teknoloji belirli aracılara bağımlılığı azaltabilir; ancak ortak normların, hukukun ve topluluk uzlaşmasının yerini tamamen alamaz. Kısacası blockchain güveni silmez: onu kurumdan protokole, yöneticiden topluluğa ve kapalı defterden incelenebilir koda taşır.

Değişken, değer ve tip birbirinden farklıdır

Python, JavaScript ve Ruby gibi dinamik tipli dillerde değişkenin kendisi çoğunlukla belirli bir veri türüne sahip değildir. Değişken, bellekte bulunan bir değere referans taşır; veri türü ise o değerle ilişkilendirilir.

veri = 42          # veri, bir tam sayı nesnesine bağlanır
veri = "Merhaba"  # artık bir metin nesnesine bağlanır

İkinci atama sırasında aynı bellek bölgesinin sihirli biçimde metne dönüştürülmesi gerekmez. Çalışma zamanı yeni bir metin nesnesi oluşturur ve veri adının referansını bu nesneye yönlendirir. Eski 42 nesnesine başka bir referans yoksa nesne daha sonra bellekten temizlenebilir.

Bellekte gerçekte ne saklanır?

Basitleştirilmiş bir dinamik dil nesnesini şu şekilde düşünebiliriz:

Tip etiketi, çalışma zamanına verinin sayı mı, metin mi veya başka bir nesne mi olduğunu söyler. Yönetim bilgisi; nesnenin boyutu, referans sayısı ya da çöp toplayıcının kullandığı işaretler olabilir. Bu nedenle yalnızca 5 değerini saklayan dinamik bir nesne, ham makine tamsayısından daha fazla bellek tüketebilir.

Bir değişkenin nesneye bağlanmasını ise kavramsal olarak şöyle gösterebiliriz:

Aynı nesneye birden fazla değişken işaret edebilir:

a = [10, 20]
b = a
b.append(30)
print(a)  # [10, 20, 30]

Burada liste kopyalanmamıştır. a ve b, aynı liste nesnesine referans verir. Bu davranış performans kazandırırken beklenmedik değişikliklere de yol açabilir. Gerçek bir kopya gerekiyorsa dilin kopyalama araçları kullanılmalıdır.

Sayısal veriler nasıl işlenir?

Bir ifade çalıştırıldığında çalışma zamanı operandların tiplerini inceler ve uygun işlemi seçer:

sonuc = 8 + 4       # sayısal toplama: 12
metin = "8" + "4"  # metin birleştirme: "84"

İşlem sembolü aynı olsa da uygulanan davranış farklıdır. Bu yaklaşıma operatör aşırı yükleme veya tipe göre gönderim denebilir. Farklı türlerin karıştırılması ise dilin kurallarına bağlıdır. Python, 8 + "4" ifadesinde hata verirken JavaScript bazı durumlarda otomatik dönüşüm gerçekleştirir.

Açık dönüşüm, niyeti görünür kıldığı için sürprizleri azaltır.

Metinler ve değişmezlik

Metinler birçok dilde değişmez nesnelerdir. Bir metni güncellediğimizi düşündüğümüzde çoğunlukla yeni bir nesne üretilir:

mesaj = "Merhaba"
mesaj = mesaj + " dünya"

İkinci satır yeni bir metin oluşturur ve mesaj referansını ona bağlar. Çok sayıda metni döngü içinde + ile birleştirmek bu nedenle maliyetli olabilir. Parçaları listede toplayıp join kullanmak genellikle daha verimlidir.

Esnekliğin bedeli

Dinamik tipleme hızlı prototipleme, kısa kod ve esnek veri işleme sağlar. Buna karşılık tip hataları çalışma zamanına kalabilir ve her işlemde tip kontrolü ek maliyet oluşturabilir. Modern yorumlayıcılar; önbellekleme, çalışma zamanı uzmanlaştırması ve JIT derleme sayesinde bu maliyeti azaltır.

Sonuç olarak dinamik tip sistemi “tipsiz” değildir; tip bilgisini değişkenden değere ve derleme anından çalışma zamanına taşır. Bu ayrımı anlamak, hem bellek davranışlarını çözmeyi hem de daha güvenli, hızlı ve şaşırtmayan programlar yazmayı kolaylaştırır.

İterasyon Nedir?

İterasyon, bir işlemin adım adım tekrarlanmasıdır. Her tekrar bir iterasyon olarak adlandırılır. Örneğin 1’den 5’e kadar sayıları ekrana yazdıran bir döngü beş iterasyon gerçekleştirir.

Bir döngü genellikle üç temel parçaya sahiptir:

1. Başlangıç durumu: Sayaç veya başlangıç değeri belirlenir.
2. Devam koşulu: Döngünün çalışmayı sürdürüp sürdürmeyeceği kontrol edilir.
3. Güncelleme: Her turdan sonra durum değiştirilir.

Bir sayaç $i$ başlangıçta $0$ ise ve her adımda $1$ artıyorsa güncelleme şöyle ifade edilir:

Döngü $n$ defa çalışıyorsa ve her tur sabit süre alıyorsa yaklaşık zaman karmaşıklığı $O(n)$ olur. İç içe iki döngü ise çoğunlukla $O(n^2)$ maliyet üretir.

while Döngüsü: Koşul Doğru Oldukça Devam

while, tekrar sayısının önceden kesin olarak bilinmediği durumlarda kullanışlıdır. Önce koşulu denetler, sonuç doğruysa gövdeyi çalıştırır.

sayac = 1

while sayac <= 5:
    print(sayac)
    sayac += 1

Bu örnekte sayaç 1’den başlar. Koşul her turdan önce kontrol edilir ve sayaç 5’i geçtiğinde döngü sona erer. sayac += 1 satırını unutursak koşul sürekli doğru kalabilir. Bunun sonucu, programcıların meşhur canavarı olan sonsuz döngüdür.

while özellikle kullanıcı doğru veri girene kadar beklemek, bir oyunu oyuncunun canı bitene kadar sürdürmek veya bir arama işlemini sonuç bulunana kadar çalıştırmak için uygundur.

for Döngüsü: Koleksiyonların Düzenli Gezgini

for, bir liste, metin, demet veya belirli bir sayı aralığı üzerinde ilerlemek için tercih edilir.

meyveler = ['elma', 'armut', 'muz']

for meyve in meyveler:
    print(meyve.upper())

Burada meyve değişkeni, her iterasyonda listenin sıradaki elemanını temsil eder. Kod, listedeki meyveleri büyük harflerle yazdırır. Eleman sayısını veya indeks yönetimini elle takip etmemiz gerekmez.

Sayısal tekrarlar için range() kullanılabilir:

for sayi in range(1, 6):
    kare = sayi ** 2
    print(sayi, kare)

range(1, 6), 1’den başlayıp 6 hariç olacak şekilde değer üretir. Her sayının karesi $x^2$ formülüyle hesaplanır.

while ve for Karşılaştırması

Döngü Akışını Yönetmek

break, döngüyü tamamen sonlandırır; continue ise yalnızca mevcut iterasyonu atlayarak sonraki tura geçer.

for sayi in range(1, 11):
    if sayi == 8:
        break
    if sayi % 2 != 0:
        continue
    print(sayi)

Bu kod tek sayıları atlar, çift sayıları yazdırır ve 8’e ulaştığında döngüyü bitirir. % operatörü kalanı verdiği için $sayi \bmod 2 = 0$ koşulu çift sayıları belirler.

Döngü seçerken temel soru şudur: “Bir koşul gerçekleşene kadar mı bekliyorum, yoksa elimdeki elemanları mı geziyorum?” İlk durumda while, ikinci durumda for çoğunlukla daha doğal seçimdir. Doğru döngü; kodu yalnızca kısaltmaz, niyetini de okuyucuya açıkça anlatır.

Bellek ve kalıcı depolama arasındaki fark

Bellek hızlı fakat geçicidir. SSD, sabit disk veya ağ üzerindeki depolama ise daha yavaş olmasına rağmen veriyi program sona erdikten sonra da korur. Dosya I/O, yani Input/Output, bu iki dünya arasındaki köprüdür.

Bir metin dosyasını okumak kavramsal olarak üç adımdan oluşur: dosyayı açmak, içeriği almak ve kaynağı kapatmak. Modern dillerde kaynak yönetimi yapıları, kapatma işlemini otomatikleştirir. Bu önemlidir; çünkü açık bırakılan dosyalar işletim sistemi kaynaklarını tüketebilir veya verinin diske tam yazılmasını engelleyebilir.

Metni belleğe okumak

Python’da with bloğu, işlem başarıyla tamamlansa da hata oluşsa da dosyanın kapatılmasını sağlar:

from pathlib import Path

kaynak = Path("ham_veri.txt")

with kaynak.open("r", encoding="utf-8") as dosya:
    metin = dosya.read()

satirlar = [satir.strip() for satir in metin.splitlines() if satir.strip()]
print(f"İşlenecek {len(satirlar)} satır bulundu.")

Burada read() içeriğin tamamını belleğe yükler. Küçük ve orta büyüklükteki belgelerde kullanışlıdır; ancak devasa bir günlük dosyasında RAM’i zorlayabilir. Yaklaşık bellek gereksinimini $M ≈ N + O$ şeklinde düşünebiliriz. Burada $N$ dosyanın boyutu, $O$ ise karakter nesneleri ve veri yapılarının ek yüküdür.

Büyük dosyalarda satır satır okuma daha güvenlidir:

with open("ham_veri.txt", "r", encoding="utf-8") as dosya:
    for satir_no, satir in enumerate(dosya, start=1):
        temiz = satir.strip()
        if temiz:
            print(satir_no, temiz.lower())

Bu yaklaşımda bellek tüketimi yaklaşık olarak $M ≈ L$ olur; $L$, aynı anda işlenen satırın boyutudur. Dosya yüzlerce megabayt olsa bile program bütün içeriği tek seferde taşımak zorunda kalmaz.

İşlenmiş veriyi kalıcılaştırmak

Okunan metin temizlenebilir, dönüştürülebilir veya analiz edilebilir. Sonuç yalnızca ekrana yazdırılırsa program kapandığında pratik değerini kaybedebilir. Çıktıyı belgeye yazmak için w ve a kipleri kullanılabilir.

sonuclar = [satir.upper() for satir in satirlar]

with open("rapor.txt", "w", encoding="utf-8") as dosya:
    dosya.write("İŞLENMİŞ VERİLER\n")
    dosya.write("-" * 20 + "\n")
    dosya.writelines(f"{deger}\n" for deger in sonuclar)

w kipi mevcut içeriği siler. Bu nedenle değerli bir dosyanın üzerine yazmadan önce hedef yol doğrulanmalı veya yedek oluşturulmalıdır. Ayrıca encoding="utf-8" belirtmek, Türkçe karakterlerin farklı sistemlerde anlamsız sembollere dönüşmesini önler.

Güvenli ve dayanıklı I/O

Dosya bulunamayabilir, erişim izni reddedilebilir ya da disk dolabilir. Sağlam bir program bu durumları yakalamalıdır:

try:
    with open("rapor.txt", "a", encoding="utf-8") as dosya:
        dosya.write("İşlem başarıyla tamamlandı.\n")
except OSError as hata:
    print(f"Dosya işlemi başarısız: {hata}")

Daha kritik uygulamalarda sonuç önce geçici bir dosyaya yazılır, ardından hedef dosyanın yerine atomik olarak taşınır. Böylece işlem yarıda kesilirse eski sağlam belge korunur. Kısacası iyi dosya yönetimi; doğru kip, uygun kodlama, kontrollü bellek kullanımı ve hata yönetiminin birleşimidir. Veri kalıcılığı tesadüf değil, bilinçli bir tasarım kararıdır.

``

Fonksiyon Nedir?

Fonksiyon; girdi alabilen, bir işlem gerçekleştiren ve gerektiğinde çıktı üreten alt programdır. Matematikteki fonksiyon kavramıyla benzer şekilde düşünülebilir:

Burada $x$ fonksiyonun girdisi, $2x+3$ işlemi fonksiyonun davranışı, elde edilen değer ise çıktıdır. Programlamada aynı fikir şu biçimde ifade edilebilir:

def hesapla(x):
    return 2 * x + 3

sonuc = hesapla(5)
print(sonuc)  # 13

hesapla fonksiyonu işlemin nasıl yapıldığını tek bir yerde tanımlar. Programın diğer bölümleri ayrıntılarla uğraşmadan yalnızca fonksiyonun adını kullanır. Bu yaklaşım soyutlama olarak adlandırılır.

Parametre ve Argüman Arasındaki Fark

Bu iki kavram sıklıkla birbirinin yerine kullanılsa da teknik olarak farklıdır:

Parametreler birer boş kutu, argümanlar ise çağrı sırasında bu kutulara yerleştirilen değerler gibi düşünülebilir.

def indirimli_fiyat(fiyat, indirim_orani=10):
    indirim = fiyat * indirim_orani / 100
    return fiyat - indirim

standart = indirimli_fiyat(500)
ozel = indirimli_fiyat(500, 25)

Bu örnekte indirim_orani varsayılan bir parametredir. İlk çağrı yüzde 10, ikinci çağrı yüzde 25 indirim uygular. Tek fonksiyon, farklı argümanlarla farklı durumlara uyarlanmıştır.

Modülerlik Neden Önemlidir?

Modüler kodlama, büyük bir problemi küçük ve bağımsız görevlere ayırma yaklaşımıdır. Bir e-ticaret uygulamasında fiyat hesaplama, vergi ekleme, stok kontrolü ve bildirim gönderme ayrı fonksiyonlar olabilir.

Örneğin toplam tutar matematiksel olarak

şeklinde ifade edilebilir. Burada $f_i$ ürün fiyatını, $a_i$ ise ürün adedini temsil eder:

def sepet_toplami(urunler):
    """Fiyat ve adet bilgilerini kullanarak toplam tutarı hesaplar."""
    toplam = 0
    for urun in urunler:
        toplam += urun["fiyat"] * urun["adet"]
    return toplam

sepet = [
    {"fiyat": 120, "adet": 2},
    {"fiyat": 75, "adet": 3}
]

print(sepet_toplami(sepet))  # 465

Fonksiyon yalnızca toplam hesaplama sorumluluğunu üstlenir. Ekrana yazdırma, veritabanına kaydetme veya ödeme alma gibi işler başka modüllere bırakılmalıdır. Bu ilkeye tek sorumluluk ilkesi denir.

Daha Sağlam Fonksiyonlar Yazmak

İyi bir fonksiyon kısa, anlamlı isimli ve tahmin edilebilir olmalıdır. islem() yerine vergi_hesapla() gibi niyeti açıklayan adlar seçilmelidir. Fonksiyon mümkünse dışarıdaki değişkenleri değiştirmemeli; girdiden çıktı üretmelidir. Böyle fonksiyonlara saf fonksiyon denir ve test edilmeleri çok daha kolaydır.

Kısacası fonksiyonlar yalnızca satır sayısını azaltmaz; kodun düşünce yapısını düzenler. Tekrar eden bir blok gördüğünüzde kendinize şu soruyu sorun: “Bu davranışın bir adı olsaydı ne olurdu?” Cevap büyük ihtimalle yeni fonksiyonunuzun adıdır.

``

Bug, beklenti ile gerçeklik arasındaki farktır

Bir programın beklenen çıktısını $E$, gözlenen çıktısını $O$ ile gösterelim. İncelediğimiz sapma kabaca şöyle düşünülebilir:

Buradaki asıl mesele $D$ değerini sıfırlamak değil, farkın hangi koşulda doğduğunu açıklayabilmektir. Açıklayamadığımız ama geçici olarak susturduğumuz hata, genellikle daha dramatik bir kostümle geri döner.

İyi bir hata ayıklama süreci bilimsel yönteme benzer:

1. Belirtiyi gözlemle.
2. Hatayı güvenilir biçimde yeniden üret.
3. Bir hipotez kur.
4. Tek bir değişkeni değiştirerek hipotezi test et.
5. Sonucu kaydet ve kapsamı daralt.

Bu yaklaşımın içe dönük tarafı şudur: Her hipotez, kod kadar zihnimiz hakkında da bilgi verir. “Veritabanı bozuktur” demeden önce, neden ilk olarak dış dünyayı suçlamaya eğilimli olduğumuzu fark ederiz.

Tepki vermek ile araştırmak

Önce hatayı görünür kıl

Aşağıdaki Python fonksiyonu, indirimli fiyat hesaplıyor. Ancak oran değerinin yüzde mi, ondalık mı olduğu belirsiz:

def indirimli_fiyat(fiyat, oran):
    print(f"DEBUG fiyat={fiyat}, oran={oran}")
    assert fiyat >= 0, "Fiyat negatif olamaz"
    assert 0 <= oran <= 1, "Oran 0 ile 1 arasında olmalı"
    return fiyat * (1 - oran)

print(indirimli_fiyat(100, 0.20))

print, programın o andaki durumunu görünür yapar; assert ise sessiz bir varsayımı çalıştırılabilir kurala dönüştürür. Formülümüz $P_{son} = P(1-r)$ olduğuna göre 20 değil, 0.20 beklenir. Böylece sorun yalnızca yanlış değer olmaktan çıkar, açıkça tanımlanmış bir sözleşme ihlaline dönüşür.

Gerçek projelerde günlük kayıtları, debugger durak noktaları ve otomatik testler aynı amaca hizmet eder: Zihnimizde kurduğumuz hikâyeyi ölçülebilir kanıtlarla karşılaştırmak.

İkiye böl, sakinleş, tekrar et

Hatanın yüz satırlık bir alanda bulunduğunu düşünelim. Her adımda alanı ikiye bölersek gereken yaklaşık inceleme sayısı:

$n=100$ için yalnızca $k=7$ adım yeterlidir. git bisect, modülleri devre dışı bırakma ve girdiyi küçültme teknikleri bu mantığı kullanır. Panik bütün sistemi aynı anda görmeye çalışır; yöntem ise soruyu küçültür.

Debug günlüğü tut

Kısa bir kayıt, dairesel düşünmeyi engeller:

Belirti: Sepet toplamı bazı siparişlerde negatif.
Tekrar: İki kupon aynı anda uygulanınca oluşuyor.
Hipotez: İndirimler sırayla değil, toplam olarak düşülüyor.
Deney: İkinci kuponu kapat.
Sonuç: Negatif değer kayboldu.

Bu günlük gelecekteki ekip arkadaşına yardım ederken geçmişteki hâlinizle de dürüst bir konuşma kurar.

Sonunda iyi debugger, hiç hata yapmayan kişi değildir. Yanıldığını hızlı, sakin ve kanıta dayanarak fark edebilen kişidir. Bug düzeldiğinde yalnızca program değişmez; varsayımlarını sınamayı öğrenen geliştirici de küçük bir sürüm yükseltmesi yaşar.

Kalıtımın Temel Mantığı

Kalıtım, bir alt sınıfın başka bir sınıfta tanımlanan özellik ve metotları devralmasıdır. Özellikleri aktaran sınıfa temel sınıf, üst sınıf veya ebeveyn sınıf denir. Bunları alan sınıf ise alt sınıf ya da çocuk sınıftır.

Örneğin Hayvan sınıfında ad özelliğini ve bilgi_ver() metodunu tanımlayabiliriz. Kedi ve Kopek sınıfları bu ortak üyeleri yeniden yazmadan kullanabilir. Bu ilişki genellikle “bir türüdür” testiyle anlaşılır: Kedi bir hayvan türüdür, dolayısıyla kalıtım burada mantıklıdır.

class Hayvan:
    def __init__(self, ad):
        self.ad = ad

    def bilgi_ver(self):
        return f"Benim adım {self.ad}."


class Kedi(Hayvan):
    pass


tekir = Kedi("Tekir")
print(tekir.bilgi_ver())

Kedi sınıfının gövdesinde bilgi_ver() bulunmamasına rağmen tekir nesnesi bu metodu kullanabilir. Python metodu önce alt sınıfta arar, bulamazsa kalıtım zincirinde yukarı doğru ilerler.

Kalıtım sayesinde elde edilen basit kod kazancını yaklaşık olarak şöyle düşünebiliriz:

Kalıtım gereksiz yere kullanılırsa soyutlama maliyeti artar. Bu nedenle yalnızca kod tekrarını azaltmak için değil, sınıflar arasında gerçek bir tür ilişkisi bulunduğunda tercih edilmelidir.

Metot Ezme ve Çok Biçimlilik

Alt sınıf, temel sınıftan gelen bir metodu aynı isimle yeniden tanımlayabilir. Buna metot ezme (override) denir. Çok biçimliliğin sihri de burada ortaya çıkar: Program aynı ses_cikar() çağrısını yapar, fakat çalıştırılan kod nesnenin gerçek türüne göre seçilir.

class Hayvan:
    def __init__(self, ad):
        self.ad = ad

    def ses_cikar(self):
        return "Bilinmeyen bir ses"


class Kedi(Hayvan):
    def ses_cikar(self):
        return "Miyav!"


class Kopek(Hayvan):
    def ses_cikar(self):
        return "Hav hav!"


hayvanlar = [Kedi("Tekir"), Kopek("Karabaş")]

for hayvan in hayvanlar:
    print(hayvan.ad, hayvan.ses_cikar())

Döngü, listedeki nesnelerin türünü denetleyen uzun if blokları içermez. Her nesne nasıl ses çıkaracağını kendisi bilir. Bu yaklaşım, programa yeni bir Kus sınıfı eklendiğinde mevcut döngünün değiştirilmesine gerek bırakmaz.

super() ile Temel Davranışı Korumak

Bazen üst sınıftaki davranışı tamamen silmek yerine genişletmek isteriz. super(), temel sınıfın metoduna kontrollü biçimde ulaşmamızı sağlar.

class Kus(Hayvan):
    def __init__(self, ad, kanat_acikligi):
        super().__init__(ad)
        self.kanat_acikligi = kanat_acikligi

    def bilgi_ver(self):
        temel_bilgi = super().bilgi_ver()
        return f"{temel_bilgi} Kanat açıklığım {self.kanat_acikligi} cm."

Burada temel sınıfın kurucusu ad değerini hazırlar; alt sınıf yalnızca kendine özgü kanat_acikligi alanını ekler. Böylece ortak kurulum kodu kopyalanmaz.

Ne Zaman Kullanılmalı?

Kalıtım güçlüdür ancak her ilişki kalıtım değildir. “Araba bir motordur” ifadesi yanlış olduğu için Araba, Motor sınıfından türetilmemelidir; araba bir motora sahiptir. Bu durumda bileşim daha uygundur.

Çok biçimlilik ise ödeme yöntemleri, dosya biçimleri, bildirim kanalları ve oyun karakterleri gibi ortak bir işlemin farklı uygulanabildiği sistemlerde parıldar. Kısacası kalıtım sınıfların ortak geçmişini, çok biçimlilik ise kendilerine özgü karakterlerini temsil eder. İyi tasarlandıklarında kod ailesinde herkes akrabadır, fakat kimse aynı şakaya aynı tepkiyi vermek zorunda değildir.

Kapsam ve isim alanı aynı şey mi?

Bu kavramlar yakın akraba olsalar da aynı değildir. İsim alanını bir sözlük, kapsamı ise o sözlüğe hangi noktadan erişilebildiğini belirleyen kurallar bütünü gibi düşünebiliriz.

Matematiksel olarak bir isim alanını şu eşleme ile gösterebiliriz:

Örneğin x = 42 ifadesi, ilgili isim alanında $N(x)=42$ eşleşmesini oluşturur. Program x ismini kullandığında yorumlayıcı, geçerli kapsamları belirli bir sırayla araştırır.

Python’da LEGB arama sırası

Python, bir ismi çözümlerken LEGB kuralını kullanır:

1. Local: Çalışan fonksiyonun yerel isim alanı.
2. Enclosing: İç içe fonksiyonlarda dış fonksiyonların alanları.
3. Global: Modül seviyesinde tanımlanan isimler.
4. Built-in: len, print ve range gibi hazır isimler.

Bu arama sırasını $L \rightarrow E \rightarrow G \rightarrow B$ biçiminde özetleyebiliriz. İlk eşleşme bulunduğunda arama durur. Dolayısıyla yerel bir print değişkeni tanımlarsanız yerleşik print() fonksiyonunu gölgeleyebilirsiniz. Program çalışır gibi görünürken bir anda “str nesnesi çağrılamaz” hatası vermesi, Python’ın küçük bir şakası değildir; isim gölgelemenin sonucudur.

message = "Global mesaj"

def show_message():
    message = "Lokal mesaj"
    print(message)

show_message()  # Lokal mesaj
print(message)  # Global mesaj

Fonksiyon içindeki atama yeni bir lokal isim üretir. Dışarıdaki message değişkeni değişmez; iki isim farklı isim alanlarında bulunur.

Girinti her zaman yeni kapsam oluşturmaz

Python’da fonksiyonlar, sınıflar ve modüller isim alanı oluşturur. Ancak if, for ve while blokları girintili olmalarına rağmen ayrı bir lokal kapsam meydana getirmez.

if True:
    result = 25

print(result)  # 25

for number in range(3):
    squared = number ** 2

print(squared)  # 4

Bu davranış JavaScript’teki let veya C ailesindeki blok kapsamından farklıdır.

global ve nonlocal anahtar sözcükleri

Bir fonksiyon içinde global değişkeni yeniden bağlamak için global gerekir. İç içe fonksiyonlarda dış fonksiyonun değişkenini değiştirmek içinse nonlocal kullanılır.

counter = 0

def create_incrementer():
    step = 1

    def increment():
        global counter
        nonlocal step
        counter += step
        step += 1
        return counter

    return increment

Burada counter modül alanında, step ise çevreleyen fonksiyon alanındadır. Her çağrıda artış miktarının korunması, closure adı verilen yapının sonucudur.

Sağlam tasarım için öneriler

Global değişkenler kolay erişim sağlar fakat fonksiyonların gizli bağımlılıklar taşımasına yol açar. Bu nedenle değerleri parametre olarak geçirmek ve sonucu return ile döndürmek genellikle daha test edilebilir bir tasarım üretir. Ayrıca yerleşik fonksiyon adlarını değişken olarak kullanmamak, kısa ama belirsiz isimlerden kaçınmak ve kapsamı mümkün olduğunca dar tutmak önemlidir.

Özetle kapsam, bir değişkenin “nereden görüldüğünü”; isim alanı ise “hangi nesneyi temsil ettiğini” açıklar. LEGB sırasını ve girintili her bloğun yeni kapsam oluşturmadığını bilmek, değişkenlerin program içinde saklambaç oynamasını büyük ölçüde engeller.

List Comprehension Nedir?

List comprehension, yinelenebilir bir kaynaktan yeni bir liste oluşturan sözdizimsel bir yapıdır. Temel biçimi şöyledir:

[yeni_deger for eleman in kaynak]

Matematiksel olarak bunu bir küme dönüşümüne benzetebiliriz. Bir $A$ veri kümesindeki her $x$ elemanına $f$ fonksiyonu uygulanıyorsa sonuç şöyle gösterilebilir:

Örneğin sayıların karelerini üretelim:

sayilar = [1, 2, 3, 4, 5]
kareler = [sayi ** 2 for sayi in sayilar]

print(kareler)  # [1, 4, 9, 16, 25]

Buradaki ifade soldan sağa okunabilir: “sayilar içindeki her sayi için sayi ** 2 değerini listeye ekle.” Aynı işlemin klasik döngüyle karşılığı daha uzundur:

kareler = []
for sayi in sayilar:
    kareler.append(sayi ** 2)

Koşulla Veri Süzme

İfadenin sonuna if ekleyerek yalnızca belirli elemanları seçebiliriz. Örneğin çift sayıların karelerini üretelim:

sayilar = range(1, 11)
cift_kareler = [x ** 2 for x in sayilar if x % 2 == 0]

print(cift_kareler)  # [4, 16, 36, 64, 100]

Koşulun matematiksel karşılığı şu şekilde düşünülebilir:

Burada önce x % 2 == 0 filtresi uygulanır, ardından koşulu geçen sayıların karesi hesaplanır. Böylece filtreleme ve dönüştürme tek bir ifadede birleşir.

if-else Kullanımında Sıra Değişir

Her elemanı listeye almak, ancak koşula göre farklı bir değer üretmek istiyorsak if-else bölümü for ifadesinden önce yazılır:

etiketler = ["çift" if x % 2 == 0 else "tek" for x in range(1, 6)]
print(etiketler)  # ['tek', 'çift', 'tek', 'çift', 'tek']

Bu ayrım başlangıçta küçük bir Python bilmecesi gibi görünse de mantığı basittir: Sondaki if, elemanın listeye girip girmeyeceğine; baştaki if-else ise hangi değerin üretileceğine karar verir.

İç İçe Döngüler

List comprehension birden fazla döngü de içerebilir. Aşağıdaki kod iki listenin tüm sayı çiftlerini üretir:

harfler = ["A", "B"]
sayilar = [1, 2, 3]

eslesmeler = [(harf, sayi) for harf in harfler for sayi in sayilar]
print(eslesmeler)

Döngüler, klasik iç içe döngülerdeki sırayla yazılır. Yine de üç veya daha fazla döngü ve çok sayıda koşul eklemek okunabilirliği hızla düşürür. Tek satır yazabilmek, her zaman tek satır yazmanız gerektiği anlamına gelmez.

Performans ve Pythonik Denge

List comprehensions, append() çağrısını Python seviyesinde tekrar tekrar çalıştırmadığı için klasik döngülerden çoğunlukla daha hızlıdır. Ancak bütün sonuçları bellekte tutar. Çok büyük veri akışlarında köşeli parantez yerine parantez kullanan generator expression tercih edilebilir:

toplam = sum(x ** 2 for x in range(1_000_000))

Generator, değerleri ihtiyaç oldukça üretir; yaklaşık bellek yaklaşımı liste için $O(n)$, generator için ise çoğu senaryoda $O(1)$ düzeyindedir.

Sonuç olarak list comprehension; kısa dönüşüm, filtreleme ve eşleştirme işlemlerinde güçlü bir araçtır. Altın kural şudur: İfade ilk bakışta anlaşılabiliyorsa Pythoniktir; çözmek için dedektif şapkası gerekiyorsa klasik döngü daha iyi seçimdir.

``

Sınıf ve nesne arasındaki fark

OOP’nin merkezinde sınıf ve nesne bulunur. Sınıf, nesnelerin hangi özelliklere ve metotlara sahip olacağını belirleyen bir şablondur. Nesne ise bu şablondan üretilmiş somut bir örnektir.

Bunu kurabiye kalıbına benzetebiliriz: Kalıp sınıf, kalıpla hazırlanan her kurabiye ise ayrı bir nesnedir. Kurabiyelerin şekli aynı olsa da renkleri veya süslemeleri farklı olabilir.

Bir nesnenin durumunu matematiksel olarak özellikler kümesiyle gösterebiliriz:

Örneğin bir otomobilin durumu $D = {renk, hız, yakıt}$, davranışları ise $B = {hızlan, fren}$ biçiminde düşünülebilir.

İlk sınıfımızı oluşturalım

Aşağıdaki Python sınıfı, otomobilin verilerini saklar ve hızını kontrollü biçimde değiştiren metotlar sunar:

class Otomobil:
    def __init__(self, marka, renk, yakit):
        self.marka = marka
        self.renk = renk
        self.yakit = yakit
        self.hiz = 0

    def hizlan(self, miktar):
        gereken_yakit = miktar * 0.05

        if gereken_yakit <= self.yakit:
            self.hiz += miktar
            self.yakit -= gereken_yakit
        else:
            print("Yeterli yakıt yok!")

    def fren_yap(self, miktar):
        self.hiz = max(0, self.hiz - miktar)

    def bilgileri_goster(self):
        return f"{self.marka}: {self.hiz} km/sa, {self.yakit:.1f} litre"

__init__, nesne oluşturulurken otomatik çalışan kurucu metottur. self, işlem yapılan mevcut nesneyi temsil eder. hizlan metodu hem hızı hem de yakıtı değiştirirken fren_yap, hızın sıfırın altına düşmesini engeller.

Şimdi aynı sınıftan bağımsız iki nesne üretelim:

araba_1 = Otomobil("Volvo", "Mavi", 40)
araba_2 = Otomobil("Toyota", "Beyaz", 25)

araba_1.hizlan(50)
araba_2.hizlan(30)
araba_2.fren_yap(10)

print(araba_1.bilgileri_goster())
print(araba_2.bilgileri_goster())

Her nesne kendi hiz ve yakit değerlerini saklar. araba_1 üzerinde gerçekleştirilen işlem, araba_2 nesnesini etkilemez. Bu ayrım, büyük uygulamalarda veri karmaşasını önleyen önemli bir avantajdır.

OOP’nin dört temel ilkesi

OOP yalnızca sınıf yazmaktan ibaret değildir. Sağlam tasarımlar genellikle dört temel ilkeye dayanır:

Kapsülleme, nesnenin iç durumuna rastgele müdahale edilmesini sınırlar. Kalıtım, mevcut sınıfların özelliklerini yeni sınıflarda kullanmayı sağlar. Çok biçimlilik, aynı metot adının nesne türüne göre farklı çalışabilmesidir. Soyutlama ise kullanıcıya yalnızca ihtiyaç duyduğu arayüzü gösterir.

Neden OOP kullanalım?

OOP; banka hesapları, kullanıcılar, oyun karakterleri veya siparişler gibi belirgin varlıklara sahip sistemlerde oldukça etkilidir. İlgili veri ve davranışlar aynı yerde tutulduğu için kodun okunması, test edilmesi ve genişletilmesi kolaylaşır. Ancak her küçük problem için onlarca sınıf oluşturmak da gereksiz karmaşıklık yaratabilir.

Özetle sınıf bir plan, nesne bu planın çalışan örneğidir. İyi tasarlanmış bir nesne neyi bildiğini özellikleriyle, neler yapabildiğini ise metotlarıyla anlatır. Kod konuşabilseydi muhtemelen şöyle derdi: “Verimi bana bırak, davranışımı metotlarımdan iste!”