Python __init__, self ve Metotlar
Ders 32'de Sınıflar ve Nesneler konusuyla kalıbı öğrendin: class yazdın, Ogrenci() dedin, nesne ürettin. Ama her attribute'ı elle eklemek zorundaydın. ogrenci1.ad = "Elif" satırını unuttuğun an, yarım bir kayıt elinde kalıyordu.
Bu ders o yarım işi tamamlıyor. Kurucu metot __init__, gizemli parametre self ve sınıf içinde yaşayan fonksiyonlar yani metotlar — üçü birden bu derste. Üstelik sınıfına davranış kazandıracaksın; nesne artık sadece veri taşımayacak, iş de yapacak.
init: Nesnenin Doğum Anı
Bir nesne doğduğu anda bazı işleri otomatik yapmasını istersin: adını alsın, numarasını kaydetsin, not listesini hazırlasın. İşte __init__ tam olarak bunun için var:
class Ogrenci:
def __init__(self, ad, numara):
"""Nesne oluşturulduğu anda otomatik çalışan kurucu metot."""
self.ad = ad
self.numara = numara
self.notlar = [] # Her öğrenci boş bir not listesiyle doğsun
# Kurucu artık parametre istiyor: ad ve numara
ogrenci1 = Ogrenci("Elif", 101)
ogrenci2 = Ogrenci("Mert", 102)
print(ogrenci1.ad) # Elif
print(ogrenci2.notlar) # []
Arka planda olan şu: Ogrenci("Elif", 101) çağrısı bellekte yer ayırır, sonra __init__ metodunu yeni nesneyle birlikte çalıştırır. Metot bittiğinde nesne artık dolu doğmuştur; ad ve numara alanlarının eksik kalma ihtimali yoktur. Adındaki çift alt çizgiler süs değil: Python'da __init__ gibi özel anlamı olan metotlara "dunder" (double underscore) denir ve bu ismi değiştirirsen otomatik çağrı hiç gerçekleşmez. __init__'ın bir marifeti de validasyon: parametreyi olduğu gibi self'e yazmak yerine kontrol edebilirsin; negatif numarayı reddeden bir kurucu, hatalı kaydı daha doğarken engeller.
self: Nesnenin Kendisi
Peki self ne? Sihirli bir anahtar kelime değil. Sıradan bir parametre adı — sadece herkes aynı ismi kullanmayı kabul etmiş. self, o anda üretilmekte olan nesnenin kendisini temsil eder:
ogrenci1 = Ogrenci("Elif", 101)
# Python aslında arka planda şunu yapar:
Ogrenci.__init__(ogrenci1, "Elif", 101)
# self parametresinin yerine nesnenin kendisi geçer
Kurucu tek bir yerde yazılı ama her nesne için ayrı çalışıyor. self olmasaydı, "bu ad hangi öğrencinin adı olacak?" sorusunun cevabı olmazdı. İşte o yüzden sınıf içindeki her fonksiyonun ilk parametresi self'tir; Python bu parametreyi senin yerine doldurur, sen çağrıda yazmazsın. Bu mekanizmayı bir kez kavradığında, ileride okuyacağın her kütüphanenin kaynak kodu sana daha az yabancı gelecek.
Acı Tecrübem: Kayıp self, Gelen TypeError
Yıllar önce bir projede metot tanımlarken self yazmayı unuttum:
class Ogrenci:
def __init__(ad, numara): # self burada yok!
self.ad = ad
Kod çalıştırmayı denediğimde şu hatayı aldım: TypeError: __init__() takes 2 positional arguments but 3 were given. On beş dakika hata mesajına boş boş baktım. Çünkü kafamda "iki parametre verdim, niye üç diyor?" sorusu vardı.
Cevap mekanikti: Python her metot çağrısında nesneyi ilk argüman olarak zorla ekler. self parametresi tanımda yer almazsa, Python'un enjekte ettiği nesne parametre sayısını taşırır ve hesap tutmaz. O günden beri bu hatayı binlerce kez gördüm — sende de mutlaka çıkacak. Mesajı görünce aklına ilk gelen şu olsun: parametre sayısı bir fazla görünüyorsa, self unutulmuştur.
Metotlar: Sınıf İçinde Yaşayan Fonksiyonlar
Sınıfın içine normal fonksiyon da yazabilirsin. O zaman adı metot olur ve nesnenin verileri üzerinde çalışır:
class Ogrenci:
def __init__(self, ad, numara):
self.ad = ad
self.numara = numara
self.notlar = []
def not_ekle(self, puan):
"""Öğrencinin not listesine yeni bir puan ekler."""
self.notlar.append(puan)
def ortalama(self):
"""Notların ortalamasını döndürür; liste boşsa 0.0 verir."""
if not self.notlar:
return 0.0
return sum(self.notlar) / len(self.notlar)
# Metotlar nesne üzerinden, nokta notasyonuyla çağrılır
ogrenci1 = Ogrenci("Elif", 101)
ogrenci1.not_ekle(85)
ogrenci1.not_ekle(90)
print(ogrenci1.ortalama()) # 87.5
Arka planda ogrenci1.not_ekle(85) çağrısı Ogrenci.not_ekle(ogrenci1, 85) biçimine çevrilir; self yine devreye girer ve 85, doğru nesnenin listesine eklenir. ortalama metodu da aynı nesnenin notlar listesini self üzerinden okur, ortalamayı hesaplar ve döndürür. Veri ile davranış artık ayrılmaz bir çift: notlar nesnede, notlarla ilgili işlemler de sınıfın içinde.
# Aynı metot, iki farklı nesne için iki ayrı işlem yürütür
ogrenci2 = Ogrenci("Mert", 102)
ogrenci2.not_ekle(70)
print(ogrenci1.notlar) # [85, 90]
print(ogrenci2.notlar) # [70]
not_ekle kodu bir kez yazıldı ama hangi nesne onu çağırırsa o nesnenin listesine yazdı; bu ayırımı yapan yine self. Fonksiyon yaklaşımıyla yapsaydın listeyi her çağrıda parametre olarak taşıman ve doğru listeyi asla karıştırmaman gerekirdi.
Instance Attribute vs Class Attribute
Şimdiye kadar gördüğün alanların hepsi instance attribute'tu: her nesneye özel, self ile tanımlanmış. Bir de class attribute var — sınıf seviyesinde tanımlanır, tüm nesneler ortak görür:
class Ogrenci:
okul_adi = "Anadolu Lisesi" # Class attribute: herkes için aynı değer
def __init__(self, ad):
self.ad = ad # Instance attribute: her nesneye özel
ogrenci1 = Ogrenci("Elif")
ogrenci2 = Ogrenci("Mert")
print(ogrenci1.okul_adi) # Anadolu Lisesi
print(ogrenci2.okul_adi) # Anadolu Lisesi
Python bir attribute okurken önce nesnenin kendi __dict__'ine bakar, orada bulamazsa sınıfa tırmanır; okul_adi bu yüzden iki nesnede de aynı çıkar. Sınıf seviyesinde değişiklik yaparsan herkes görür; ama bir nesneye kendi okul_adi'sini atarsan o nesne artık kendi kopyasını taşır ve sınıf değerini gölgeler. Arama sırası şudur: önce nesne, sonra sınıf. Gerçek sistemlerde ikisi bir arada yaşar: ortak ayarlar class attribute olur, kişisel veriler instance attribute.
Acı Tecrübem: Ortak Liste Felaketi
Bu konuda en pahalı hatamı anlatayım. Gençken bir sınıfı şöyle yazdım:
class Ogrenci:
notlar = [] # Sınıf seviyesinde liste: BÜYÜK HATA
def __init__(self, ad):
self.ad = ad
Aklımca "not listesi hazır gelsin" diye düşünmüştüm. Sonra üç öğrenci üretip hepsine not ekledim ve ekranda gördüm ki Elif'in notu Mert'te, Mert'in notu Zeynep'te görünüyor. Akşamımı bu hatayı aramakla geçirdim.
Sebep basitti: liste tek bir yerde, sınıfın üzerinde duruyordu ve bütün nesneler aynı listeye yazıyordu. O akşam şu kuralı kafama kazıdım: değişken (mutable) yapılar asla sınıf seviyesinde tanımlanmaz, __init__ içinde self ile oluşturulur. Okul adı gibi sabit değerler sınıf seviyesinde kalabilir; liste ve sözlük gibi büyüyen yapılar __init__'a aittir.
str ile print Davranışı
Şimdiye kadar bir nesneyi doğrudan print etmedik. Edersen ne olur, bir gör:
class Ogrenci:
def __init__(self, ad, numara):
self.ad = ad
self.numara = numara
ogrenci1 = Ogrenci("Elif", 101)
print(ogrenci1) # <__main__.Ogrenci object at 0x000001F3...>
Çirkin, değil mi? Varsayılan davranışta Python sana nesnenin sınıfını ve bellek adresini gösterir. __str__ metodunu tanımlarsan bu çıktıyı sen belirlersin:
class Ogrenci:
def __init__(self, ad, numara):
self.ad = ad
self.numara = numara
def __str__(self):
"""print() ve str() bu metodun döndürdüğü metni kullanır."""
return f"Ogrenci(ad='{self.ad}', numara={self.numara})"
ogrenci1 = Ogrenci("Elif", 101)
print(ogrenci1) # Ogrenci(ad='Elif', numara=101)
Arka planda print fonksiyonu, nesneyi metne çevirmek için str() çağırır; str() de senin __str__ metodunu bulur ve döndürdüğü değeri kullanır. Tek şart var: __str__ mutlaka string döndürmeli, aksi halde Python yine TypeError fırlatır. Hata ayıklarken nesneyi direkt print edebilmek, hayatını gerçekten kolaylaştırır.
Örnek: Ogrenci Sınıfını Tamamlayalım
Bu derste öğrendiklerinin hepsi tek bir sınıfta toplansın:
class Ogrenci:
"""Ad, numara ve not bilgilerini tek çatı altında toplayan sınıf."""
okul_adi = "Anadolu Lisesi" # Ortak bilgi: class attribute
def __init__(self, ad, numara):
self.ad = ad # Özel bilgiler: instance attribute
self.numara = numara
self.notlar = []
def not_ekle(self, puan):
"""Not listesine yeni bir puan ekler."""
self.notlar.append(puan)
def ortalama(self):
"""Notların ortalamasını hesaplar."""
if not self.notlar:
return 0.0
return sum(self.notlar) / len(self.notlar)
def __str__(self):
"""Nesneyi okunaklı bir metne çevirir."""
return f"{self.ad} (No: {self.numara}, Ortalama: {self.ortalama():.2f})"
# Üç öğrenci, üç bağımsız kayıt
ogrenciler = [Ogrenci("Elif", 101), Ogrenci("Mert", 102), Ogrenci("Zeynep", 103)]
ogrenciler[0].not_ekle(85)
ogrenciler[0].not_ekle(90)
ogrenciler[1].not_ekle(70)
ogrenciler[2].not_ekle(100)
for ogrenci in ogrenciler:
print(ogrenci)
Bu kodda her parça yerini buldu: kurucu alanları garanti ediyor, metotlar davranışı taşıyor, __str__ okunaklı çıktı veriyor. Dikkatini çekmesini istediğim bir detay var: __str__ içinde self.ortalama() çağrılıyor — yani bir metot, aynı nesnenin başka bir metodunu yine self üzerinden kullanıyor. Sınıfların gücü de bu: parçalar birbirini biliyor, sen dışarıdan tek noktadan yönetiyorsun. Bu kodu kendi bilgisayarında çalıştır ve üç satır çıktının hangi metottan geldiğini tek tek söyleyebilene kadar incele.
Sık Sorulan Sorular
init yazmazsam ne olur?
Hiçbir şey bozulmaz. Python sana görünmez, boş bir kurucu sağlar ve nesne yine üretilir. Ama o zaman Ders 32'deki duruma dönersin: attribute'ları elle, tek tek eklemen gerekir. __init__ zorunluluk değil, düzen aracıdır; seni de ekibini de yarısı dolu nesnelerle baş başa bırakmaz.
self yerine başka bir isim kullanabilir miyim?
Teknik olarak evet; ben de yazsan Python itiraz etmez, çünkü self ayrılmış bir anahtar kelime değildir. Ama yapma. Bütün kütüphaneler, dokümanlar ve ekip arkadaşların self der; farklı bir isim kodu okuyan herkesi yavaşlatır. Sözleşmeler de bir tür dokümantasyondur.
Metot ile fonksiyon arasındaki fark ne?
Metot, bir sınıfın içinde tanımlanan ve ilk parametresi self olan fonksiyondur; bir nesneye aittir ve o nesnenin verisine erişir. Fonksiyon ise sınıfın dışında serbest yaşar. İkisi de aynı def anahtar kelimesiyle yazılır; fark, ait oldukları yerdedir. Günlük konuşmada ikisine de "fonksiyon" demek ayıp değil; ayrım, kod yazarken işine yarar.
Sırada Ne Var?
Ogrenci sınıfı güzel oldu ama dürüst olalım: yarın bir de Ogretmen sınıfı yazman gerekirse ne yapacaksın? Ad ve numara tutan kısmı baştan mı yazacaksın? Her yeni kayıt türünde aynı kurucuyu, aynı alanları tekrarlamak, tam da sınıflarla kaçmaya çalıştığımız kopyala-yapıştır çıkmazıdır.
Bir sonraki derste Kalıtım (Inheritance) ile bu tekrarı bitiriyoruz: ortak alanları bir taban sınıfa koyup Ogrenci ve Ogretmen'i oradan türeteceğiz. __init__ ve self'i anladıysan kalıtım senin için sadece bir sonraki adım; hazırsın. Kalıtım, bu seride nesne yönelimini tamamlayan büyük taşlardan biri olacak.







