Python’da Kullanılan Bazı Terimler 8-)

29-)Python’da Sınıf (Class) Yapısı Sınıf oluşturmak için class anahtar kelimesini kullanırız. Python standartlarına (PEP 8) göre sınıf isimleri her zaman PascalCase (Her kelimenin ilk harfi büyük) yazılır.

1. Temel Bir Sınıf Oluşturma

Bir sınıfın içinde genellikle verileri tutan nitelikler (attributes) ve iş yapan metotlar (methods) bulunur.

class Robot:
    def __init__(self, ad, gorev):
        self.ad = ad        # Nitelik
        self.gorev = gorev  # Nitelik

def tanit(self):        # Metot
        print(f"Merhaba, ben {self.ad}. Görevim: {self.gorev}")
# Sınıftan bir nesne (instance) oluşturma:
robot1 = Robot("R2-D2", "Tamir")
robot1.tanit()

2. Python’da Boş Bir Sınıf Nasıl Oluşturulur?

Bazen projenin başında sadece bir sınıfın varlığına ihtiyaç duyarsın ama içine henüz kod yazmak istemezsin. Python’da bir kod bloğu (if, for, class, def) asla boş bırakılamayacağı için burada imdadımıza **pass** anahtar kelimesi yetişir.

class TaslakSinif:
    pass

# Bu sınıf hata vermeden çalışır ve daha sonra doldurulmayı bekler.
obj = TaslakSinif()

Neden Boş Sınıf Oluştururuz?

• Yer Tutucu (Placeholder): Projenin mimarisini çizerken sınıfları belirleyip içini sonra doldurmak için.
• Veri Konteyneri: Sadece nitelik atamak için boş bir sınıf oluşturup, çalışma anında (runtime) ona özellikler ekleyebiliriz.

class Veri: pass

v = Veri()
v.x = 10
v.y = 20

30–)Python’da monkey patching nedir? Monkey Patching, bir programın kaynak koduna dokunmadan, çalışma zamanında (runtime) bir modülün, sınıfın veya fonksiyonun davranışını dinamik olarak değiştirme veya genişletme işlemidir.

Kısacası, kod çalışırken bir parçayı söküp yerine kendi parçanızı takmak gibidir.

Nasıl Yapılır? (Örnek)

Diyelim ki bir kütüphanede (kutuphane.py) bir fonksiyon var ve siz bu fonksiyonun orijinal halini değiştirmek istiyorsunuz:

# orijinal_kod.py
class Robot:
    def selamla(self):
        print("Sistemsel selamlar.")

# senin_kodun.py
def yeni_selamla(self):
    print("Merhaba dostum! Ben güncellendim.")
# Monkey Patching Uygulama:
Robot.selamla = yeni_selamla
# Test:
bot = Robot()
bot.selamla()  # Çıktı: "Merhaba dostum! Ben güncellendim."

Neden Kullanılır?

• Hata Düzeltme (Hotfix): Kullandığınız üçüncü parti bir kütüphanede hata varsa ve kütüphanenin yeni sürümünü bekleyecek vaktiniz yoksa, hatayı çalışma anında yamayabilirsiniz.
• Test Etme (Mocking): Bir fonksiyonun internete bağlanması gerekiyorsa ama siz test sırasında internete bağlanmasını istemiyorsanız, o fonksiyonu geçici olarak sahte (mock) bir fonksiyonla değiştirebilirsiniz.
• Özellik Ekleme: Mevcut sınıflara yeni yetenekler kazandırmak için kullanılır.

31-)Descriptor Protokolü

1. Descriptor Nedir?

En basit tanımıyla Descriptor (Tanımlayıcı); bir nesnenin niteliklerine (attributes) erişildiğinde, o erişim davranışını (get, set, delete) tamamen kendi üzerine bağlayan ve manipüle eden özel bir sınıftır (class).

Bir sınıfın Descriptor olabilmesi için, serimizin 12. yazısında bahsettiğimiz protokol mantığına uygun olarak, şu üç dunder (magic) metottan en az birini uygulaması gerekir:

• __get__(self, instance, owner): Değer okunurken tetiklenir.
• __set__(self, instance, value): Değer atanırken tetiklenir.
• __delete__(self, instance): Değer silinirken tetiklenir.

2.Veri Doğrulama (Validation)

Neden Descriptor’lara ihtiyaç duyduğumuzu anlamak için klasik bir problemi ele alalım. Bir Urun sınıfımız olsun ve bu ürünün fiyat bilgisi negatif bir değer (örn: -50) alamasın.

Bunu @property ile yapabiliriz:

class Urun:
    def __init__(self, isim, fiyat):
        self.isim = isim
        self.fiyat = fiyat # Setter tetiklenir

    @property
        def fiyat(self):
            return self._fiyat
        @fiyat.setter
        def fiyat(self, değer):
            if değer < 0:
                raise ValueError("Fiyat negatif olamaz!")
            self._fiyat = değer

Peki ya sınıfımıza stok_adedi, indirim_orani, kargo_ucreti gibi negatif olmaması gereken 10 tane daha alan eklersek ne olacak? Her biri için ayrı ayrı @property, getter ve setter yazmak zorunda kalacağız. Kodumuz devasa bir tekrar yığınına dönüşecek ve DRY (Don't Repeat Yourself) prensibini çiğneyecektir.

3. Kendi Descriptor Sınıfımızı Yazmak

Descriptor protokolü tam olarak burada hayat kurtarır. Yeniden kullanılabilir bir veri doğrulama motoru yazıp, bunu sınıflarımızın niteliklerine uygulayabiliriz.

class NegatifOlamaz:
    """Bu sınıf bir Descriptor'dır."""
    def __init__(self, nitelik_adi):
        self.nitelik_adi = nitelik_adi

    def __get__(self, instance, owner):
            # instance: Urun nesnesinin kendisi (u1)
            # owner: Urun sınıfının kendisi
            if instance is None:
                return self
            return instance.__dict__.get(self.nitelik_adi)
        def __set__(self, instance, value):
            if value < 0:
                raise ValueError(f"{self.nitelik_adi} negatif olamaz!")
            instance.__dict__[self.nitelik_adi] = value
    # Tasarladığımız Descriptor'ı kullanıyoruz
    class Urun:
        fiyat = NegatifOlamaz("fiyat")
        stok = NegatifOlamaz("stok")
        indirim = NegatifOlamaz("indirim")
        def __init__(self, isim, fiyat, stok, indirim):
            self.isim = isim
            self.fiyat = fiyat
            self.stok = stok
            self.indirim = indirim
    u1 = Urun("Oyuncu Mousu", 1500, 20, 5)
    # u1.fiyat = -100  # HATA! ValueError: fiyat negatif olamaz! fırlatır.

Nasıl Çalıştı?: u1.fiyat = 1500 dediğimizde, Python u1 nesnesinin içinde fiyat arar. Ancak fiyat'ın sınıf seviyesinde bir Descriptor nesnesi (NegatifOlamaz) olduğunu fark eder. Bu yüzden doğrudan atama yapmak yerine, bizim yazdığımız __set__ metodunu arkada otomatik olarak tetikler.

32-)Nesne Ömrü ve Garbage Collector (Çöp Toplayıcı) Python’da ise bu işi Garbage Collector (GC) üstlenir. Bir nesnenin ömrü, oluşturulduğu an başlar ve ona olan ihtiyaç bittiğinde GC tarafından sonlandırılır.

Python bu süreci iki temel mekanizma ile yönetir:

1. Referans Sayımı (Reference Counting)

Python’da her nesne, kendisine kaç farklı değişkenin veya yapının işaret ettiğini tutan bir sayaç barındırır.

• Bir nesne yeni bir değişkene atandığında sayaç +1 artar.
• Bir değişken silindiğinde (del) veya kapsam dışı kaldığında (fonksiyon bitişi gibi) sayaç -1 azalır.
• Sayaç 0 olduğunda: Python, o nesneye artık kimsenin ihtiyacı olmadığını anlar ve nesneyi derhal bellekten siler.

2. Nesilsel Çöp Toplama (Generational Garbage Collection)

Sadece referans sayımı yeterli değildir çünkü bazen “Döngüsel Referanslar” (Circular References) oluşur. Örneğin, A nesnesi B’yi, B nesnesi de A’yı gösteriyorsa, ikisinin de sayacı asla sıfıra düşmez.

Bu noktada devreye Garbage Collector girer. GC, nesneleri ömürlerine göre üç “Nesil”e (Generation) ayırır:

• 0. Nesil (Gen 0): Yeni oluşturulan nesneler. En sık burası denetlenir.
• 1. Nesil (Gen 1): Bir temizlikten sağ çıkan (hala silinmemiş) nesneler buraya taşınır.
• 2. Nesil (Gen 2): En uzun süre hayatta kalan nesneler (örneğin kütüphaneler, sabitler). En nadir burası denetlenir.

Kritik Kavramlar

• Döngüsel Referans (Circular Reference): İki nesnenin birbirini işaret ederek “hayalet” bir bağ oluşturmasıdır. Referans sayımı bunu çözemez, ancak GC bu düğümü tespit edip siler.
• Bellek Sızıntısı (Memory Leak): Gereksiz nesnelerin bir şekilde referanslarının açık kalması ve GC tarafından temizlenememesi sonucu RAM kullanımının sürekli artmasıdır.

Örneğin;

Python’da bir nesnenin kaç referansı olduğunu merak ediyorsak sys modülünü kullanabiliriz:

import sys

liste = [1, 2, 3]
print(sys.getrefcount(liste)) # Çıktı genelde 2 olur (biri değişken, diğeri getrefcount fonksiyonu)
yedek = liste
print(sys.getrefcount(liste)) # Çıktı 3 olur

Buraya kadar okuduğunuz için teşekkürler :)

dxtaner (Taner Özer) https://medium.com/@dxtaner Taner Özer | LinkedIn