Sınıf, nesne, self, __init__ ve metotlar

Bu bölümde kendi nesne türlerimizi tanımlayacağız. Örneklerin çoğu bir bankanın hesap programından: her hesabın bir sahibi ve bir bakiyesi var. Geçen hafta böyle bir kaydı sözlükte tuttuk ve iki sorunla karşılaştık: sözlükte hangi anahtarların bulunması gerektiğini ve sözlüğü hangi fonksiyonların değiştirdiğini izlemek zordu. Sınıf (class) ikisini aynı tanımda toplar: bir kaydın bilgilerini tek bir ad altında tutar ve yanlarına o bilgilerle çalışan fonksiyonları koyar. Bilgilerin o anki değerleri nesnenin durumudur, fonksiyonların yaptığı işler de davranışıdır. Sınıftan oluşturulan her nesneye o sınıfın örneği (instance) denir. Her örnek kendi durumunu taşır.

Bu sayfadaki kod hücreleri kendiliğinden çalışmaz. Her hücrede önce çıktıyı tahmin edin, sonra Run Code düğmesine basın. Kodu değiştirip yeniden çalıştırabilir, Start Over ile ilk hâline döndürebilirsiniz.

Bu bölümün kapsamı

NotSınavda sorulur
  • Sınıf ile örnek ayrımı ve class ile tür tanımlama
  • __init__ içinde örnek niteliklerini oluşturma
  • self parametresinin, metodu çağrılan nesne olması
  • Aynı sınıftan oluşturulan nesnelerin örnek niteliklerinin birbirinden bağımsız olması
  • Sınıf niteliği, örnek niteliği ve gölgeleme
  • Paylaşılan değiştirilebilir (mutable) sınıf niteliğinin riski
  • Niteliği doğrudan atamak yerine bir metotla değiştirmenin gerekçesi

İlk sınıfımız

Python’da yeni bir tür class deyimiyle tanımlanır. Hücrede BankAccount sınıfı tanımlanıyor ve Ada için bir hesap açılıyor. İki satır ne yazar?

BankAccount sınıftır. BankAccount("Ada", 500) satırı sınıfı bir fonksiyon gibi çağırır: Python yeni bir nesne oluşturur, __init__ metodunu çalıştırır ve nesneyi döndürür. account adı bu nesneye bağlanır. Sınıfın içine yazılan fonksiyonlara metot denir, __init__ de bir metottur. Yeni nesne oluşturulunca kendiliğinden çalışır ve nesneye ilk değerlerini verir.

self.owner ve self.balance, nesnenin üzerinde taşıdığı adlardır. Bunlara nitelik (attribute) denir. Geçen hafta sözlükten product["stock"] diye okuduğumuz bilgiyi burada account.balance diye okuyoruz. self.owner = owner satırında iki ayrı owner var. Sağdaki owner parametredir, __init__ bitince ortadan kalkar. Soldaki self.owner nesnenin niteliğidir, nesne durdukça kalır. İkisine aynı adı vermek bir alışkanlıktır, Python bunu zorunlu tutmaz.

Not__init__ hazır gelen nesneyi başlatır

Python’da nesne önce oluşturulur, sonra başlatılır. Oluşturma adımını Python kendisi yapar. __init__ ikinci adımdır: hazır gelen nesneyi self parametresiyle alır ve niteliklerine ilk değerlerini verir. __init__ için “yapıcı” (constructor) da denir, ama nesneyi __init__ oluşturmaz.

Üç adımlı akış. Birinci adımda Python boş bir nesne kutusu oluşturur. İkinci adımda __init__ çalışır, self etiketi aynı kutuya bağlıdır ve kutuya owner: Ada ve balance: 500 yazılır. Üçüncü adımda account etiketi kutuya bağlanır.

BankAccount("Ada", 500) satırı üç adımda çalışır. account adı nesneye en son, __init__ bittikten sonra bağlanır.
NotNesneyi print() ile yazdırmak

Hücrenin sonuna print(account) ekleyip çalıştırırsanız <__main__.BankAccount object at 0x...> gibi bir satır görürsünüz. Python nesnenin hangi sınıftan olduğunu ve bir sayı yazar, niteliklerini yazmaz. Nitelikleri account.owner gibi tek tek yazdırın. Nesnenin print() ile nasıl görüneceğini 12. haftada kendiniz belirleyeceksiniz.

self: metodu çağrılan nesne

Hücrede aynı sınıftan iki hesap açılıyor. __init__ iki kez çalışıyor ve iki kez self.owner = owner satırını çalıştırıyor. Ece’nin hesabı açılınca Ada’nın hesabındaki ad değişir mi? İki satır ne yazar?

self, metodu hangi nesne için çağırdıysanız o nesnedir. first = BankAccount("Ada", 500) satırında Python önce yeni bir nesne oluşturur ve onu __init__’e self olarak verir. __init__ bitince nesne first adına bağlanır. second satırında self bu kez başka bir yeni nesnedir. Bu yüzden self.owner = owner ataması her seferinde başka bir nesnenin niteliğini doldurur.

Geçen haftaki sell(product, amount) fonksiyonu hangi kayıtla çalışacağını ilk parametresinden öğreniyordu. self de metodun ilk parametresidir ve aynı işi görür. Fark şu: çağrıda self’i siz yazmazsınız, Python nesneyi kendisi gönderir.

Davranışı sınıfa eklemek

Para yatırma işini sınıfa bir metot olarak ekliyoruz. Hücrede Ada’nın hesabına 50 yatırılıyor. Son satır ne yazar?

Geçen haftaki gibi ayrı bir fonksiyon yazsaydık çağrı deposit(account, 50) olurdu. Metotta account.deposit(50) yazılır ve Python bu çağrıyı BankAccount.deposit(account, 50) gibi çalıştırır: noktanın solundaki nesne self parametresine gider. Kodda ilk biçimi yazarız, ikincisi self’in nereden geldiğini anlamaya yardım eder.

Solda account.deposit(50) çağrısı. Ortada deposit(self, amount) metodu, amount 50 ve self.balance += amount satırı. Sağda tek bir hesap nesnesi kutusu, balance 100'den 150'ye çıkıyor. Kutuya iki etiket bağlı: account ve self.

account.deposit(50) çağrısı sürerken account ve self aynı nesneyi gösterir. Metot bitince self etiketi kalkar, bakiyedeki değişiklik kalır.

deposit metodu sınıfta bir kez yazılır, nesnelerin içinde kopyası yoktur. Ada’nın hesabı da Ece’nin hesabı da aynı deposit metodunu kullanır. Ama self her çağrıda başka bir hesaptır ve her çağrı o hesabın kendi balance niteliğini değiştirir. deposit() metodunu BankAccount sınıfına yazdık, çünkü bakiyeyi değiştirmek hesabın işidir. Bir sınıfın üstlendiği işlere o sınıfın sorumluluğu denir.

Masada iki karton kutu duruyor. Birinin kâğıdında owner: Ada ve balance: 500, ötekinde owner: Ece ve balance: 900 yazıyor. Kutulara iple first ve second etiketleri bağlı. İki kutudan da kırmızı bir ip, kapağında BankAccount yazan mavi bir dosyaya gidiyor. Dosyanın önündeki kartta deposit() ve withdraw() yazıyor.

Mavi dosya BankAccount sınıfıdır: metotlar orada, bir kez yazılı. Kutular bu sınıftan oluşturulmuş iki nesnedir ve her biri kendi niteliklerini taşır. Kırmızı ip nesnenin hangi sınıftan olduğunu gösterir. first ve second adları nesnelere 6. haftadaki gibi etiketle bağlı. AI ile üretilmiş görsel.

Aynı sınıftan bağımsız nesneler

Ada’nın hesabına yatırılan para Ece’nin hesabını değiştirmemeli. Hücrede iki hesap da 100 ile açılıyor. Ada’nın hesabına iki kez 50, Ece’nin hesabına bir kez 20 yatırılıyor. Üç satır ne yazar?

__init__ her nesne için ayrı çalışır ve her nesnenin kendi balance niteliğini oluşturur. Sınıfı iki kez çağırmak iki ayrı nesne verir. 6. haftadaki gibi second = first yazsaydık iki ad aynı hesabı gösterirdi (aliasing: iki adın aynı nesneyi göstermesi) ve first is second True olurdu.

Sınıf niteliği ve örnek niteliği

Bankadaki hesapların para birimi çoğunlukla aynıdır: Türk lirası. Böyle bir bilgiyi her nesneye ayrı ayrı yazmak yerine sınıfa bir kez yazabilirsiniz. Hücredeki BankAccount sınıfında currency sınıfın gövdesinde, owner ise __init__ içinde atanıyor. Hesap nesnelerine currency diye bir nitelik hiç atanmadı. print(ada_account.currency) hata verir mi? Hücre ne yazar?

owner, __init__ içinde self.owner ile atandığı için her hesabın kendisine aittir. Buna örnek niteliği denir. currency ise sınıfın gövdesinde, metotların dışında tanımlanmıştır. Buna da sınıf niteliği denir. ada_account.currency yazdığınızda Python önce ada_account nesnesinde currency adlı bir nitelik arar. Bulamazsa sınıfa bakar ve oradaki değeri verir. Metotlar da aynı yolla bulunur: ada_account.deposit(50) yazınca Python deposit metodunu nesnede bulamaz, sınıfta bulur.

Üstte BankAccount sınıf kutusu, içinde currency = TL ve deposit(). Altta iki hesap nesnesi kutusu, birinde owner Ada ve balance 500, ötekinde owner Ece ve balance 900. Kutulara ada_account ve ece_account etiketleri bağlı. Her nesneden sınıfa doğru kesik bir ok çıkıyor: currency nesnede yok, sınıfta bulunur.

Python bir niteliği önce nesnede arar, bulamazsa sınıfa bakar. İki hesapta da currency yok, ikisi de sınıftaki "TL" değerini okur.

Nitelik gölgeleme (shadowing)

Ada hesabını dolar hesabına çevirmek istiyor. Hücrede yalnız ada_account.currency niteliğine yeni bir değer atanıyor. Üç satır ne yazar?

ada_account.currency = ... sınıf niteliğini değiştirmez, yalnız ada_account nesnesinde aynı adlı bir örnek niteliği oluşturur. Artık ada_account.currency okunurken Python bu niteliği nesnede bulur ve sınıfa hiç bakmaz. Buna gölgeleme (shadowing) denir: nesnedeki nitelik, sınıftaki aynı adlı değeri o nesne için örter. Sınıftaki değeri gerçekten değiştirmek istiyorsanız bunu açıkça BankAccount.currency = ... ile yazın. Bu atamadan sonra kendi currency niteliği olmayan hesaplar yeni değeri görür. ada_account ise kendi niteliğini görmeye devam eder.

Masada iki karton kutu ve arkada kapağında BankAccount yazan mavi bir dosya. Dosyanın önündeki kartta currency: TL yazıyor. Soldaki kutunun kâğıdında owner: Ada ve balance: 500 yazıyor, altına currency: USD yazan sarı bir not yapıştırılmış. Sağdaki kutunun kâğıdında owner: Ece ve balance: 900 yazıyor, sarı not yok. Kutulara ada_account ve ece_account etiketleri bağlı, iki kutudan da dosyaya kırmızı ip gidiyor.

Sarı not yalnız Ada’nın kutusunda: currency: USD artık bu nesnenin kendi niteliğidir ve sınıftaki currency: TL değerini bu nesne için örter. Ece’nin kutusunda böyle bir not yok, Python sınıftaki değeri okur. AI ile üretilmiş görsel.

Paylaşılan değiştirilebilir sınıf niteliği

Her hesabın yatırılan tutarları bir listede tutmasını istiyoruz. Liste sınıf niteliği olarak yazılırsa ne olur? Hücrede yalnız Ada’nın hesabına para yatırılıyor. print(ece_account.transactions) ne yazar?

transactions sınıf niteliği olduğu için iki hesap da aynı listeyi görür. self.transactions.append(...) bir atama değildir, bu yüzden gölgeleme olmaz: sınıftaki tek liste yerinde değişir. Liste değiştirilebilir (mutable) bir nesnedir: içeriği yerinde değişebilir, append() yeni liste oluşturmaz. Her hesabın kendi işlem listesi olsun istiyorsak listeyi __init__ içinde oluştururuz:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []
UyarıDeğiştirilebilir sınıf niteliğine dikkat

Bütün örneklerin gerçekten aynı veriyi görmesi gerekiyorsa sınıf niteliği kullanılabilir. Her nesnenin kendi listesi, sözlüğü ya da kümesi gerekiyorsa bu nesneyi __init__ içinde oluşturun.

Yanlış yazılan nitelik adı hata vermeden yeni nitelik olur

__init__ içinde kurulmamış bir niteliğe değer atarsanız ne olur? Python’da program çalışırken çoğu nesneye yeni nitelik eklenebilir. Hücredeki change_owner() metodu hesabın sahibini değiştirmek için yazıldı. Son satır ne yazar?

change_owner() içindeki ad owner değil ower. self.ower = new_owner satırı hata vermez, yanlış adla yeni bir nitelik oluşturur ve owner olduğu gibi kalır. Hatayı ancak sonuç yanlış çıkınca fark edersiniz. Bu bir mantık hatasıdır.

UyarıBütün nitelikleri __init__ içinde oluşturun

Nesnede bulunması gereken bütün nitelikleri __init__ içinde atayın, öteki metotlarda yeni nitelik oluşturmayın. Böylece bir nesnenin hangi nitelikleri olduğunu tek bir yerde görürsünüz. Nitelik adını elle yazmak yerine editörün önerdiği tamamlamayı kullanın.

Sorumluluğu doğru yere koymak

6. haftada para çekme kuralını withdraw fonksiyonuna yazmıştınız. Aynı if ve raise satırları metoda da yazılır, yalnız sözlüğün yerini self alır. Hücrede Ada’nın hesabında 100 var. Önce metotla, sonra doğrudan atamayla 500 çekiliyor. İki satır ne yazar?

Bakiye yetmeyince metot çekimi reddeder. Para çekmenin kuralı hesabın içinde, tek bir yerde yazılı: para çekmek hesabın sorumluluğudur. Bakiyeyi değiştiren her kod bu metodu çağırırsa kural her seferinde denetlenir. Son satır ise metodu atlar ve bakiye eksiye düşer. Python bu satırı durdurmaz. Gelecek hafta niteliği doğrudan değiştiren kodu da kurala bağlayacağız.

Metodun üstündeki @ satırları

Bu bölümde yazdığımız metotların hepsi örnek metodudur: ilk parametreleri self olur ve account.deposit(50) gibi bir nesneyle çağrılırlar. İnternetteki örneklerde bazı metotların üstünde @ ile başlayan bir satır görürsünüz. Bu satıra dekoratör (decorator) denir. Dekoratör, hemen altındaki fonksiyonun ya da metodun nasıl çalışacağını değiştirir. Ayrıntısını ilerleyen haftalarda göreceğiz: 8. haftada @property, 11. haftada @abstractmethod dekoratörünü kullanacağız. Sınıflarda sık görülen iki dekoratör şunlar:

class User:
    @classmethod
    def from_text(cls, text):
        ...

    @staticmethod
    def is_valid_name(name):
        ...
  • @classmethod ile yazılan metot ilk parametre olarak nesneyi değil, sınıfın kendisini (cls) alır. Nesneyi başka bir biçimden, örneğin bir metin satırından oluşturan metotlarda kullanılır.
  • @staticmethod ile yazılan metot ne self ne cls alır. Nesnenin verisini kullanmayan, ama sınıfla ilgili olduğu için sınıfın içine yazılan yardımcı fonksiyonlarda kullanılır.

Bu haftanın işleri yan yana

Bu haftaki işleri önceki haftalarda nasıl yapardık, bu hafta nasıl yapıyoruz:

İş Önceki haftalarda Bu haftaki Python yolu Dikkat
Sahibin adını ve bakiyeyi bir arada tutan hesap açmak Sözlük: {"owner": "Ada", "balance": 500} class BankAccount ve __init__, sonra BankAccount("Ada", 500) __init__ nesneyi oluşturmaz, hazır gelen nesneye ilk değerlerini verir. Adın iki yanında ikişer alt çizgi vardır
Para yatırmak Sözlüğü parametre olarak alan fonksiyon: deposit(account, 50) account.deposit(50): Python hesabı self olarak gönderir Metot tanımında self unutulursa çağrı TypeError verir
Ada’nın ve Ece’nin hesaplarını birbirinden ayrı tutmak İki ayrı sözlük Sınıfı iki kez çağırmak: BankAccount("Ada", 500) ve BankAccount("Ece", 900) ece = ada yeni hesap açmaz, aynı nesneye ikinci bir ad verir
Bütün hesaplarda aynı olan bilgiyi tek yerde tutmak Fonksiyonların dışında, modülde bir değişken Sınıf niteliği: sınıf gövdesinde currency = "TL" Nesne üzerinden atama sınıf niteliğini değiştirmez, gölgeler. Liste gibi değiştirilebilir değerleri __init__ içinde oluşturun
Para çekme kuralını tek yerde tutmak withdraw(account, 100) fonksiyonu, ama account["balance"] -= 100 yazan kodu hiçbir şey durdurmaz account.withdraw(100) metodu: kural hesabın içinde Python account.balance -= 100 satırını da durdurmaz

İlk üç satırda sözlük ve onu alan fonksiyonlar tek bir sınıf tanımına dönüştü: sözlüğün anahtarları nitelik oldu, fonksiyonun kayıt parametresi self oldu. Bütün hesaplarda aynı olan bilgi modüldeki bir değişkende dursaydı hangi sınıfa ait olduğu anlaşılmazdı. Sınıf niteliği bu bilgiyi sınıfın kendisinde tutar. Para çekmede bir eksik kalıyor: kural withdraw metodunda duruyor, ama niteliği doğrudan değiştiren kodu Python durdurmuyor. Gelecek hafta bunu nasıl önleyeceğimizi göreceğiz.

Alıştırmalar

İndirim metodunu tamamla

apply_discount(rate) metodu ürünün fiyatını verilen oranda indirsin: rate değeri 0.10 olduğunda fiyat yüzde 10 azalır. Boşluğa tek satır yazın. Metot bir değer döndürmesin, self.price niteliğini değiştirsin. Hücrede 1000 liralık klavyeye yüzde 10 indirim uygulanıyor, son satır 900.0 yazmalı. Run Code sonucu başka fiyat ve oranlarla da denetler.

self.price *= (1 - rate)

self hatasını bul

Bu hücredeki metot tanımında bilerek bir hata bırakıldı. Hücrenin sonuna door = Door() ve door.open() satırlarını ekleyin. Çalıştırmadan önce ne olacağını tahmin edin, sonra çalıştırıp hata mesajını okuyun. Ardından metot tanımındaki eksikliği düzeltin ve sona print(door.is_open) satırını ekleyin: son satır True yazmalı.

Gölgelemeden sonra sınıf niteliğini değiştir

Ürünlerin çoğunda KDV oranı yüzde 20, ekmekte yüzde 1. Hücrede önce yalnız ekmeğin oranı değiştiriliyor, sonra sınıftaki oran 18 yapılıyor. Üç satırı tahmin edin, sonra çalıştırın. Ardından bread nesnesinin sınıftaki değişikliği neden görmediğini bir cümleyle açıklayın.

1, 18, 18. bread.tax_rate = 1 ataması bread nesnesinde bir örnek niteliği oluşturdu. Python bread.tax_rate okunurken bu niteliği nesnede bulur ve sınıfa bakmaz. pen nesnesinde böyle bir nitelik yok: Python sınıfa bakar ve yeni değeri bulur.

Book sınıfı

Programı VS Code’da kitap.py adlı bir dosyaya yazıp çalıştırın. Book(title, author) çağrısıyla kitap oluşturulsun. Her kitabın title, author ve is_borrowed örnek nitelikleri olsun. Üçünü de __init__ içinde oluşturun, is_borrowed başlangıçta False olsun. borrow() metodu kitabı ödünç verilmiş, return_book() metodu iade edilmiş duruma getirsin.

Şimdilik aynı kitabın iki kez ödünç alınmasını engellemiyoruz. Bu tür geçersiz durumları gelecek hafta engelleyeceğiz.

Çalışır kod görevi: En az iki Book nesnesi oluşturun. İki kitap başlangıçta ödünçte olmasın. İlk kitap ödünç alınınca yalnız onun is_borrowed değeri True olsun, öteki kitabınki False kalsın. İade edilince yeniden False olsun. Her adımda iki kitabın is_borrowed değerini assert ile denetleyin.

Sınav provası

Önce kendi cevabınızı seçin; sonra cevap anahtarında her şıkkın neden doğru veya yanlış olduğunu okuyun. Çeldiriciler uydurma değil, bu konuda gerçekten yapılan hatalardır. Sınav soruları da bu mantıkla yazılır.

1. Sınıf ile nesne (örnek) arasındaki fark nedir?

  • A. Sınıf veriyi, nesne davranışı tutar
  • B. Nesne sınıfın kopyasıdır; sınıf değişirse nesne değişmez
  • C. Her sınıftan tek bir nesne oluşturulur
  • D. Sınıf kod yazılırken, nesne program çalışırken var olur
  • E. Sınıf türü tanımlar; nesne o türün bir örneğidir

2. __init__ metodu ne yapar?

  • A. Nesne silinirken çalışır ve kaynakları serbest bırakır
  • B. Her metot çağrısından önce çalışır ve nitelikleri ilk değerlerine döndürür
  • C. Nesneyi yoktan yaratır ve belleği ayırır
  • D. Yeni oluşturulan örneğe ilk nitelik değerlerini verir
  • E. Sınıf niteliklerini tanımlar

3. Aşağıdaki sınıfta reset() çağrıldıktan sonra balance neden hâlâ 100’dür?

class Account:
    def __init__(self):
        self.balance = 100

    def reset(self):
        self.blance = 0
  • A. reset() metodu self almadığı için çalışmaz
  • B. self.blance yeni bir nitelik oluşturur ve balance değişmez
  • C. balance __init__ içinde tanımlandığı için salt okunurdur
  • D. AttributeError yükselir ve atama yapılmaz
  • E. Metot içinde nitelik değiştirmek için global bildirimi gerekir

4. Bir metodun içinde self hangi nesneyi gösterir?

  • A. Metodun çağrıldığı nesneyi
  • B. Sınıfın bütün örneklerini
  • C. Son oluşturulan örneği
  • D. Sınıfın kendisini
  • E. Hiçbirini; self bir anahtar sözcüktür

5. Aşağıdaki sınıfta Lamp().turn_on() çağrısı ne yapar?

class Lamp:
    def __init__(self):
        self.is_on = False

    def turn_on():
        self.is_on = True
  • A. TypeError yükselir; metotta örneği alacak parametre yoktur
  • B. NameError yükselir; self tanımsızdır
  • C. Metot tanımı söz dizimi hatası verir
  • D. Sorunsuz çalışır; self metot içinde kendiliğinden tanımlıdır
  • E. is_on değerini True yapar ama başka örnekleri etkilemez

6. Aşağıdaki program ne yazdırır?

class Counter:
    def __init__(self):
        self.value = 0

    def increment(self):
        self.value += 1

first = Counter()
second = Counter()
first.increment()
first.increment()
second.increment()

print(first.value, second.value)
  • A. 3 3
  • B. 1 1
  • C. 2 2
  • D. 0 0
  • E. 2 1

7. Aşağıdaki program ne yazdırır?

class Student:
    school = "Merkez MYO"

    def __init__(self, name):
        self.name = name

ada = Student("Ada")
ece = Student("Ece")
ada.school = "Başka MYO"

print(ada.school, ece.school, Student.school)
  • A. AttributeError; sınıf niteliği örnek üzerinden değiştirilemez
  • B. Başka MYO Merkez MYO Merkez MYO
  • C. Başka MYO Başka MYO Merkez MYO
  • D. Üç değer de Merkez MYO
  • E. Üç değer de Başka MYO

8. Student sınıfının gövdesinde school = "Merkez MYO" satırı var ve ada bu sınıfın bir örneği. Hiçbir örnekte school adlı bir örnek niteliği yok. Sınıftaki ortak school değerini değiştirmek için hangisi yazılmalıdır?

  • A. global school bildirip atamak
  • B. Student.school = "Yeni MYO"
  • C. Student("Can").school = "Yeni MYO"
  • D. ada.school = "Yeni MYO"
  • E. self.school = "Yeni MYO" (herhangi bir metot içinde)

9. Aşağıdaki program ne yazdırır?

class Team:
    members = []

    def __init__(self, name):
        self.name = name

first = Team("A")
second = Team("B")
first.members.append("Ada")

print(second.members)
  • A. ['Ada', 'Ada']
  • B. []
  • C. None
  • D. ['Ada']
  • E. AttributeError

10. Her takımın bağımsız bir üye listesine sahip olması için sınıf nasıl yazılmalıdır?

  • A. __init__ içinde self.members.clear() çağrılmalıdır
  • B. members = [] satırı sınıf gövdesinde __init__ tanımından sonraya taşınmalıdır
  • C. Liste __init__ içinde self.members = [] ile oluşturulmalıdır
  • D. Sınıf gövdesinde members = [] yerine self.members = [] yazılmalıdır
  • E. Sınıf gövdesindeki members = [] satırı members = list() yapılmalıdır

11. account.balance -= 100 yerine account.withdraw(100) yazmanın tasarım gerekçesi nedir?

  • A. Python’da nitelikler dışarıdan değiştirilemez
  • B. Doğrudan atama söz dizimi hatası verir
  • C. Para çekme kuralı hesabın metodunda durur
  • D. Metot çağrısı doğrudan atamadan daha hızlı çalışır
  • E. Metot kullanmak nitelik adını gizler

1. Doğru: E. Sınıf, nesnelerin hangi nitelikleri ve metotları olacağını tanımlar. Nesne bu tanımdan oluşturulur ve kendi nitelik değerlerini taşır.

  • A yanlış: Sınıfın veriyi, nesnenin davranışı tuttuğu düşünülebilir. Oysa nesne kendi niteliklerini, yani verisini taşır. Metotlar ise sınıfta yazılıdır.
  • B yanlış: Nesnenin sınıftan “basıldığı” benzetmesi kopya fikrini doğurur. Ama nesne sınıfın kopyası değildir: kendi niteliklerini taşır, metotlarını ve sınıf niteliklerini sınıfta bulur. Sınıftaki bir değer değişirse, o değeri kendisinde taşımayan nesneler yeni değeri görür.
  • C yanlış: İlk örneklerde her sınıftan tek nesne oluşturulduğu için böyle bir sınır sanılabilir. Oysa bir sınıftan istediğiniz kadar nesne oluşturabilirsiniz.
  • D yanlış: Sınıfı kodda yazdığımız, nesneyi ise program çalışırken oluşturduğumuz için sınıfın yalnız kodda var olduğu sanılabilir. Oysa class satırı da program çalışırken çalışan bir deyimdir: sınıf o satır çalışınca oluşur.

2. Doğru: D. Python’da nesne önce oluşturulur, sonra başlatılır. __init__ ikinci adımdır; self ile örneğin niteliklerine ilk değerlerini verir.

  • A yanlış: Nesnenin ömrünün iki ucu, başlangıç ve bitiş, kolayca karıştırılır. Ama __init__ nesne oluşturulduğunda çalışır ve başlangıç niteliklerini ayarlar. Nesnenin ömrünün sonundaki işlerle ilgisi yoktur.
  • B yanlış: __init__ her nesnede kendiliğinden çalıştığı için her işlemde yeniden çalıştığı sanılabilir. Ama __init__ yalnız nesne oluşturulurken bir kez çalışır. deposit() gibi çağrılar onu yeniden çalıştırmaz.
  • C yanlış: “Yapıcı” adı nesneyi bu metodun kurduğu izlenimini verir. Ama nesneyi oluşturmak ayrı bir adımdır; __init__ hazır gelen nesneyi başlatır.
  • E yanlış: __init__ sınıfın içinde yazıldığı için sınıf düzeyinde iş yaptığı sanılabilir. Ama sınıf nitelikleri sınıf gövdesinde tanımlanır; __init__ örneğin niteliklerini kurar.

3. Doğru: B. Python program çalışırken nesneye yeni nitelik eklenmesine izin verir. Bu yüzden yanlış yazılmış ad hiçbir uyarı vermeden yeni bir nitelik olur; hata ancak sonuç yanlış çıkınca fark edilir.

  • A yanlış: Metotlarda self unutmak sık yapılan bir hata olduğu için sorunun bu olduğu düşünülebilir. Ama bu sınıfta self parametresi iki metodun tanımında da vardır.
  • C yanlış: Başlangıç değerinin __init__ içinde sabitlendiği düşünülebilir. Oysa __init__ içinde kurulan nitelikler sonradan değiştirilebilir.
  • D yanlış: Yanlış yazılmış bir adın hata vermesi beklenir. Ama AttributeError olmayan bir niteliği okurken çıkar; olmayan bir niteliğe değer atamak ise yeni nitelik oluşturur.
  • E yanlış: Fonksiyon içinden dış bir adı değiştirmek için global gerektiği bilgisi buraya taşınabilir. Ama global modül düzeyindeki adlar içindir; nitelikler self üzerinden yazılır.

4. Doğru: A. first.deposit(50) çağrısında self → first; second.deposit(50) çağrısında self → second olur.

  • B yanlış: Metot sınıfta bir kez yazıldığı için bütün örneklere birden etki ettiği düşünülebilir. Ama self yalnız metodun çağrıldığı tek nesnedir. Öteki örnekler etkilenmez.
  • C yanlış: Örneklerde metot çoğu zaman son oluşturulan nesneyle çağrıldığı için böyle sanılabilir. Ama self, nesnelerin oluşturulma sırasına bakmaz: noktanın solundaki nesnedir.
  • D yanlış: Metot sınıfın içinde yazıldığı için self’in sınıfı gösterdiği sanılabilir. Ama self bir nesnedir. Sınıfın kendisini alan parametre cls’tir ve @classmethod ile kullanılır.
  • E yanlış: self her metotta aynı adla yazıldığı için anahtar sözcük sanılabilir. Ama self geleneksel bir parametre adıdır; yerine başka bir ad da yazılabilir.

5. Doğru: A. Python çağrıda yeni lamba nesnesini ilk argüman olarak gönderir, ama metodun hiç parametresi yoktur. Argüman sayısı tutmadığı için hata, gövde çalışmadan çıkar.

  • B yanlış: Gövdede tanımsız bir self kullanıldığı için bu hata akla yatkındır. Ama hata, gövdeye hiç girilmeden, argümanlar parametrelerle eşleştirilirken çıkar.
  • C yanlış: Parametresiz bir metot tanımı yanlış göründüğü için hatanın tanımda çıkacağı düşünülebilir. Ama tanım geçerlidir; sorun çağrı anında ortaya çıkar.
  • D yanlış: self her metotta kullanıldığı için dilin ayırdığı bir ad gibi görünür. Ama self sihirli bir ad değildir; parametre olarak yazılmalıdır.
  • E yanlış: Metodun adı ve gövdesi niyeti açıkça gösterdiği için çalışacağı sanılabilir. Ama gövde hiç çalışmaz.

6. Doğru: E. value her örnekte __init__ içinde ayrı ayrı kurulur; sayaçlar bağımsızdır.

  • A yanlış: Üç increment() çağrısının tek bir ortak sayacı artırdığı düşünülürse bu sonuç beklenir. Ama value her nesnede __init__ içinde ayrı kurulur. first ile second ayrı sayaçlardır.
  • B yanlış: Her nesnenin bir kez artırıldığı sanılabilir. Ama first için increment() iki kez çağrılmıştır.
  • C yanlış: İki nesne aynı sınıftan olduğu için aynı değeri taşıdığı sanılabilir. Ama second yalnız bir kez artırılmıştır.
  • D yanlış: __init__ her seferinde value niteliğini 0 yaptığı için değerin sıfırda kaldığı sanılabilir. Ama __init__ yalnız nesne oluşturulurken çalışır. increment() çağrıları niteliği gerçekten değiştirir.

7. Doğru: B. ada.school = ... yalnızca ada örneğinde aynı adlı bir nitelik oluşturur ve sınıftaki değeri o nesne için gölgeler. Sınıf ve diğer örnek etkilenmez.

  • A yanlış: Sınıf niteliğinin nesne üzerinden değiştirilemeyeceği bilgisi, atamanın hata vereceği düşüncesine dönüşebilir. Ama atama hata vermez, yeni bir örnek niteliği oluşturur.
  • C yanlış: ada ile ece aynı sınıftan olduğu için birine yapılan atamanın ötekine de geçtiği sanılabilir. Ama ece kendisinde school niteliği taşımaz ve sınıftaki değeri görür.
  • D yanlış: Sınıf niteliğinin nesne üzerinden değişmediği bilindiği için atamanın hiçbir etkisi olmadığı sanılabilir. Ama ada.school okunurken ada nesnesine atanan yeni nitelik bulunur.
  • E yanlış: school sınıfta tanımlandığı için nesne üzerinden yapılan atamanın sınıfa ulaştığı sanılabilir. Ama atama yalnız ada nesnesinde bir nitelik oluşturur. Sınıftaki değer ancak Student.school = ... ile değişir.

8. Doğru: B. Sınıf niteliği sınıfın adıyla değiştirilir. Bu niteliği gölgelemeyen bütün örnekler yeni değeri görür.

  • A yanlış: Fonksiyon içinden dış bir adı değiştirmek için global gerektiği bilgisi buraya taşınabilir. Ama global modül düzeyindeki adlar içindir, sınıf niteliğine erişmez.
  • C yanlış: Satırda sınıf adı geçtiği için sınıfı değiştirdiği sanılabilir. Ama Student("Can") yeni bir örnek oluşturur ve atama yalnız o örneği etkiler.
  • D yanlış: ada.school okunurken sınıftaki değer geldiği için atamanın da sınıfa gittiği sanılabilir. Ama atama yalnız ada örneğinde gölgeleyen bir nitelik oluşturur.
  • E yanlış: Atama sınıfın bir metodunda yazıldığı için sınıfı değiştirdiği sanılabilir. Ama self bir nesnedir: self.school ataması da o nesnede bir örnek niteliği oluşturur.

9. Doğru: D. first.members.append(...) yeni bir nitelik oluşturmaz, sınıftaki listeyi yerinde değiştirir. first.members is second.members sonucu True’dur.

  • A yanlış: İki nesne aynı listeyi gördüğü için eklemenin iki kez yapıldığı sanılabilir. Ama tek bir append çağrısı vardır ve liste de tektir.
  • B yanlış: first ile second ayrı nesneler olduğu için listelerinin de ayrı olduğu sanılabilir. Ama members sınıfta duran tek bir listedir ve iki nesne de onu görür.
  • C yanlış: append() metodunun None döndürdüğü bilgisi listenin None olduğu düşüncesine dönüşebilir. Ama append() listeyi yerinde değiştirir, members hâlâ bir listedir.
  • E yanlış: second nesnesine members diye bir nitelik hiç atanmadığı için hata beklenebilir. Ama örnekte olmayan ad sınıfta aranır ve bulunur.

10. Doğru: C. Böylece her yeni takım için ayrı bir liste oluşturulur ve takımlar aynı listeyi paylaşmaz.

  • A yanlış: Her yeni takımın boş listeyle başlaması sorunu çözüyor gibi görünür. Ama self.members hâlâ sınıftaki ortak listedir; yeni bir takım oluşturmak öteki takımların üyelerini de siler.
  • B yanlış: __init__’ten sonra yazılan satırın her örnekte çalışacağı düşünülebilir. Ama satır hâlâ sınıf gövdesindedir, metodun içinde değildir; yine bir kez çalışır ve ortak bir sınıf niteliği oluşturur.
  • D yanlış: self. öneki niteliği örneğe bağladığı için bu yazım doğru görünür. Ama sınıf gövdesinde self diye bir ad yoktur; self yalnız metotların parametresidir. Satır NameError verir.
  • E yanlış: list() bir çağrı olduğu için her örnekte yeni liste vereceği sanılabilir. Ama list() de tek bir liste oluşturur; satır sınıf gövdesinde olduğu için yine yalnız bir kez çalışır.

11. Doğru: C. Bakiyeyi doğrudan değiştiren her kod parçası kuralı kendisi yeniden yazmak zorunda kalır. Metot ise kuralı nesnenin içinde, tek yerde tutar; kontrol orada yapılır.

  • A yanlış: Metot kullanma önerisi, dilin doğrudan atamayı yasakladığı izlenimini verir. Oysa nitelikler değiştirilebilir; dil engel olmadığı için bu kararı tasarımda vermek gerekir.
  • B yanlış: Önerilmeyen bir yazımın geçersiz olduğu düşünülebilir. Ama söz dizimi doğrudur; sorun tasarımdadır.
  • D yanlış: Metot çağrısı daha düzenli göründüğü için daha verimli sanılabilir. Ama hız farkı konu değildir; gerekçe, kuralın hangi nesnede durduğudur.
  • E yanlış: Nitelik adı artık çağrıda görünmediği için gizlenmiş gibi durur. Ama ad gizlenmez; değişiklik bu kez metodun içinden yapılır.

Tek sayfa özet

  • Sınıf bir tür tanımıdır. Sınıftan oluşturulan nesneye o sınıfın örneği denir: BankAccount("Ada", 500).
  • __init__ yeni nesnenin niteliklerine ilk değerlerini verir. Nesneyi oluşturmaz, hazır gelen nesneyi başlatır.
  • self.owner = owner satırında sağdaki owner parametredir, soldaki self.owner nesnenin niteliğidir.
  • self metodun çağrıldığı nesnedir. Metodun ilk parametresidir, ama çağrıda yazılmaz: account.deposit(50), BankAccount.deposit(account, 50) gibi çalışır.
  • Metotlar sınıfta bir kez yazılıdır. Her nesne kendi örnek niteliklerini taşır, bir nesnenin balance niteliğini değiştirmek ötekini etkilemez.
  • Python bir niteliği ya da metodu önce nesnede, bulamazsa sınıfta arar. Sınıf niteliğini, aynı adlı bir örnek niteliği olmayan bütün nesneler sınıftan okur.
  • Bir nesneye sınıf niteliğiyle aynı adlı bir nitelik atamak, o nesne için sınıftaki değeri gölgeler. Sınıf niteliğini sınıfın adıyla değiştirin.
  • Sınıf niteliği bir liste ise bütün nesneler aynı listeyi görür. Her nesnenin kendi listesi gerekiyorsa listeyi __init__ içinde oluşturun.
  • Python program çalışırken nesneye yeni nitelik eklenmesine izin verir. Yanlış yazılmış bir nitelik adı hata vermeden yeni bir nitelik oluşturur.
  • Bir işin kuralını o işi yapan metoda yazın: para çekme kuralı withdraw içinde durur. Bir metodu hangi sınıfa yazacağınıza karar verirken şunu sorun: bu iş hangi nesnenin sorumluluğu?
  • Metodun üstündeki @ satırı bir dekoratördür ve altındaki metodun nasıl çalışacağını değiştirir.

Bu bölümün kazanımları

Bu bölümü bitiren öğrenci:

  • Sınıf ile örnek ayrımını açıklar ve class ile kendi türünü tanımlar.
  • __init__ içinde örnek niteliklerini oluşturur.
  • self parametresinin, metodu çağrılan nesne olduğunu açıklar.
  • Aynı sınıftan oluşturulan nesnelerin örnek niteliklerinin birbirinden bağımsız değiştiğini açıklar.
  • Sınıf niteliği ile örnek niteliğini ayırt eder ve gölgelemenin sonucunu açıklar.
  • Paylaşılan değiştirilebilir sınıf niteliğinin riskini açıklar ve koleksiyonu __init__ içinde oluşturur.
  • Niteliği doğrudan atamak yerine bir metotla değiştirmenin gerekçesini açıklar.
Başa dön