Kapsülleme, property ve geçerli durum

Geçen hafta BankAccount sınıfını yazdınız, ama account.balance = -500 gibi bir satırı hiçbir şey durdurmuyordu. Program yine çalışır, ama eksi bakiyeli bir hesapla yanlış sonuç verir. Bu hafta nesnenin kurallarını sınıfın içine yazacağız: kurala uymayan bir değer geldiğinde program hata verecek. Örneklerin çoğu bir kırtasiyenin stok programından: her ürünün adı, fiyatı ve stok sayısı var. 3. haftadaki envanter görevi bir soruyla bitiyordu: “Stok sıfırın altına düşmesin” kuralını nerede koruyoruz? 6. haftada kuralı sell fonksiyonunun içine yazdınız, ama sözlüğü programın her yeri yine değiştirebiliyordu. Üç kavram kullanacağız: değişmez koşul (invariant), kapsülleme (encapsulation) ve property. Üçünü de ilk geçtikleri yerde birer örnekle tanımlayacağız.

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
  • Bir sınıf için değişmez koşul (invariant) yazma
  • Geçersiz başlangıç durumunu __init__ içinde engelleme
  • Kapsüllemenin amacı: erişimi yasaklamak değil, niteliklerin yalnız sınıfın metotlarıyla değişmesi
  • Tek alt çizgi geleneği ve Python’da dışarıdan erişimi engelleyen bir private belirtecinin olmaması
  • property ve setter yazma, üç adın aynı olması
  • Doğrulamayı tek yerde tutmak için __init__ içinde setter’ı kullanmak
  • Önce ön koşulları denetleyip sonra niteliği değiştirmek

Geçersiz ürünü baştan reddetmek

Fiyatın sıfırdan büyük olması ve stoğun eksiye düşmemesi, ürün kullanıldığı sürece her an doğru kalması gereken kurallardır. Böyle bir kurala değişmez koşul (invariant) denir. Niteliklerin değeri değişir, kural değişmez: stok 12 de olabilir 0 da, ama eksi olamaz. Bir banka hesabında balance >= 0, bir ders kaydında 0 <= score <= 100 de birer değişmez koşuldur.

Kuralı ilk denetleyecek yer __init__. __init__ değer döndürmez, kurala uymayan bir değer gelince hatayı raise ile bildirir. Hücrede stoğu -5 olan bir kalem oluşturuluyor. Hücre ne yazar? pen adı bir nesneye bağlanır mı?

7. haftada gördüğünüz gibi Python nesneyi önce oluşturur, sonra __init__ ile başlatır. Yani __init__ çalışırken nesne vardır. raise çalışınca __init__ yarıda kalır ve Product("Kalem", 10, -5) çağrısı nesne döndürmek yerine hata verir. Atama yapılmaz, pen adı hiçbir nesneye bağlanmaz. Başlatılması yarıda kalan nesneye hiçbir ad ulaşmadığı için programın kullandığı her ürün kurala uyar.

Hatayı erken vermek: fail fast

Fail fast (erken hata ver) ilkesi, geçersiz bir değeri ortaya çıktığı anda bildirmeyi önerir. Stoğu -5 olan kalemin daha oluşturulurken hata vermesi, eksi stoğun programda dolaşıp haftalar sonra yanlış bir sipariş raporuna yol açmasından iyidir. Hata, değerin ortaya çıktığı yere yakın verilirse nedeni de kolay bulunur.

Stoğu yalnız metotlar değiştirsin

Stok iki yoldan değişir: mal girişi ve satış. Hücrede ikisi için birer metot var, add_stock ve sell. Stoğu okumak için de stock() metodu var. Kalemin stoğu 5, önce 3 tane ekleniyor, sonra 10 tane satılmak isteniyor. Hücre ne yazar?

İki metot da stoğa dokunmadan önce miktarı denetler, stoğu ancak kural tutuyorsa değiştirir. Kural artık sınıfın içinde, stoğu değiştiren iki metotta yazılı.

Niteliğin adı da değişti: stock yerine _stock. Bu alt çizginin ne işe yaradığına sıradaki başlıkta bakacağız.

Tek alt çizgi: “dışarıdan dokunmayın”

Bazı dillerde bir nitelik private diye işaretlenir ve ona sınıfın dışından erişim tamamen engellenir. Python’da böyle bir belirteç yok. _stock adının başındaki tek alt çizgi bir adlandırma geleneğidir (convention). Python programcıları bu işareti şöyle okur: “Bu nitelik sınıfın iç ayrıntısıdır, dışarıdan dokunmayın.”

Python bu geleneği zorlar mı? Hücrede kalem 5 stokla oluşturuluyor, sonra dışarıdaki kod _stock niteliğine -5 atıyor. Bu atama hata verir mi? Son satır ne yazar?

__init__ içindeki kontrol yalnız nesne oluşturulurken bir kez çalışır. Sonraki atamayı denetleyen bir kod yok ve Python alt çizgili bir ada dışarıdan atama yapılmasını engellemez.

Nesne durumu yalnızca kurallı davranışlarla değiştiğinde invariantın korunduğunu gösteren diyagram.

Kapsülleme ve invariant
ÖnemliKuralı metotlar ve programcılar korur

Bir nesnenin dışarıdaki koda açtığı metot ve niteliklere o nesnenin arayüzü denir. Kapsülleme, niteliklerin yalnız arayüzdeki metotlarla, kurala uyarak değişmesidir. Python bunu bir erişim engeliyle sağlamaz. Kuralı programcılar korur: alt çizgili adlara dışarıdan dokunmaz, niteliği sınıfın metotlarıyla değiştirirler.

Çift alt çizgi ve ad dönüştürme

__stock gibi iki alt çizgiyle başlayan bir ad, sınıf gövdesinde Python’ın o adı değiştirmesine yol açar. Buna ad dönüştürme (name mangling) denir:

class Product:
    def __init__(self):
        self.__stock = 5

Python bu adı _Product__stock biçimine dönüştürür. Bu dönüşüm niteliği gizlemek ya da korumak için yapılmaz. Bir sınıftan yeni bir sınıf türetildiğinde (buna kalıtım denir, 10. bölümde göreceğiz) iki sınıftaki aynı adlı niteliklerin yanlışlıkla çakışmasını önler.

Uyarı__x gerçek anlamda private değildir

Dönüştürülmüş ada pen._Product__stock yazarak yine erişebilirsiniz. Çift alt çizgili bir nitelik için “kimse erişemez” demek bu yüzden yanlıştır. Bu derste sınıfın iç verisi için tek alt çizgi (_stock) kullanacağız. __x biçiminde bir ad gördüğünüzde Python’ın bu adı dönüştürdüğünü hatırlayın.

Fiyatı kurala uyarak değiştirmek: property

Stoğu pen.stock() diye, parantezle okuyoruz. Fiyat ise düz bir nitelik: pen.price = -12 satırını hiçbir şey durdurmaz. Fiyatın pen.price diye okunmasını, ama yalnız kurala uyan değerlerle değişmesini istiyoruz. Python’da bunun aracı property’dir: dışarıdan nitelik gibi görünen, ama okununca ya da atanınca bir metot çalıştıran ad.

Önce okuma tarafına bakalım. 7. haftada @classmethod için gördüğünüz gibi, @property de bir dekoratördür. Bir metodun üstüne yazılınca o metot parantezsiz çağrılır:

@property
def stock(self):
    return self._stock

@property ile işaretlenen metot değer okunurken çalışır. Buna getter denir. Artık pen.stock() yerine pen.stock yazarız. Değer atanırken çalışan metoda ise setter denir. Hücredeki sınıfta stock için setter yok. print(pen.stock) ne yazar? Son satırda ne olur?

Setter’ı olmayan bir property’ye değer atanamaz. Stok için istediğimiz de bu: stok yalnız add_stock ve sell yoluyla değişsin.

property ve setter'ın bir niteliği okumak ve değiştirmek için kontrollü bir arayüz oluşturduğunu gösteren diyagram.

property erişim kapısı

Fiyat ise değişebilmeli, ama yalnız kurala uyarak. Bunun için setter yazılır. Hücredeki pen.price = 12 ve pen.price = -12 satırları setter’ı çalıştırır. İlk print() ne yazar? Son satır çalışır mı?

pen.price = -12 sıradan bir atama gibi görünür, ama Python bu atamayı setter’a gönderir. Setter kurala uymayan değeri reddeder ve _price eski değerinde kalır.

Setter söz diziminde üç ad aynı olmalıdır

Yukarıdaki örnekte şu üç satıra dikkat edin:

@property
def price(self):
    ...

@price.setter
def price(self, value):
    ...

Dışarıdan kullanılan ad price ise getter metodunun adı, @price.setter dekoratöründeki ad ve setter metodunun adı da price olmalıdır. Setter metoduna farklı bir ad vermek bu konuda en sık yapılan hatalardandır.

__init__ neden setter’ı kullanıyor?

Son hücredeki __init__, fiyatı self._price = price diye değil self.price = price diye atıyor. __init__ içinde hiç if yok. Product("Klavye", -100) hata verir mi?

__init__ içindeki self.price = price ataması da setter’dan geçer. Böylece başlangıçtaki fiyat da sonraki fiyat atamaları da aynı kuraldan geçer.

ÖnemliTek doğrulama noktası

Aynı kuralı __init__ içinde bir kez, setter içinde bir kez daha yazarsanız ikisi kolayca birbirini tutmaz hâle gelir: birini güncelleyip ötekini unutursunuz. Niteliği dışarıdan değiştirmenin yolu setter’sa __init__ de ilk değeri o setter’la atasın. Kural değişirse yalnız setter’ı güncellersiniz.

Yarım güncelleme tehlikesi

Satış metodunu bu kez başka bir sırayla yazalım: stok önce azaltılıyor, kontrol sonra yapılıyor. Kalemin stoğu 3, 5 tane satılmak isteniyor ve satış hata veriyor. Son satır kaç yazar?

Kontrol hata verdiğinde _stock çoktan eksiye düşmüştür ve öyle kalır. raise o ana kadar yapılan değişikliği geri almaz. Ürün yarım güncellenmiş, kurala uymayan bir durumda kalır.

Bir işlemin yapılabilmesi için önceden doğru olması gereken koşula ön koşul denir. Burada ön koşul, stoğun satılan miktara yetmesidir. Güvenli sıra şudur:

  1. Bütün ön koşulları denetle.
  2. Sonra durumu değiştir.

“Stoğu yalnız metotlar değiştirsin” başlığındaki sell bu sırayı izliyordu. İki nesneyi birlikte değiştiren işlemlerde sıra daha da önemlidir. Bir hesaptan ötekine para aktaran metot kontrolü arada yaparsa, hata anında para bir hesaptan çıkmış, öteki hesaba girmemiş olur. Bu sırayı dönem boyunca kullanacağız.

Bu haftanın işleri yan yana

Stok programındaki kuralları önceki haftalarda nasıl korurduk, bu hafta nasıl koruyoruz:

Kural Önceki haftalarda Bu haftaki Python yolu Dikkat
Geçersiz ürün kaydedilmesin __init__ gelen değeri denetlemeden niteliğe yazar __init__ içinde raise ValueError(...) __init__ değer döndürmez, hatayı raise ile bildirir
Stok yalnız satışla ve mal girişiyle değişsin sell() ve add_stock() fonksiyonları if ile denetler sell() ve add_stock() metotları, _stock niteliği Stoğu okumak için setter’ı olmayan bir stock property’si yeter
Öteki kod stoğu doğrudan değiştiremesin Yapılamaz: sözlükteki ya da nitelikteki değeri her kod değiştirebilir Tek alt çizgi: _stock Python da engellemez, pen._stock = -5 çalışır
Fiyat sonradan değişince de denetlensin set_price() fonksiyonu yazılır, herkesin onu çağırdığına güvenilir @property ve @price.setter, __init__ içinde self.price = price Getter, @price.setter ve setter aynı adı taşır
Satış hata verirse ürün eski hâlinde kalsın Önce if ile denetlenir, sonra alan değiştirilir Aynı sıra: önce ön koşullar, sonra atama raise yapılmış değişikliği geri almaz

Öteki kodun stoğu doğrudan değiştirmesini Python engellemez: alt çizgi bir engel koymaz, programcılara “dokunmayın” der. Kuralı korumanın yolu, niteliği yalnız sınıfın metotlarıyla değiştirmektir. Fiyat için ayrı bir set_price() metodu yazsaydınız herkesin onu çağıracağına güvenmek zorunda kalırdınız. Setter aynı denetimi yapar, üstelik dışarıdaki kod sıradan bir atama yazar ve bu atama yine setter’dan geçer.

3. haftadaki soruya da artık cevap verebiliriz. Stok bir sözlükte dururken “stok sıfırın altına düşmesin” kuralı, sözlüğü değiştiren her satırda ayrı ayrı korunmak zorundaydı. Şimdi kural Product sınıfında, __init__ ve sell içinde yazılı. Stoğu değiştirmek isteyen kod bu metotları çağırır ve kural her seferinde denetlenir.

Alıştırmalar

Invariant belirle

Aşağıdaki sınıfların her biri için en az iki invariant yazın:

  • Student
  • BankAccount
  • Reservation

Puan aralığı, bakiyenin eksiye düşmemesi ya da tarihlerin sırası gibi kurallar düşünebilirsiniz.

Güvenli withdraw

7. haftadaki withdraw metodu yalnız bakiyenin tutara yetip yetmediğine bakıyordu. Bu kez bakiye _balance niteliğinde duruyor ve dışarıdan balance property’siyle okunuyor. Boşluğa iki kontrol yazın: tutar pozitif olmalı ve bakiye tutara yetmeli. Kural bozulursa metot ValueError yükseltsin. İki kontrol de bakiyeyi azaltan satırdan önce gelmeli.

if amount <= 0:
    raise ValueError("Tutar pozitif olmalı")
if amount > self._balance:
    raise ValueError("Yetersiz bakiye")

Property mi metot mu?

Aşağıdaki dört yazımı karşılaştırın:

  • account.balance
  • account.withdraw(100)
  • rectangle.area
  • order.cancel()

Hangileri nesnenin verisinden hesaplanan bir değer gibi, hangileri nesneye verilen bir komut gibi okunuyor? Python’da her şeyi property yapmanız gerekmez, her değeri bir get_...() metoduyla okumanız da gerekmez. Arayüzü, kodu okuyan kişi neyin değer, neyin eylem olduğunu hemen anlayacak biçimde kurun.

Güvenli kitap

7. haftada yazdığınız Book sınıfı aynı kitabın iki kez ödünç alınmasını engellemiyordu. Şimdi engelleyin. Book sınıfı şu kuralları korusun:

  • title boş olamaz.
  • is_borrowed dışarıdan okunabilir, ama yalnız borrow() ve return_book() metotlarıyla değişir.
  • Ödünçteki kitap yeniden ödünç alınamaz.
  • Ödünçte olmayan kitap iade edilemez.

title niteliğini getter ve setter’ı olan bir property ile yazın. __init__ içinde self.title = title yazarak aynı doğrulamayı yeniden kullanın. is_borrowed için yalnız getter yazın. Kural bozulursa metot ValueError yükseltmeli ve kitabın durumunu değiştirmemeli.

Çalışır kod görevi: En az şu beş durumu çalıştırın: geçerli bir kitap, boş başlıkla oluşturulan kitap, sonradan atanan boş başlık, aynı kitabı iki kez ödünç alma ve ödünçte olmayan kitabı iade etme. Hata veren işlemlerden sonra niteliklerin değişmediğini assert ile doğrulayın.

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. Değişmez koşul (invariant) nedir?

  • A. Sınıfın bütün örneklerinde ortak olan sınıf niteliğidir
  • B. Nesne kullanılırken her zaman doğru olması gereken kuraldır
  • C. Metotların kaç parametre alacağını belirleyen sözleşmedir
  • D. Nesne oluşturulduktan sonra hiç değişmeyen nitelik değeridir
  • E. Programın hiç hata vermeyeceğini garanti eden kontroldür

2. Bir Course nesnesinde capacity dersin kontenjanını, enrolled kayıtlı öğrenci sayısını tutuyor. Bu sınıf için en uygun invariant çifti hangisidir?

  • A. enrolled == 0 ve capacity == 30
  • B. enrolled > 0 ve enrolled < capacity
  • C. capacity >= 0 ve enrolled >= capacity
  • D. capacity ve enrolled hiç değişmez
  • E. capacity >= 0 ve enrolled <= capacity

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

class BankAccount:
    def __init__(self, owner, balance=0):
        if balance < 0:
            raise ValueError("Başlangıç bakiyesi negatif olamaz")
        self.owner = owner
        self.balance = balance

try:
    account = BankAccount("Ada", -100)
except ValueError as error:
    print(error)
  • A. Başlangıç bakiyesi negatif olamaz; account adına nesne bağlanmaz
  • B. 0; negatif değer varsayılana düşer
  • C. Hiçbir şey yazmaz; nesne balance = -100 ile oluşur
  • D. Program çöker; __init__ içinde raise kullanılamaz
  • E. None

4. Aşağıdaki Product sınıfı fiyatı __init__ içinde değil, total() içinde denetliyor. Program hangi satırda hata verir?

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def total(self, quantity):
        if self.price <= 0:
            raise ValueError("Fiyat pozitif olmalı")
        return self.price * quantity

items = []
items.append(Product("Kalem", 10))
items.append(Product("Defter", -5))
print(len(items))
print(items[1].total(3))
  • A. Hata vermez; raise yalnız bir try bloğunun içinde çalışır
  • B. print(len(items)) satırında; listede geçersiz bir ürün vardır
  • C. print(items[1].total(3)) satırında; geçersiz ürün listeye girmiştir
  • D. Hata vermez; son satır -15 yazar
  • E. items.append(Product("Defter", -5)) satırında; nesne oluşturulamaz

5. Python’da kapsülleme temel olarak neyi amaçlar?

  • A. Niteliklere dışarıdan erişimi teknik olarak imkânsız kılmayı
  • B. Niteliklerin yalnız sınıfın metotlarıyla değişmesini
  • C. Bütün nitelikleri salt okunur yapmayı
  • D. Sınıfın kaynak kodunu kullanıcılardan gizlemeyi
  • E. Her niteliğe bir getter ve bir setter yazmayı

6. Aşağıdaki program çalıştırıldığında ne olur?

class Account:
    def __init__(self, balance):
        if balance < 0:
            raise ValueError("Bakiye negatif olamaz")
        self._balance = balance

acc = Account(100)
acc._balance = -50
print(acc._balance)
  • A. ValueError verir, çünkü __init__ içindeki kural her atamada yeniden çalışır
  • B. AttributeError verir, çünkü _balance private bir niteliktir
  • C. -50 yazdırılır, çünkü kural yalnız __init__ içinde denetleniyor
  • D. 100 yazdırılır, çünkü alt çizgili nitelik dışarıdan değiştirilemez
  • E. -50 yazdırılır ve Python ekrana bir uyarı basar

7. Aşağıdaki sınıfta product.price = -50 satırı ne yapar?

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value <= 0:
            raise ValueError("Fiyat pozitif olmalı")
        self._price = value
  • A. Yeni bir price örnek niteliği oluşturur ve property’yi gölgeler
  • B. AttributeError yükseltir; price salt okunurdur
  • C. Hiçbir şey yapmaz; atama yok sayılır
  • D. Setter çalışır ve ValueError yükseltir; _price değişmez
  • E. _price değerini hata vermeden -50 yapar

8. price adlı bir property yazarken hangi üç ad aynı olmalıdır?

  • A. Setter’ın adı, setter parametresinin adı ve iç niteliğin adı
  • B. Getter’ın adı, iç niteliğin adı ve setter’ın adı
  • C. __init__ parametresinin adı, iç niteliğin adı ve getter’ın adı
  • D. Getter’ın adı ve @price.setter içindeki ad; setter’ın adı serbesttir
  • E. Getter’ın adı, @price.setter içindeki ad ve setter’ın adı

9. __init__ içinde self._price = price yerine self.price = price yazmanın gerekçesi nedir?

  • A. Başlangıç değeri de setter’dan geçer
  • B. Nesne oluşturmayı hızlandırır
  • C. Property tanımını zorunlu kılar
  • D. Nesneyi değiştirilemez yapar
  • E. _price adını dışarıdan gizler

10. Aşağıdaki metot neden güvenli değildir?

def transfer_to(self, other, amount):
    self._balance -= amount
    if self._balance < 0:
        raise ValueError("Yetersiz bakiye")
    other._balance += amount
  • A. Kontrol değişiklikten sonra yapıldığı için bakiye eksiye düşmüş kalır
  • B. raise bir metot içinde kullanılamaz
  • C. amount negatif olabileceği için tür denetimi gerekir
  • D. Sorun yoktur; istisna yükselince değişiklik kendiliğinden geri alınır
  • E. other nesnesinin özel niteliğine erişilemez

11. Durumu birden çok adımda değiştiren bir metotta hangi sıra izlenmelidir?

  • A. Önce durum değiştirilir, sonuç yanlışsa geri alınır
  • B. Kontrol hiç yapılmaz; çağıran doğru değer göndermekle yükümlüdür
  • C. Kontroller try/except içine alınır ve hata yutulur
  • D. Önce bütün ön koşullar sınanır, sonra durum değiştirilir
  • E. Her adımdan sonra ayrı ayrı kontrol yapılır

1. Doğru: B. balance >= 0 ya da 0 <= score <= 100 gibi kurallar nesne kullanıldığı sürece doğru kalmalıdır. Niteliklerin değeri değişir, kural değişmez.

  • A yanlış: Sınıf niteliği paylaşılan veridir; kural değildir.
  • C yanlış: Metodun kaç parametre aldığını imzası belirler; bu ayrı bir konudur.
  • D yanlış: Hiç değişmeyen değer sabittir; invariant’ta ise değer değişebilir, değişmeyen kuraldır.
  • E yanlış: Kuralı korumanın yolu çoğu zaman hata yükseltmektir; amaç geçersiz değeri engellemektir.

2. Doğru: E. İkisi de nesne kullanıldığı sürece doğru kalmalıdır ve dersin kendi kuralını anlatır: kontenjan eksi olamaz, kayıtlı öğrenci sayısı kontenjanı aşamaz.

  • A yanlış: Nesne oluşturulurken bu değerler doğru olabilir. Ama bunlar başlangıç değerleridir: ilk öğrenci kaydolunca enrolled == 0 bozulur. İnvariant nesne kullanıldığı sürece doğru kalmalıdır.
  • B yanlış: Kayıtlı öğrenci sayısını sınırladığı için doğru kurala yakın görünür. Ama boş bir dersi de tam dolu bir dersi de geçersiz sayar; ikisi de olağan durumlardır.
  • C yanlış: İki koşul da karşılaştırma olduğu için kural gibi görünür. Ama ikinci koşul dersin hep dolu olmasını ister: yeni açılan, henüz kimsenin kaydolmadığı ders bu kuralı bozar.
  • D yanlış: “Değişmez koşul” adı, niteliklerin değişmediği izlenimini verir. Ama öğrenci kaydoldukça enrolled değişir; değişmeyen, değerlerin uyması gereken kuraldır.

3. Doğru: A. __init__ çalışmaya başladığında nesne oluşturulmuştur, ama raise başlatmayı yarıda keser. BankAccount("Ada", -100) çağrısı nesne döndürmek yerine hata verir, atama yapılmaz ve account adı hiçbir nesneye bağlanmaz. except bloğu hatanın mesajını yazdırır.

  • B yanlış: Kod değeri kendiliğinden düzeltmez; hata yükseltir.
  • C yanlış: Atama satırları if kontrolünden sonra gelir. Bakiye negatif olduğu için raise çalışır, self.balance = balance satırına hiç gelinmez.
  • D yanlış: __init__ içinde hata yükseltmek olağan ve önerilen bir kalıptır.
  • E yanlış: Yazdırılan, yakalanan istisnanın mesajıdır.

4. Doğru: C. __init__ fiyatı denetlemediği için -5 fiyatlı defter oluşur ve listeye girer, print(len(items)) de 2 yazar. Hata ancak fiyat kullanılınca, ürünün oluşturulduğu satırdan uzakta ortaya çıkar. Denetim __init__ içinde olsaydı hata defterin oluşturulduğu satırda verilirdi (fail fast).

  • A yanlış: raise örnekleri çoğunlukla try ile birlikte görüldüğü için ona bağlı sanılabilir. Ama raise her yerde çalışır; try yalnız hatayı yakalamak için gerekir. Burada hata yakalanmaz ve program durur.
  • B yanlış: Listede geçersiz bir ürün olduğu doğrudur. Ama len() yalnız eleman sayısına bakar, ürünlerin niteliklerini denetlemez; bu satır 2 yazar.
  • D yanlış: Son satır -5 * 3 çarpımını yapıyormuş gibi görünür. Ama total() çarpmadan önce fiyatı denetler; fiyat pozitif olmadığı için ValueError yükseltir.
  • E yanlış: Fiyat kuralı sınıfta yazılı olduğu için nesne oluşturulurken denetlendiği sanılabilir. Ama kural total() içindedir; __init__ fiyatı denetlemeden niteliğe yazar ve nesne oluşur.

5. Doğru: B. Python erişimi engellemez. Kuralı, niteliği kurala uyarak değiştiren metotlar ve alt çizgi geleneğine uyan programcılar korur.

  • A yanlış: Python’da böyle bir engel yoktur; _balance adına da __balance adına da dışarıdan ulaşılabilir.
  • C yanlış: Çoğu nesnenin nitelikleri değişmek zorundadır; denetlenen, nasıl değiştikleridir.
  • D yanlış: “Kapsülleme” sözcüğü bir şeyi kapatıp gizlemeyi çağrıştırır. Ama sınıfın kodu okunabilir kalır; korunan, niteliklerin değişme biçimidir.
  • E yanlış: Kapsülleme çoğu zaman property ile anlatıldığı için her niteliğe erişim metodu yazmak gerekiyormuş gibi görünür. Ama kuralı olmayan nitelik düz kalabilir; erişim metodu yazmak tek başına bir kuralı korumaz.

6. Doğru: C. Tek alt çizgi erişimi engellemez: _balance bir adlandırma geleneğidir, Python bunu zorlamaz. Kontrol yalnız nesne oluşturulurken bir kez çalıştı. Dışarıdan yapılan doğrudan atama bu kontrolden geçmez. Kuralın her değişiklikte denetlenmesi için değişikliği bir metotla ya da property ile yapmak gerekir.

  • A yanlış: Kural sınıfın içinde yazıldığı için niteliği her zaman koruduğu düşünülebilir. Ama __init__ yalnız nesne oluşturulurken bir kez çalışır. Sonraki atamalar onu yeniden çalıştırmaz.
  • B yanlış: Alt çizgi “dokunmayın” uyarısı gibi okunduğu için erişimi engellediği sanılabilir. Ama Python’da dışarıdan erişimi engelleyen bir private belirteci yoktur; alt çizgi yalnız niyeti gösterir.
  • D yanlış: Alt çizgili ad korunuyormuş gibi göründüğü için atamanın etkisiz kaldığı sanılabilir. Ama atama başarılı olur ve değer gerçekten -50 olur.
  • E yanlış: Geleneğe aykırı bir kullanımın en azından uyarı vereceği beklenebilir. Ama Python alt çizgili bir ada yapılan atama için uyarı vermez. Geleneğe uymak programcıya kalır.

7. Doğru: D. property sayesinde sıradan bir atama gibi görünen satır setter’ı çağırır ve değer doğrulamadan geçer.

  • A yanlış: Python price adına yapılan atamayı setter’a gönderir; nesnede aynı adlı yeni bir nitelik oluşmaz, gölgeleme olmaz.
  • B yanlış: Setter tanımlı olduğu için atama yapılabilir.
  • C yanlış: Atama setter’ı çağırır ve hata yükselir.
  • E yanlış: Setter bunu engeller.

8. Doğru: E. Üçü de dışarıdan kullanılan price adını taşır. Setter’a farklı ad vermek en sık yapılan hatalardandır.

  • A yanlış: Üçü de setter’ın içinde göründüğü için birbirine bağlı sanılabilir. Ama setter’ın parametre adı (çoğu zaman value) serbesttir, iç nitelik de _price olur.
  • B yanlış: Değer iç nitelikte durduğu için onun da aynı adı taşıması gerekiyormuş gibi görünür. Ama iç nitelik price olursa getter içindeki self.price getter’ı yeniden çağırır ve RecursionError oluşur. İç nitelik bu yüzden _price olur.
  • C yanlış: __init__ içinde self.price = price yazıldığı için parametrenin de bu üçlüye girdiği sanılabilir. Ama parametre adı serbesttir, iç nitelik de _price olur.
  • D yanlış: Dekoratörde price yazdığı için setter’ın property’ye oradan bağlandığı sanılabilir. Ama setter farklı adla yazılırsa price adına bağlanmaz; obj.price = 5 ataması AttributeError verir.

9. Doğru: A. Başlangıç değeri de setter’daki doğrulamadan geçer ve kural tek yerde kalır. Aynı kuralı iki yerde yazarsanız zamanla ikisi birbirini tutmayabilir. Kural tek yerdeyse değiştiğinde yalnız orayı güncellersiniz.

  • B yanlış: self.price daha sade göründüğü için daha hızlı sanılabilir. Tersine, araya bir metot çağrısı girer; gerekçe hız değildir.
  • C yanlış: Satır bir property kullandığı için onu tanımlatan şey sanılabilir. Ama property zaten tanımlıdır; bu satır onu kullanır.
  • D yanlış: Doğrulama nesneyi koruduğu için onu kilitlediği düşünülebilir. Ama setter niteliği kurala uyarak değiştirmek için vardır; nesneyi değiştirilemez yapmaz.
  • E yanlış: Alt çizgili ad satırdan kalktığı için gizlenmiş gibi görünür. Ama ad yine erişilebilir. Bu satırın yararı, doğrulamanın tek yerde kalmasıdır.

10. Doğru: A. Hata yükseldiğinde self._balance zaten negatife düşmüştür; nesne yarım güncellenmiş, geçersiz bir durumda kalır. Doğru sıra önce bütün ön koşulları sınamak, sonra durumu değiştirmektir.

  • B yanlış: raise örnekleri çoğunlukla fonksiyonlarda görüldüğü için metotta kullanılamayacağı sanılabilir. Ama kullanılabilir; sorun raise satırının değişiklikten sonra gelmesidir.
  • C yanlış: Negatif amount gerçekten ayrı bir eksik olduğu için cazip gelir. Ama bu bir tür denetimi değil, değer denetimidir; metodu güvensiz yapan da işlemlerin sırasıdır.
  • D yanlış: İstisna işlemi iptal ediyormuş gibi göründüğü için yapılan değişikliğin de geri alınacağı sanılabilir. Ama Python değişikliği kendiliğinden geri almaz; bakiye eksi kalır.
  • E yanlış: Alt çizgili bir niteliğe başka bir nesne üzerinden erişmek kurala aykırı görünebilir. Ama tek alt çizgi teknik bir engel değildir; aynı sınıf içinde bu erişim olağandır.

11. Doğru: D. Böylece hata yükseldiğinde nesne hiç değişmemiş olur ve geçerli durumunu korur.

  • A yanlış: Geri alma kodu kolayca eksik kalır ve nesne yarım güncellenmiş kalabilir.
  • B yanlış: İnvariant’ı korumak nesnenin kendi sorumluluğudur.
  • C yanlış: Hata gizlenir ve geçersiz durum kimse fark etmeden kalıcı olur.
  • E yanlış: İlk adım geçip ikincisi düşerse nesne yine yarım kalır.

Tek sayfa özet

  • Değişmez koşul (invariant), nesne kullanıldığı sürece her an doğru kalması gereken kuraldır: stock >= 0 gibi.
  • Kuralı ilk __init__ denetler. Kurala uymayan değer gelirse raise başlatmayı yarıda keser: çağrı hata verir ve atamanın solundaki ada nesne bağlanmaz.
  • Kapsülleme, niteliklerin yalnız sınıfın metotlarıyla, kurala uyarak değişmesidir.
  • _stock gibi tek alt çizgili bir ad “bu ad içeride kullanılır” der, ama erişimi engellemez. Python’da private belirteci yoktur.
  • property, pen.price = 12 gibi sade bir atamanın arkasına denetim koyar. Setter’ı olmayan bir property’ye değer atanamaz.
  • Getter, @price.setter ve setter aynı adı taşır. __init__ ilk değeri setter’la atarsa doğrulama tek yerde kalır.
  • Önce bütün ön koşulları denetleyin, sonra durumu değiştirin. raise yapılmış değişikliği geri almaz.

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

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

  • Bir sınıf için değişmez koşul (invariant) yazar.
  • Geçersiz başlangıç durumunu __init__ içinde engeller.
  • Kapsüllemede amacın erişimi yasaklamak değil, niteliklerin yalnız sınıfın metotlarıyla değişmesi olduğunu açıklar.
  • Tek alt çizginin bir adlandırma geleneği olduğunu ve Python’ın dışarıdan erişimi engellemediğini gösterir.
  • property ve setter tanımlar; üç adın aynı olması gerektiğini bilir.
  • __init__ içinde setter’ı kullanarak doğrulamayı tek yerde tutar.
  • Önce ön koşulları sınayıp sonra durumu değiştirerek yarım güncellemeyi önler.
Başa dön