Bütünleştirici nesne tasarımı

Son haftada yeni bir OOP kavramı yok. Dönem boyunca öğrendiklerinizi tek bir küçük kütüphane programında birlikte kullanacaksınız: bir nesnenin o anki durumunu okumak, her kuralı doğru sınıfa koymak, nesnenin geçersiz bir duruma düşmesini önlemek, iki nesne arasındaki bağı tutarlı tutmak ve bir değişikliğin başka neleri etkilediğini göstermek.

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 sistemi okurken hangi sınıfın hangi durumu koruduğunu belirleme
  • Bir iş kuralının hangi sınıfa ait olduğuna, kuralın koruduğu durumun sahibine bakarak karar verme
  • İnvariant için raise, geliştirici kontrolü için assert
  • Birden çok nesneyi değiştiren işlemde nesneler arası tutarlılık
  • in ve list.remove() işlemlerinin aynı nesneyi ya da == ile eşit elemanı araması
  • __eq__ eklemenin koleksiyon davranışını da değiştirmesi
  • Tasarım değişikliğini regresyon kontrolleriyle doğrulama

Başlangıç sistemi: kim neyi tutuyor?

Kütüphane programında üç sınıf var: Book bir kitabın ISBN’ini ve adını, Member bir üyenin numarasını ve adını tutuyor. Library kütüphanedeki bütün kitapları ve üyeleri bir arada tutuyor. Kütüphaneden şu beş istek geldi:

  1. Her kitabın kimde olduğunu ve her üyenin hangi kitapları aldığını kaydetmek
  2. Bir üyeye aynı anda en fazla üç kitap vermek, bu sınırın programın başka bir yerinden aşılmasına izin vermemek
  3. Ödünç verirken kitabın kaydını ve üyenin listesini birlikte güncellemek: kitap ödünçte görünüp üyenin listesinde eksik kalmamalı
  4. Kitabı yalnız onu ödünç alan üyeden geri almak
  5. Aynı ISBN’li iki Book nesnesini aynı kitap saymak

Aşağıdaki kod çalışan bir sistem. Üç sınıfı tanımlıyor, en altta da bir kitabı Ada’ya ödünç veriyor. Kodu baştan sona okuyun. Son iki satır ne yazar?

Hücreyi çalıştırdıktan sonra kodda şu soruların cevabını arayın:

  1. Bir kitabın kimde olduğunu hangi sınıf, hangi nitelikte tutuyor?
  2. Bir üyenin aldığı kitapları hangi sınıf tutuyor? Bu listeyi dışarıya olduğu gibi veriyor mu?
  3. Library kitapları ve üyeleri neden sözlükte tutuyor? Bu sözlükleri dışarıya veriyor mu?
  4. isbn ve member_id neden salt okunur property?
  5. Book ve Member sınıflarında adı alt çizgiyle başlayan metotları kim çağırıyor?
  6. Ödünç verilen Book nesnesi hem Library’nin sözlüğünde hem Ada’nın listesinde duruyor. Bunlar iki ayrı kitap mı?
  1. Book, _borrowed_by niteliğinde. Kitap kütüphanedeyse bu nitelik None, ödünçteyse kitabı alan Member nesnesini gösterir. Dışarıdan yalnız borrowed_by ve is_available property’leriyle okunur.
  2. Member, _borrowed_books listesinde. Dışarıya listenin kendisini değil, borrowed_books property’siyle bir demet (tuple) kopyasını verir.
  3. Kitabı ISBN’iyle, üyeyi numarasıyla taramadan bulmak için. Sözlüğün anahtarı tek olduğu için aynı ISBN ya da aynı üye numarası iki kez kaydedilemez. Sözlükler _books ve _members iç niteliklerinde durur, dışarıya verilmez. Dış kod kitabı find_book(), üyeyi find_member() ile bulur. 9. haftadaki karar sözlükler için de geçerli: sözlük library.books adıyla açık olsaydı library.books.clear() satırı bütün kitap kayıtlarını silerdi.
  4. Bu iki değer sözlüklerin anahtarı. book.isbn = "978-2" ataması yapılabilseydi sözlük kitabı eski "978-1" anahtarıyla tutmaya devam ederdi: find_book("978-2") kitabı bulamaz, "978-2" ISBN’li ikinci bir kitap da kaydedilebilirdi. Property’nin setter’ı olmadığı için bu atama AttributeError verir.
  5. Yalnız Library. _borrow_by() ile _return_book() yalnız kitabın kaydını, _add_book() ile _remove_book() yalnız üyenin listesini değiştirir. Biri dışarıdan tek başına çağrılırsa iki kayıt birbirini tutmaz. Adlarındaki tek alt çizgi 8. haftadaki gelenektir: bu metotlar sınıfın iç adımlarıdır, dışarıdan çağırmayın. Ödünç verme ve iade için dışarıya açık yol Library.borrow() ve Library.return_book().
  6. Hayır. Hücre True yazdı: iki koleksiyon da aynı Book nesnesini gösteriyor. Koleksiyona eklemek nesneyi kopyalamaz, nesneye bir referans daha ekler.

Birinci iş, kitabın kimde olduğunu kaydetmekti. Bu kayıt iki yerde duruyor: kitap kendisini alan üyeyi, üye de aldığı kitapları biliyor. Bölümün geri kalanında, ödünç verme ve iade Library üzerinden yapıldığı sürece bu iki kaydın birbiriyle uyumlu kaldığını göreceğiz.

Üye başına en fazla üç kitap

Programın uyması gereken “üye başına en fazla üç kitap” gibi kurallara iş kuralı denir. Bir iş kuralını hangi sınıfa koyacağınıza karar verirken kuralın hangi durumu sınırladığına bakın. Üç kitap sınırı üyenin aldığı kitapları sayar. O listeyi Member tutuyor, kural da orada duruyor: MAX_BORROWED_BOOKS sınıf niteliği ve ensure_can_borrow() metodu.

Aşağıdaki hücrede Member sınıfı kısaltılmış hâlde, tek başına duruyor. Kitapların yerinde kısaca adları var, çünkü Member kitaba bakmıyor, yalnız sayıyor. Programda _add_book() metodunu yalnız Library çağırır. Burada sınırı Member üzerinde denemek için onu doğrudan çağırıyoruz. Ada üç kitap aldıktan sonra dördüncüyü istiyor. Hücre ne yazar? Son satır sınırı aşabilir mi?

  • Reddedildi: Ödünç kitap sınırı dolu: dördüncü _add_book() çağrısında ensure_can_borrow() hata yükseltti, kitap listeye eklenmedi.
  • 3: listede hâlâ üç kitap var.
  • AttributeError: borrowed_books bir demet döndürüyor. Demette append() metodu yoktur.

borrowed_books iç listeyi değil, onun demet kopyasını verir. Dışarıdaki kod bu demete eleman ekleyemez, iç listeye de ulaşamaz. 9. haftada gördüğünüz gibi, property iç listeyi olduğu gibi döndürseydi dış kod append() ile dördüncü kitabı ekleyebilir, ensure_can_borrow() kontrolüne hiç uğramazdı.

Bu kuralın çalıştığını şu kontrollerle gösterirsiniz:

  • 1., 2. ve 3. kitap ödünç alınır.
  • 4. kitap reddedilir.
  • Reddedilen kitap hâlâ ödünç alınabilir durumdadır.
  • Üyenin listesinde yalnız üç kitap vardır.

Sınırı neden assert ile yazmıyoruz?

Bir noktada neyin doğru olmasını beklediğinizi koda şöyle satırlarla yazabilirsiniz:

assert book.borrowed_by is member
assert len(member.borrowed_books) == 3

assert, koşul yanlışsa AssertionError yükseltir, doğruysa hiçbir şey yapmaz. Yukarıdaki kontrolleri böyle yazmak, test yazmaya doğru atılmış iyi bir ilk adımdır.

Sınırın kendisini de _add_book() içinde assert ile yazmak akla gelebilir:

assert len(self._borrowed_books) < self.MAX_BORROWED_BOOKS, "Sınır dolu"

Bu güvenli değildir. Python -O (optimize) seçeneğiyle çalıştırıldığında assert satırları kaldırılır ve kural da onlarla birlikte ortadan kalkar. Program gerçek kullanıcılara hizmet verirken (üretimde) böyle çalıştırılabilir.

Önemliİnvariant için raise, geliştirici kontrolü için assert

Değişmez koşul (invariant), nesne kullanıldığı sürece doğru kalması gereken kuraldır: “üyede en fazla üç kitap olur” gibi. Kullanıcı girdisini, bir iş kuralını ya da nesnenin invariant’ını koruyan kontrol programın her çalışmasında yapılmalıdır. Bunun için if ...: raise ... kullanın. assert ise geliştirirken ya da test ederken “burada doğru olduğunu varsaydığım şey gerçekten doğru mu?” diye sorduğunuz kontroller içindir.

Ödünç alma: iki kayıt birlikte değişir

Her nesnenin kendi kuralını koruması yetmeyebilir. Ödünç alma hem Book hem Member nesnesini değiştirir. Aşağıdaki hücrede borrow() fonksiyonu önce kitabı işaretliyor, sonra üyenin listesine ekliyor. Sınır kontrolü Member içinde. Ada üç kitap aldıktan sonra dördüncüyü istiyor. Son iki satır ne yazar?

İşlem reddedildi, ama kitap çoktan Ada’yı gösteriyor. Ada’nın listesinde ise yok. Member kendi kuralını korudu ve dördüncü kitabı almadı. Yine de iki kayıt birbiriyle çelişiyor: sistem yarım güncellenmiş kaldı.

ÖnemliBir sınıfın invariant’ı yetmeyebilir

Bir işlem birden fazla nesneyi birlikte değiştiriyorsa bu nesnelerin birbiriyle uyumlu kalmasını ayrıca düşünmeniz gerekir. Buna nesneler arası tutarlılık diyoruz.

Başlangıç sistemindeki Library.borrow() bu yüzden 8. haftadaki “önce kontrol et, sonra değiştir” sırasını iki nesneye birlikte uygular:

# Önce bütün ön koşullar, sonra durum değişiklikleri.
member.ensure_can_borrow(book)
if not book.is_available:
    raise ValueError("Kitap zaten ödünçte")

book._borrow_by(member)
member._add_book(book)
  1. Üye ve kitap bulunur.
  2. Üyenin ödünç alma koşulları kontrol edilir.
  3. Kitabın rafta olup olmadığı kontrol edilir.
  4. Ancak bundan sonra iki nesne de değiştirilir.

Kontrollerden biri hata verirse iki nesneye de dokunulmamış olur. Library kuralı kendisi yazmıyor: sınırı Member’a, rafta olup olmadığını Book’a soruyor. Yalnız sorma sırasını o belirliyor.

Bu güvence yalnız Library üzerinden yapılan işlemler için geçerli. book._borrow_by(member) dışarıdan tek başına çağrılırsa kitap üyeyi gösterir, üyenin listesi değişmez. Python bu çağrıyı engellemez. Metodun adındaki alt çizgi programcılara “bu bir iç adım, dışarıdan çağırmayın” der. Ödünç vermek isteyen kod library.borrow() metodunu çağırır.

Gerçek bir kütüphane sistemi verileri kalıcı olarak saklar ve aynı anda birden çok işlemi yürütür. O durumda birden fazla nesneyi değiştiren işlemler için transaction gibi daha güçlü düzenekler gerekebilir. Bu modelde ise işlemler birer birer çalışır ve veriler yalnız bellekte durur. Bu yüzden kontrolleri değişikliklerden önce yapmak yarım güncellemeyi önlemeye yeter.

İade: kitap yalnız onu alan üyeden döner

İade de iki nesneyi birlikte değiştirir: kitap rafa döner, üyenin listesinden çıkar. Başlangıç sistemindeki Library.return_book() metoduna bakmadan önce iadenin hangi durumlarda reddedilmesi gerektiğini düşünün:

  • Üye yok.
  • Kitap yok.
  • Kitap zaten kütüphanede.
  • Kitap başka bir üyede.
  • Kitabın borrowed_by property’si üyeyi gösteriyor ama kitap üyenin listesinde yok.

Son durum, önceki hücrede gördüğünüz yarım güncellemedir. Başlangıç sisteminde bu durum ancak biri _borrow_by() metodunu dışarıdan çağırırsa ortaya çıkar. return_book() onu yine de yakalar. Şimdi metodu okuyun. Hangi satır hangi durumu yakalıyor?

member = self.find_member(member_id)  # üye yoksa ValueError
book = self.find_book(isbn)           # kitap yoksa ValueError
if book.borrowed_by is not member:
    raise ValueError("Kitap bu üyede değil")
if book not in member.borrowed_books:
    raise ValueError("Kitap ve üye kaydı tutarlı değil")

book._return_book()
member._remove_book(book)

book.borrowed_by is not member satırı iki durumu birden yakalar: kitap kütüphanedeyse borrowed_by None’dır, başka üyedeyse başka bir Member nesnesini gösterir. Burada == değil is kullanılıyor, çünkü soru “kitabı alan bu üye mi?” sorusudur.

Başarılı bir iadeden sonra şu iki koşul doğru olmalı:

assert book.is_available
assert book not in member.borrowed_books

Bu assert satırları test kontrolüdür. return_book() içindeki raise satırlarının yerini tutmaz.

ISBN’e göre eşitlik

Beşinci iş için Book sınıfına 12. haftadaki gibi ISBN’leri karşılaştıran bir __eq__ ekleyeceğiz:

class Book:
    ...

    def __eq__(self, other):
        if not isinstance(other, Book):
            return NotImplemented
        return self.isbn == other.isbn

Yalnız Book sınıfını değiştiriyoruz. Ama Member sınıfında şu iki satır var:

if book in self._borrowed_books:
    ...

self._borrowed_books.remove(book)

in ve remove() hangi eşitliği kullanıyor?

in listede eleman ararken, list.remove() de silinecek elemanı bulurken listeyi baştan gezer. Her elemana önce aranan nesnenin kendisi mi diye bakar, değilse ikisini == ile karşılaştırır. Aynı nesne ya da == ile eşit bulunan ilk eleman eşleşir. Bu yüzden aynı nesne, __eq__ metodu False döndürse bile listede bulunur. Başlangıç sisteminde Book sınıfında __eq__ yok. O zaman == de iki nesnenin kimliğine bakar: ISBN’leri aynı olsa bile iki ayrı Book örneği eşit sayılmaz.

Aşağıdaki hücrede Book sınıfı __eq__ ile birlikte kısaltılmış hâlde duruyor. Listede yalnız registered var. probe aynı ISBN’li başka bir nesne. Üç print() ne yazar? books.remove(probe) hata verir mi?

Listede probe ile aynı nesne yok. Yine de remove(probe), ISBN’i aynı olduğu için eşit sayılan registered nesnesini listeden siler. Şimdi __eq__ metodunu hücreden silin ve yeniden çalıştırın. Ne değişti?

__eq__ varken:

  • False: registered ile probe iki ayrı nesne.
  • True: in, probe’u listedeki registered ile == üzerinden eşleştirdi.
  • []: remove() eşit sayılan registered nesnesini sildi.

__eq__ silinince ilk satır yine False, ikinci satır False olur. remove(probe) ise ValueError yükseltir, çünkü == artık kimliğe bakıyor ve listede probe yok.

Uyarı__eq__ eklemek yalnızca a == b satırını değiştirmez

Eşitliği tanımladığınızda in, list.remove(), iki listenin == ile karşılaştırılması ve başka koleksiyon işlemleri de bu tanımı kullanır. Book.__eq__’yi ISBN’e göre tanımladığınız anda Member sınıfındaki book in self._borrowed_books kontrolü ve remove() çağrısı da, bu satırlara hiç dokunmadığınız hâlde farklı davranmaya başlar.

Kütüphane modeliniz için istediğiniz davranış bu olabilir. Ama bu etkiyi bilerek sınamanız gerekir.

Değişiklikten sonra eski davranışı sınamak

Bir değişiklikten sonra eskiden çalışan davranışın bozulup bozulmadığını ya da nasıl değiştiğini sınayan kontrole regresyon kontrolü denir. __eq__ ekledikten sonra şunları gösterin:

  1. Aynı ISBN’li iki farklı nesne == ile eşit, is ile farklıdır.
  2. Aynı ISBN’li ikinci nesne, in kontrolünde ilk nesneyle eşleşir.
  3. remove() artık ISBN eşitliğine göre siler.
  4. Üç kitap sınırı ve iade kontrolleri hâlâ geçer.

Bir şeye daha dikkat edin: 12. haftada gördüğünüz gibi, __eq__ yazıp __hash__ yazmadığınız sınıfın nesneleri artık bir kümeye eleman ya da sözlüğe anahtar olamaz. Bu modelde sözlüğün anahtarı kitabın kendisi değil ISBN metni olduğu için Library etkilenmez. isbn salt okunur olduğu için bir kitabın hangi kitaplarla eşit sayıldığı da sonradan değişmez.

Son olarak bu davranışı modelinizde isteyip istemediğinizi gerekçesiyle kısaca yazın. Bu iş için 6. haftanın kimlik (is), 9. haftanın nesne koleksiyonları ve 12. haftanın eşitlik (==, __eq__) konularını birlikte kullanırsınız.

İşler hangi sınıfta?

Kütüphaneden gelen beş isteğin bu bölümdeki karşılıkları:

İş Önceki haftalarda Bu bölümdeki yol Dikkat
Kitabın kimde olduğunu kaydetmek Nesne başka nesneyi tutar, koleksiyon (9. hafta) Book._borrowed_by üyeyi, Member._borrowed_books kitapları, Library _books ve _members sözlüklerinde bütün kayıtları tutar, dışarıya find_book() ve find_member() ile verir Aynı Book nesnesi iki koleksiyonda durur, iki ayrı kitap olmaz. Sözlük anahtarı olan isbn ve member_id salt okunurdur
Üye başına en fazla üç kitap Sınıf niteliği (7. hafta), raise ile kural, property (8. hafta) Member.MAX_BORROWED_BOOKS ve ensure_can_borrow(), borrowed_books demet döndürür Kuralı assert ile yazmayın: -O ile kaldırılır
İki kaydı birlikte güncellemek Önce kontrol et, sonra değiştir (8. hafta) Library.borrow() bütün kontrollerden sonra iki nesneyi değiştirir Her nesnenin kendi kuralı yarım güncellemeyi önlemez. _borrow_by() ve _add_book() iç adımdır, dışarıdan çağrılmaz
Yalnız alan üyeden geri almak Kimlik ve is (6. hafta) Library.return_book() book.borrowed_by is member diye sorar Kayıtların çelişmesini de ayrıca kontrol eder
Aynı ISBN’li kitapları eşit saymak __eq__ (12. hafta) Book.__eq__ ISBN’leri karşılaştırır in ve remove() da bu tanımı kullanır, regresyon kontrolü yazın

Üç kitap sınırını Library’ye de yazabilirdiniz. Kod çalışırdı, ama sınırı aşmanın başka bir yolu kalırdı: üyenin listesine Library’ye uğramadan ekleme yapan her kod kuralı atlardı. Kural, sınırladığı listeyi tutan sınıfta durunca bu yol kapanır. İki kaydı birlikte güncellemek için de yeni bir araç gerekmedi. 8. haftada tek nesnede kurduğunuz “önce kontrol et, sonra değiştir” sırasını Library iki nesneye birlikte uyguluyor.

Bütünleştirici görev

Bu görevi, alttaki tasarım savunmasını ve deneme sınavını evde, kendi bilgisayarınızda yapın. Teslim edilmez, not getirmez. Başlangıç sistemi ilk dört işi zaten yapıyor. Sizin işiniz beşinciyi eklemek ve hepsini kontrollerle göstermek. Bölümün başındaki hücredeki kodu bir dosyaya kopyalayın ve şunları yapın:

  • Book.__eq__’yi ISBN’e göre tanımlayın.
  • Üye başına en fazla üç kitap kuralını kontrollerle gösterin.
  • İadenin yanlış üyeden reddedildiğini gösterin.
  • Member’ın iç listesinin dışarıdan değiştirilemediğini gösterin.
  • Başarılı ve başarısız işlemleri küçük kontrollerle doğrulayın.

Çalışır kod görevi. En az şu senaryoları assert ile kontrol eden çalışır bir dosya hazırlayın:

  • Normal ödünç alma
  • Aynı kitabı tekrar alma
  • Dördüncü kitap sınırı
  • Başarılı iade
  • Yanlış üyeden iade
  • Aynı ISBN’li farklı Book örnekleriyle eşitlik ve in davranışı

İş kurallarını raise ile koruyun. assert satırlarını yalnız sonucu doğrulamak için kullanın. Hata beklediğiniz senaryoda çağrıyı try/except içine alın ve hatanın geldiğini kontrol edin.

Kısa tasarım savunması

Kodun altına şu sorular için en fazla 150 kelimelik bir cevap yazın:

  1. Ödünç alma sınırı neden Member sınıfının işidir?
  2. Library ön koşulları neden yine de değişiklikten önce sırayla kontrol eder?
  3. Book.__eq__ eklemek koleksiyon davranışını nasıl değiştirdi?
  4. Member’ın iç listesi neden dışarıya değiştirilebilir (mutable) bir liste olarak verilmedi?
  5. Hangi kontrolleri raise, hangilerini assert ile yazdınız ve neden?

Deneme sınavı: 25 soru

Bu 25 soru final biçiminin birebir örneğidir: final de 25 sorudur, her soru beş şıklıdır ve her kazanımdan en fazla bir soru gelir. Önce kendiniz çözün, sonra cevap anahtarındaki gerekçeleri okuyun.

1. Python’da a ve b tamsayı, b de sıfırdan farklıyken a // b (bölüm) ve a % b (kalan) için hangisi her zaman doğrudur?

  • A. a // b sonucu en yakın tamsayıya yuvarlanır
  • B. a // b sonucu sıfıra doğru kırpılır
  • C. a % b sonucunun işareti a’nın işaretini izler
  • D. a == (a // b) * b
  • E. a == (a // b) * b + (a % b)

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

parts = ["Ada", "80"]
record = ",".join(parts)
print(record)
print(parts)
  • A. Önce Ada,80, sonra ['Ada', '80']
  • B. Önce ['Ada', ',', '80'], sonra ['Ada', '80']
  • C. Önce Ada80, sonra ['Ada', '80']
  • D. Önce ,Ada,80, sonra ['Ada', '80']
  • E. İki satırda da Ada,80

3. grades = {101: 85} iken aşağıdaki satırlardan hangisi hata verir?

  • A. print(102 in grades)
  • B. print(grades.get(102))
  • C. print(grades.get(102, 0))
  • D. print(grades[102])
  • E. grades[102] = 60

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

def double(n):
    n = n * 2

x = 4
double(x)
print(x)
  • A. None
  • B. 16
  • C. 8
  • D. 4
  • E. Hata verir; parametreye yeni değer atanamaz

5. int(raw) çağrısı sayıya çevrilemeyen bir metin alınca yükselen hatayı yakalamak istiyorsunuz. Hangi yazım uygundur?

  • A. except: (tür yazmadan)
  • B. except Exception:
  • C. except TypeError:
  • D. except ValueError:
  • E. if int(raw) == error:

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

def empty(product):
    product["stock"] = 0

def replace(product):
    product = {"name": "Silgi", "stock": 4}

a = {"name": "Kalem", "stock": 10}
b = {"name": "Kalem", "stock": 10}
empty(a)
replace(b)
print(a["stock"], b["stock"])
  • A. 10 4
  • B. 10 10
  • C. 0 10
  • D. 0 4
  • E. Hata verir; product adı iki fonksiyonda birden kullanılamaz

7. withdraw() her para çekişini history listesine kaydediyor. Program ne yazdırır?

class Account:
    def __init__(self, balance):
        self.balance = balance
        self.history = []

    def withdraw(self, amount):
        self.balance -= amount
        self.history.append(-amount)

account = Account(500)
account.withdraw(100)
account.balance -= 50

print(account.balance, account.history)
  • A. 350 []
  • B. AttributeError; balance metot dışından değiştirilemez
  • C. 400 [-100]
  • D. 350 [-100, -50]
  • E. 350 [-100]

8. Bir otel programında Reservation nesnesi giriş gününü check_in, çıkış gününü check_out niteliğinde gün numarası olarak tutuyor. Misafir kalışını uzatabiliyor ya da kısaltabiliyor. Bu sınıf için en uygun invariant hangisidir?

  • A. check_out - check_in == 3
  • B. check_in > check_out
  • C. check_in < check_out
  • D. check_out >= check_in + 7
  • E. check_in ve check_out hiç değişmez

9. Aşağıdaki programın son satırı çalışınca ne olur?

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

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

    @price.setter
    def set_price(self, value):
        if value <= 0:
            raise ValueError("Fiyat pozitif olmalı")
        self._price = value

pen = Product(10)
pen.price = -5
  • A. pen nesnesinde yeni bir price niteliği oluşur, değeri -5 olur
  • B. NameError verir; @price.setter satırında price henüz tanımlı değildir
  • C. AttributeError verir; price adına bağlı bir setter yoktur
  • D. Setter çalışır ve ValueError yükseltir
  • E. Hata vermez; _price niteliği -5 olur

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

class Cart:
    def __init__(self):
        self._items = []
        self._total = 0

    def add(self, name, price):
        self._items.append(name)
        if price <= 0:
            raise ValueError("Fiyat pozitif olmalı")
        self._total += price

    def summary(self):
        return len(self._items), self._total

cart = Cart()
try:
    cart.add("Kalem", -5)
except ValueError:
    pass
print(cart.summary())
  • A. (1, -5)
  • B. (1, 0)
  • C. (0, 0)
  • D. Hata mesajı yazılır ve program durur
  • E. (0, -5)

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

class Classroom:
    def __init__(self, capacity):
        self.capacity = capacity
        self._students = []

    def add(self, name):
        if len(self._students) >= self.capacity:
            raise ValueError("Sınıf dolu")
        self._students.append(name)

    def students(self):
        return self._students

room = Classroom(2)
room.add("Ada")
room.add("Ece")
names = room.students()
names.append("Mert")
print(len(room.students()))
  • A. ValueError: Sınıf dolu
  • B. AttributeError; alt çizgili liste dışarı verilemez
  • C. 3
  • D. 2
  • E. TypeError; append yalnız sınıfın içinde çağrılabilir

12. Bir sinema programında bilet satışını Ticketing sınıfı yapıyor:

class Ticketing:
    def sell(self, show, customer, seat):
        if seat in show.taken_seats:
            raise ValueError("Koltuk dolu")
        show.taken_seats.append(seat)
        customer.points += 10
        if customer.points >= 100:
            customer.level = "altın"

Bu tasarımla ilgili hangi yorum doğrudur?

  • A. Sorun, koltuk kontrolünün değişiklikten sonra yapılmasıdır
  • B. Seansın ve müşterinin kuralları Ticketing içinde birikir
  • C. Sorun yoktur; satışın bütün kuralları satışı yapan sınıfta durmalıdır
  • D. Show ve Customer sınıfları Ticketing sınıfından türetilmelidir
  • E. points bir property olsaydı sorun kalmazdı

13. “Salt okunur dosya da bir dosyadır” diye düşünülüp ReadOnlyFile sınıfı File sınıfından türetilmiş. save_log() fonksiyonu File nesneleri için yazıldı. Bu tasarım için hangisi doğrudur?

class File:
    def __init__(self):
        self.lines = []

    def write(self, line):
        self.lines.append(line)

class ReadOnlyFile(File):
    def write(self, line):
        raise PermissionError("Bu dosya salt okunur")

def save_log(file):
    file.write("Giriş yapıldı")
  • A. is-a cümlesi kurulabildiği için bu kalıtım kararı doğrudur
  • B. isinstance(ReadOnlyFile(), File) False verdiği için fonksiyon onu reddeder
  • C. File beklenen yerde ReadOnlyFile kullanılınca write() sözü bozulur
  • D. Override edilen metot raise içeremez, bu yüzden sınıf tanımı hata verir
  • E. Sorun, ReadOnlyFile sınıfının kendi __init__ metodunu yazmamasıdır

14. TaxedProduct sınıfının total() metodu, üst sınıfın hesabını kopyalamadan sonuca 20 eklemeli ve son satır 120 yazmalı. Boşluğa ne yazılmalıdır?

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

    def total(self):
        return self.price

class TaxedProduct(Product):
    def total(self):
        return ______ + 20

print(TaxedProduct(100).total())
  • A. super.total()
  • B. super().total()
  • C. Product.total()
  • D. super().__init__(self.price)
  • E. self.total()

15. Aşağıdaki EmailNotification sınıfına tarayıcıda bir FakeSmtp nesnesi, gerçek gönderimde ise standart kütüphanedeki smtplib.SMTP nesnesi veriliyor. FakeSmtp hiçbir sınıftan türetilmedi. Sınıfın iki nesneyle de çalışmasının nedeni nedir?

class FakeSmtp:
    def __init__(self):
        self.sent = []

    def send_message(self, msg):
        self.sent.append(msg)

class EmailNotification:
    def __init__(self, smtp, to):
        self.smtp = smtp
        self.to = to

    def send(self, message):
        msg = EmailMessage()
        msg["To"] = self.to
        msg.set_content(message)
        self.smtp.send_message(msg)
        return f"E-posta: {message}"
  • A. İki nesnede de send_message(msg) metodunun bulunması
  • B. FakeSmtp nesnesinin gönderilenleri sent listesinde tutması
  • C. FakeSmtp sınıfının smtplib.SMTP sınıfından türemiş sayılması
  • D. İki nesnenin de EmailMessage sınıfından türemiş olması
  • E. EmailNotification sınıfının gelen nesnenin türünü denetlemesi

16. Aşağıdaki fonksiyonda except Exception yazılmış. Bunun yerine except AttributeError yazmanın gerekçesi nedir?

def notify(notification, message):
    try:
        return notification.send(message)
    except Exception:
        return "Desteklenmiyor"
  • A. except Exception yalnız LBYL yaklaşımıyla birlikte kullanılabilir
  • B. AttributeError daha hızlı yakalandığı için program daha az bekler
  • C. except Exception yalnız raise ile açıkça yükseltilen hataları yakalar
  • D. İki yazım aynı hataları yakalar; fark yalnız okunaklılıktadır
  • E. send() içindeki gerçek hatalar da “Desteklenmiyor” diye gizlenir

17. Bir sınıfta yalnız __str__ tanımlanırsa repr(obj) ne verir?

  • A. Varsayılan temsili verir
  • B. AttributeError yükseltir
  • C. None verir
  • D. __str__ metodunun sonucunu verir
  • E. Boş metin verir

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

class Notification:
    def send(self, text):
        raise NotImplementedError("Alt sınıf göndermeli")

class SmsNotification(Notification):
    def send(self, text):
        return f"SMS: {text}"

class EmailNotification(Notification):
    pass

for notification in [SmsNotification(), EmailNotification()]:
    print(notification.send("Merhaba"))
  • A. SMS: Merhaba yazılır, EmailNotification hata vermeden atlanır
  • B. SMS: Merhaba ve ardından NotImplemented yazılır
  • C. SMS: Merhaba ve ardından None yazılır
  • D. SMS: Merhaba yazılır, ardından NotImplementedError yükselir
  • E. Hiçbir şey yazılmaz, EmailNotification() oluşturulurken hata yükselir

19. Standart kütüphanedeki smtplib modülünde sunucu alıcı adreslerinin hepsini reddedince SMTPRecipientsRefused yükseltilir. Bu sınıf SMTPException sınıfından, SMTPException da OSError sınıfından türer. Aşağıdaki except satırlarından hangisi bu hatayı yakalamaz?

  • A. except Exception:
  • B. except ValueError:
  • C. except smtplib.SMTPException:
  • D. except OSError:
  • E. except smtplib.SMTPRecipientsRefused:

20. keyboard bir Product nesnesi. Order sınıfının imzaları şöyle:

class Order:
    def add_item(self, product: Product, amount: int) -> None: ...

    def total(self) -> float: ...

Aşağıdaki kullanımlardan hangisi bu imzalara uyar?

  • A. total = order.add_item(keyboard, 2) ve ardından print(total)
  • B. order.add_item(keyboard, 2) ve ardından print(order.total())
  • C. order.add_item("P1", 2) ve ardından print(order.total())
  • D. order.add_item(keyboard, 2) ve ardından print(order.total(keyboard))
  • E. order.add_item(keyboard) ve ardından print(order.total())

21. Aşağıdaki kod çalıştıktan sonra müşterinin puanını hangi satır yazdırır?

import json

with open("customers.json", "w", encoding="utf-8") as file:
    json.dump([{"name": "Ada", "points": 40}], file)

with open("customers.json", encoding="utf-8") as file:
    data = json.load(file)
  • A. print(data[0]["points"])
  • B. print(data["points"])
  • C. print(data[0].to_dict()["points"])
  • D. print(data[0].points)
  • E. print(data.points)

22. Aşağıdaki kodu okuyun. Hangi eşleştirme doğrudur?

class Flight:
    def __init__(self, capacity):
        self._capacity = capacity
        self._passengers = []

    def board(self, passenger):
        if len(self._passengers) >= self._capacity:
            raise ValueError("Uçak dolu")
        self._passengers.append(passenger)

class Passenger:
    def __init__(self, name):
        self.name = name
        self._bags = []

    def add_bag(self, weight):
        if len(self._bags) >= 2:
            raise ValueError("En fazla iki bagaj")
        self._bags.append(weight)
  • A. Yolcu sayısı sınırını Flight korur; bagaj sınırını koruyan sınıf yok
  • B. İki sınırı da Flight korur, çünkü yolcular uçağın listesindedir
  • C. Yolcu sayısı sınırını Passenger, bagaj sınırını Flight korur
  • D. İki sınırı da Passenger korur, çünkü uçağa binen yolcudur
  • E. Yolcu sayısı sınırını Flight, bagaj sınırını Passenger korur

23. Bir ürün move() fonksiyonuyla bir depodan ötekine taşınıyor. Her depo kendi kuralını kendi metodunda denetliyor:

class Warehouse:
    def __init__(self, capacity):
        self.capacity = capacity
        self._items = []

    def take_out(self, item):
        if item not in self._items:
            raise ValueError("Ürün bu depoda yok")
        self._items.remove(item)

    def put_in(self, item):
        if len(self._items) >= self.capacity:
            raise ValueError("Depo dolu")
        self._items.append(item)

def move(item, source, target):
    source.take_out(item)
    target.put_in(item)

İki depo da kendi kuralını koruduğu hâlde move() hangi sorunu bırakır?

  • A. Hedef doluysa ürün yine hedefe eklenir ve kapasite aşılır
  • B. Hedef doluysa ürün iki depoda birden görünür
  • C. Hedef doluysa move() ürünü kaynağa kendiliğinden geri koyar
  • D. Hedef doluysa ürün kaynaktan çıkmış, hedefe girmemiş olarak kalır
  • E. Sorun yoktur; hedef doluysa iki depo da eski hâlinde kalır

24. Bir sinema programında Seat sınıfına koltuk numarasına göre __eq__ eklendi. Aşağıdaki döngü bu değişiklikten önce üç koltuğu da listeye ekliyordu. __eq__ eklendikten sonra program ne yazdırır?

class Seat:
    def __init__(self, number):
        self.number = number

    def __eq__(self, other):
        if not isinstance(other, Seat):
            return NotImplemented
        return self.number == other.number

booked = []
for seat in [Seat(12), Seat(7), Seat(12)]:
    if seat not in booked:
        booked.append(seat)

for seat in booked:
    print(seat.number)
  • A. Alt alta 12, 7 ve 12
  • B. Alt alta 7 ve 12
  • C. TypeError; Seat nesneleri in ile aranamaz
  • D. Yalnız 7
  • E. Alt alta 12 ve 7

25. assert amount > 0, "Tutar pozitif olmalı" ile iş kuralı korumak neden güvenli değildir?

  • A. Python -O ile çalıştırılınca assert satırları atlanır
  • B. assert’ün yükselttiği hata yakalanamaz
  • C. assert karşılaştırma değil, bool türünde bir değişken bekler
  • D. assert ikinci bir mesaj parametresi kabul etmez
  • E. assert satırları test_ ile başlamayan dosyalarda çalışmaz

1. Doğru: E. Bu bağıntı negatif değerlerde de tutar: -7 // 2 sonucu -4, -7 % 2 sonucu 1 olur ve -4 * 2 + 1 işlemi -7 eder. Python // sonucunu bu bağıntı tutsun diye aşağıya yuvarlar.

  • A yanlış: Bölmenin sonucunu yuvarlama fikri günlük hesaptan tanıdıktır. Ama // en yakına değil aşağıya yuvarlar: 7 // 2 işlemi 4 değil 3 verir.
  • B yanlış: Bu C davranışıdır. Python aşağıya yuvarlar: -7 // 2 işlemi -3 değil -4 verir.
  • C yanlış: C’de kalanın işareti bölünenin işaretini izlediği için bu beklenir. Python’da kalan bölenin işaretini alır: -7 % 2 işlemi 1 verir.
  • D yanlış: Bölümü bölenle çarpınca sayıya dönüleceği düşünülebilir. Ama kalan eklenmezse bağıntı tutmaz: (7 // 2) * 2 işlemi 7 değil 6 eder.

2. Doğru: A. join() parçaları ayırıcıyla birleştirip yeni bir metin döndürür. Listeye dokunmaz.

  • B yanlış: join() bir liste değil, tek bir metin döndürür.
  • C yanlış: Ayırıcı olarak virgül verildi. Ayırıcısız birleştirme "".join(parts) ile yapılır.
  • D yanlış: Ayırıcı yalnız elemanların arasına konur, başa eklenmez.
  • E yanlış: join() listeyi değiştirmez. parts hâlâ iki elemanlı listedir.

3. Doğru: D. Olmayan bir anahtarı köşeli parantezle okumak KeyError verir.

  • A yanlış: Olmayan bir anahtarı aramak da hata verecek gibi görünür. Ama in yalnız sorar ve False verir.
  • B yanlış: .get() köşeli parantezle aynı işi yapıyor gibi göründüğü için aynı hatayı vereceği sanılır. Oysa anahtar yoksa None döndürür.
  • C yanlış: Anahtarı arayan her çağrının hata vereceği düşünülebilir. Ama varsayılan değer verilen .get() anahtar yoksa 0 döndürür.
  • E yanlış: Olmayan anahtarı okumak hata verdiği için yazmanın da hata vereceği düşünülür. Oysa atama sözlüğe yeni bir kayıt ekler.

4. Doğru: D. n = n * 2 satırı yerel n adını 8 değerindeki yeni bir nesneye bağlar. x hâlâ 4’e bağlıdır. Fonksiyon bir değer de döndürmez.

  • A yanlış: Fonksiyon return içermediği için None beklenebilir. Ama yazdırılan, fonksiyonun dönüş değeri değil, x’tir.
  • B yanlış: n * 2 işleminin hem n’i hem x’i ayrı ayrı ikiye katladığı düşünülebilir. x hiç değişmez.
  • C yanlış: Liste parametresinin yerinde değiştiğini gören biri sayının da değişeceğini düşünebilir. Ama burada nesne değiştirilmez, yalnız yerel ad yeni bir nesneye bağlanır.
  • E yanlış: Parametrenin çağıranın değerine bağlı olduğu için ona atama yapılamayacağı sanılabilir. Parametre yerel bir addır, ona atama yapılabilir.

5. Doğru: D. int() sayıya çevrilemeyen metinde ValueError yükseltir. Beklenen hata türü açıkça yazılmıştır; başka hatalar gizlenmez.

  • A yanlış: En geniş biçimdir; programı Ctrl+C ile durdurmak istediğinizde oluşan istisnayı bile yakalar.
  • B yanlış: Çalışır ama beklenmedik hataları da yakalar; hata türü olabildiğince dar yazılmalıdır.
  • C yanlış: int() bir metin almıştır, yani tür doğrudur; hata metnin içeriğinden gelir.
  • E yanlış: Hata if ile yakalanmaz; int(raw) çevrilemezse istisna daha karşılaştırma yapılmadan yükselir.

6. Doğru: C. empty sözlüğün elemanına atama yaptığı için a sözlüğünü yerinde değiştirir. replace ise yalnız yerel product adını yeni bir sözlüğe bağlar; b eski sözlüğü göstermeye devam eder.

  • A yanlış: Elemana atama ile ada atamanın etkisi ters çevrilirse bu sonuç çıkar. Oysa elemana atama nesneyi değiştirir, ada atama yalnız yerel adı yeniden bağlar.
  • B yanlış: Fonksiyonların sözlüğün kopyasını aldığı düşünülürse ikisinin de kopya üzerinde çalıştığı sanılabilir. Ama parametre çağıranın sözlüğüne bağlanır; empty o sözlüğü değiştirir.
  • D yanlış: İki fonksiyon da parametresine atama yaptığı için ikisinin de çağıranı etkileyeceği sanılabilir. Ama replace içindeki atamanın solunda yalnız ad var; bu atama b adını değiştirmez.
  • E yanlış: Aynı parametre adı iki fonksiyonda geçtiği için çakışma olacağı sanılabilir. Ama her fonksiyonun parametresi kendi yerel adıdır; program hatasız çalışır.

7. Doğru: E. İki çekim de bakiyeden düşülür. Ama account.balance -= 50 satırı withdraw() metodundan geçmediği için ikinci çekim geçmişe yazılmaz. Bakiye ile geçmiş artık birbirini tutmaz; niteliği metotla değiştirmenin gerekçesi budur.

  • A yanlış: Geçmiş listesinin doğrudan atamadan sonra silindiği düşünülebilir. Ama atama yalnız balance niteliğine dokunur; withdraw() metodunun eklediği -100 listede kalır.
  • B yanlış: Sınıfta bir withdraw() metodu bulunduğu için niteliğin yalnız onunla değişebileceği sanılabilir. Python doğrudan atamayı engellemez; sorun bir hata değil, hata vermeden oluşan tutarsızlıktır.
  • C yanlış: Geçmişe yazılmayan çekimin bakiyeye de yansımadığı sanılabilir. Ama account.balance -= 50 niteliği doğrudan değiştirir; bakiye 350 olur.
  • D yanlış: Bakiyedeki her değişikliğin geçmişe kendiliğinden yazılacağı düşünülebilir. Ama kayıt yalnız withdraw() içindeki append satırıyla yapılır; doğrudan atama bu satırı çalıştırmaz.

8. Doğru: C. Kalış uzasa da kısalsa da çıkış günü giriş gününden sonra gelmelidir. Niteliklerin değeri değişir, bu kural rezervasyon kullanıldığı sürece doğru kalır.

  • A yanlış: Üç gecelik bir rezervasyon oluşturulurken bu koşul doğrudur. Ama misafir kalışını uzatınca bozulur: bu, rezervasyonun o anki değeridir, kural değildir.
  • B yanlış: Koşul iki günü karşılaştırır, ama yönü terstir: çıkış gününü giriş gününden önceye koyar. Böyle bir rezervasyon gerçekte olamaz.
  • D yanlış: Giriş ve çıkış günlerini karşılaştırdığı için doğru kurala benzer. Ama en az bir haftalık kalış ister, iki gecelik geçerli bir rezervasyonu geçersiz sayar.
  • E yanlış: “Değişmez koşul” adı, niteliklerin değişmediği izlenimini verir. Ama kalış uzayınca check_out değişir. Değişmeyen, değerlerin uyması gereken kuraldır.

9. Doğru: C. Setter metodunun adı price değil set_price olduğu için setter price adına bağlanmaz. price yalnız getter’ı olan bir property olarak kalır ve ona değer atanamaz. Getter, @price.setter ve setter aynı adı taşımalıdır.

  • A yanlış: Setter bulunamayınca atamanın sıradan bir nitelik oluşturacağı düşünülebilir. Ama price sınıfta bir property olduğu için Python nesnede aynı adlı nitelik oluşturmaz, hata verir.
  • B yanlış: Setter tanımlanırken property’nin henüz hazır olmadığı düşünülebilir. Ama price hemen üstteki getter’la tanımlanmıştır; @price.setter satırı hata vermez. Hata, son satırdaki atamada çıkar.
  • D yanlış: Dekoratörde price yazdığı için setter’ın property’ye oradan bağlandığı sanılabilir. Ama setter’ın adı farklı olduğu için pen.price = -5 ataması bu metoda gitmez; denetim hiç çalışmaz.
  • E yanlış: Getter _price değerini döndürdüğü için atamanın da doğrudan _price niteliğine yazıldığı sanılabilir. Ama atama property üzerinden yapılır ve setter’ı olmayan property’ye değer atanamaz.

10. Doğru: B. Ürün listeye eklendikten sonra fiyat denetlenir. raise çalışınca toplam güncellenmez, ama listeye eklenen ad orada kalır. Sepet yarım güncellenmiştir: bir ürün var, toplam 0. Fiyat denetimi append satırından önce yapılsaydı sepet hiç değişmezdi.

  • A yanlış: Ürün eklendiği için fiyatın da toplama eklendiği düşünülebilir. Ama self._total += price satırı raise satırından sonra gelir ve hiç çalışmaz.
  • C yanlış: Hata yükselince metodun bütün işinin iptal edildiği sanılabilir. Ama raise önceki satırlarda yapılan değişikliği geri almaz; append çoktan çalışmıştır.
  • D yanlış: raise görülünce programın duracağı beklenebilir. Ama except ValueError hatayı yakalar ve pass hiçbir şey yazmadan devam eder; son satır yine çalışır.
  • E yanlış: Toplamın güncellendiği, listenin güncellenmediği sanılabilir. Satırların sırası tam tersini gösterir: önce listeye eklenir, toplama hiç gelinmez.

11. Doğru: C. students() iç listenin kendisini döndürür. names ile _students aynı listeyi gösterir ve names.append("Mert") iç listeye eklenir. Ekleme add() metoduna uğramadığı için kontenjan kontrolü çalışmaz, sınıfta üç öğrenci olur.

  • A yanlış: Kontenjan kuralı sınıfta yazılı olduğu için her eklemede çalışacağı düşünülebilir. Ama kural yalnız add() çağrılınca çalışır; names.append() bu metodu çağırmaz.
  • B yanlış: Alt çizgi “dokunmayın” uyarısı gibi okunduğu için bir engel koyduğu sanılabilir. Ama alt çizgi teknik bir engel değildir; metot listeyi döndürür ve dış kod onu kullanır.
  • D yanlış: names ayrı bir değişken olduğu için listenin kopyasını tuttuğu sanılabilir. Ama return self._students kopya oluşturmaz; aynı listeye bir ad daha bağlanır.
  • E yanlış: Listeye ekleme işi sınıfın metodunda yapıldığı için append çağrısının da sınıfa bağlı olduğu sanılabilir. Ama append listenin metodudur; listeye ulaşan her kod onu çağırabilir.

12. Doğru: B. Koltuk kuralı seansın, puan ve seviye kuralı müşterinin işidir. İkisi de Ticketing içinde yazılı ve Ticketing öteki nesnelerin niteliklerini doğrudan değiştiriyor. Her yeni kural bu sınıfı büyütür ve sınıf “her şeyi yapan” bir merkeze dönüşür.

  • A yanlış: 8. haftadaki yarım güncelleme örneği akla gelebilir. Ama burada koltuk önce denetlenir, sonra listeye eklenir; sıra doğrudur. Sorun kuralların hangi sınıfta durduğudur.
  • C yanlış: Satışı Ticketing yönettiği için bütün kuralların da orada durması gerektiği sanılabilir. Ama işlemin sırasını yönetmek ayrı bir iştir; kurallar ait oldukları nesnelerde durmalıdır.
  • D yanlış: Kalıtım kuralları tek yerde topluyormuş gibi görünür. Ama seans da müşteri de bir bilet satış sınıfı değildir; kalıtım yanlış modeldir.
  • E yanlış: Property doğrulama için kullanıldığından çözüm gibi görünür. Ama puan ve seviye kuralı yine Ticketing içinde yazılı kalır; property kuralın yerini değiştirmez.

13. Doğru: C. File sınıfının sözü, write() çağrısının satırı eklemesidir. save_log(ReadOnlyFile()) ise PermissionError yükseltir. is-a cümlesi kurulabilse de ReadOnlyFile, File sınıfının yerine geçemez.

  • A yanlış: “Salt okunur dosya bir dosyadır” cümlesi doğru göründüğü için karar da doğru sanılabilir. Ama cümle tek başına yetmez; üst sınıfın beklendiği yerde alt sınıfın sözü tutup tutmadığına bakılır.
  • B yanlış: İki sınıfın davranışı çok farklı olduğu için Python’ın bunları ayrı tür sayacağı düşünülebilir. Ama ReadOnlyFile, File sınıfından türediği için çağrı True verir; fonksiyon da tür denetimi yapmaz.
  • D yanlış: Override edilen metodun üst sınıftakine benzemesi beklendiği için raise yasakmış gibi görünebilir. Ama sınıf tanımı sorunsuz çalışır; hata yalnız write() çağrılınca yükselir.
  • E yanlış: Alt sınıfın kurucusu olmayınca nitelikler eksik kalacakmış gibi görünür. Ama __init__ üst sınıftan devralınır ve lines niteliği kurulur; sorun write() metodunun verdiği sözdedir.

14. Doğru: B. super().total() üst sınıfın total() metodunu aynı nesne için çalıştırır ve 100 döndürür; alt sınıf buna 20 ekler. Üst sınıfın hesabı değişirse alt sınıfın sonucu da kendiliğinden değişir.

  • A yanlış: Yazım super().total() ile neredeyse aynı olduğu için doğru sanılabilir. Ama parantez olmadan super yalnız bir sınıf adıdır; total adında bir niteliği olmadığı için AttributeError yükselir.
  • C yanlış: Üst sınıfın adını yazmak doğrudan o metoda gidiyormuş gibi görünür. Ama sınıf adıyla yapılan çağrıda nesne kendiliğinden geçmez; self argümanı eksik kaldığı için TypeError yükselir.
  • D yanlış: super() en sık kurucuda görüldüğü için üst sınıfla ilgili her işte __init__ çağrılacağı sanılabilir. Ama __init__ bir değer döndürmez; None + 20 işlemi TypeError yükseltir.
  • E yanlış: Metot self üzerinden çağrıldığı için üst sınıftaki sürüme gidiyormuş gibi görünür. Ama self bir TaxedProduct nesnesidir; çağrı yine alt sınıftaki total() metoduna gider, metot kendini durmadan çağırır ve RecursionError yükselir.

15. Doğru: A. EmailNotification kendisine verilen nesnenin sınıfını sormaz, yalnız send_message(msg) çağırır. FakeSmtp ve smtplib.SMTP nesnelerinin ikisinde de bu metot olduğu için ikisi de çalışır. Ortak üst sınıf olmadan polimorfizm, yani duck typing budur.

  • B yanlış: sent listesi FakeSmtp sınıfının en göze çarpan parçası olduğu için çalışmayı onun sağladığı sanılabilir. Ama EmailNotification bu listeye hiç bakmaz; liste yalnız gönderilenleri sonradan görmeye yarar.
  • C yanlış: İki nesne aynı yerde kullanılabildiği için aralarında bir kalıtım ilişkisi kurulmuş sanılabilir. Ama FakeSmtp hiçbir sınıftan türetilmedi; Python kendiliğinden bir üst sınıf da atamaz.
  • D yanlış: EmailMessage kodda geçtiği için gönderen nesnelerin de ondan geldiği sanılabilir. Ama EmailMessage gönderilen iletinin sınıfıdır; smtp niteliğindeki nesne ise iletiyi gönderen başka bir nesnedir.
  • E yanlış: Farklı nesneler sorunsuz çalıştığı için arka planda bir tür denetimi yapıldığı düşünülebilir. Ama sınıfta isinstance() ya da type() yok; yalnız metot çağrılıyor.

16. Doğru: E. Burada beklenen hata, nesnede send bulunmamasıdır; bu durumda Python AttributeError yükseltir. except Exception ise send() içinde oluşan TypeError ya da ZeroDivisionError gibi programlama hatalarını da yutar ve hepsine “Desteklenmiyor” der. EAFP’de yalnız beklenen hata türü yakalanır. Dar yakalamada da send() içindeki bir AttributeError yakalanabilir, ama yutulan hataların sayısı azalır.

  • A yanlış: İki yaklaşım da hatalara karşı önlem aldığı için bir yakalama biçiminin birine ait olduğu sanılabilir. Ama try/except EAFP’nin aracıdır; LBYL işi yapmadan önce koşulu denetler.
  • B yanlış: Dar yakalama daha az iş yapıyormuş gibi görünebilir. Ama gerekçe hız değil, hangi hataların yutulduğudur.
  • C yanlış: Exception adı kendi yazdığımız raise satırlarını düşündürebilir. Ama Python’ın kendi yükselttiği AttributeError, TypeError gibi hatalar da Exception kapsamındadır ve yakalanır.
  • D yanlış: İki örnekte de “Desteklenmiyor” döndüğü için yazımların eşdeğer olduğu sanılabilir. Ama Exception neredeyse bütün hata türlerini kapsar, AttributeError ise yalnız erişilemeyen nitelik ya da metot durumunu.

17. Doğru: A. repr() yalnız __repr__ metoduna bakar. __str__ yoksa str() __repr__’a başvurur, tersi olmaz. Bu yüzden yalnız __str__ tanımlamak repr davranışını değiştirmez ve sonuç <__main__.Product object at 0x...> gibi varsayılan temsildir.

  • B yanlış: Sınıfta __repr__ yazılmadığı için metodun eksik olduğu düşünülebilir. Ama varsayılan __repr__ her sınıfta bulunur.
  • C yanlış: Bir şey tanımlanmadığında sonuç None olacakmış gibi görünür. Ama repr() her zaman bir metin döndürür.
  • D yanlış: Sınıfta tek temsil metodu olduğu için Python’ın onu her yerde kullanacağı sanılabilir. Ama repr() __str__ metoduna bakmaz, kendi varsayılanında kalır.
  • E yanlış: Temsil yazılmadığı için boş sonuç beklenebilir. Ama varsayılan temsil sınıfın adını ve nesnenin kimlik bilgisini (0x...) içerir.

18. Doğru: D. SmsNotification send metodunu yeniden yazmış, ilk turda onun döndürdüğü metin yazılır. EmailNotification metodu yazmamış, bu yüzden ikinci turda üst sınıftaki send çalışır ve NotImplementedError yükseltir. Nesne oluşturulurken bir denetim yapılmaz, hata metot çağrılınca çıkar.

  • A yanlış: Metodu yazmayan sınıfın döngüde kendiliğinden atlanacağı sanılabilir. Ama Python hiçbir nesneyi atlamaz; ikinci turda üst sınıftaki send çalışır ve istisna program durdurur.
  • B yanlış: NotImplemented ile NotImplementedError adları birbirine çok benzer. Ama üst sınıftaki metot bir değer döndürmez, istisna yükseltir.
  • C yanlış: EmailNotification gövdesinde bir şey olmadığı için send çağrısının değer döndürmeyeceği sanılabilir. Ama metot üst sınıftan gelir ve raise ile istisna yükseltir; print çağrısına ulaşılmaz.
  • E yanlış: Eksik metot nesnenin kendisini eksik bırakıyormuş gibi görünebilir. Ama NotImplementedError yalnız metot çağrılınca yükselir; liste sorunsuz oluşturulur.

19. Doğru: B. SMTPRecipientsRefused sınıfının üst sınıfları SMTPException, OSError, Exception ve BaseException sınıflarıdır. ValueError bu zincirde yoktur, bu yüzden except ValueError bloğu hatayı yakalamaz.

  • A yanlış: Hata başka bir modülden geldiği için genel bloğun onu görmeyeceği sanılabilir. Ama OSError da Exception sınıfından türer; except Exception bu hatayı yakalar.
  • C yanlış: Hatanın adı farklı olduğu için yalnız kendi adıyla yakalanacağı sanılabilir. Ama SMTPRecipientsRefused bir SMTPException’dır; üst sınıfı yazan except bloğu alt sınıfın nesnesini de yakalar.
  • D yanlış: OSError dosya ve işletim sistemi hatalarını çağrıştırdığı için e-postayla ilgisiz görünür. Ama SMTPException OSError sınıfından türediği için bu blok da hatayı yakalar.
  • E yanlış: Modülün bütün hatalarını yakalamak daha yaygın olduğu için hatanın kendi adıyla yakalanamayacağı sanılabilir. Ama yükseltilen sınıfın adını yazan except bloğu onu doğrudan yakalar.

20. Doğru: B. add_item bir Product ve bir int alır, değer döndürmez. total parametre almaz ve bir float döndürür. Satırlar iki metodu da imzalarına uygun çağırıyor.

  • A yanlış: Ekleme metodunun yeni toplamı döndürdüğü sanılabilir. Ama -> None metodun değer döndürmediğini söyler; total değişkeni None olur.
  • C yanlış: Ürün kodu ürünü tanıttığı için onu vermek yeterli görünebilir. Ama product: Product bir ürün nesnesi bekler, metin kod beklemez.
  • D yanlış: Toplamın bir ürüne göre hesaplandığı sanılabilir. Ama total(self) imzasında self dışında parametre yoktur; metot argümansız çağrılır.
  • E yanlış: Miktar verilmezse 1 sayılacağı sanılabilir. Ama amount parametresinin varsayılan değeri yok; iki argüman da verilmelidir.

21. Doğru: A. json.load dosyadaki JSON metnini Python değerlerine çevirir: burada bir sözlük içeren bir liste. data[0] ilk sözlüktür, ["points"] de o sözlükten puanı okur ve 40 yazılır.

  • B yanlış: Sözlük okur gibi anahtarla erişmek doğru görünür. Ama data sözlük değil, sözlük içeren bir listedir; listeye metin anahtarla erişilince TypeError alınır.
  • C yanlış: Kaydederken to_dict() kullanıldığını bilen öğrenci okurken de aynı metodu arayabilir. Ama data[0] bir sözlüktür; to_dict() yalnız kendi sınıfınızın nesnelerinde vardır.
  • D yanlış: Kaydedilen şey bir müşteri olduğu için okunan değerin de nitelikleri olan bir nesne olduğu sanılabilir. Ama json.load sözlük verir; sözlükte .points niteliği yoktur ve AttributeError alınır.
  • E yanlış: Dosyada tek müşteri olduğu için data değerinin o müşteri olduğu sanılabilir. Ama data bir listedir; listede points niteliği yoktur.

22. Doğru: E. Bir kuralı, kuralın sınırladığı durumu tutan ve o durumu değiştiren metotta kuralı denetleyen sınıf korur. Yolcu listesini Flight tutar ve board() içinde denetler. Bagaj listesini Passenger tutar ve add_bag() içinde denetler.

  • A yanlış: Bagaj kuralı __init__ içinde değil, ayrı bir metotta durduğu için gözden kaçabilir. Ama add_bag() üçüncü bagajda ValueError yükseltir; bagaj sınırını Passenger korur.
  • B yanlış: Yolcular uçağın listesinde durduğu için yolculara ait her kuralın uçakta olduğu sanılabilir. Ama bagajlar Passenger nesnesinin kendi listesindedir; Flight bu listeye hiç dokunmaz.
  • C yanlış: İki sınıfın görevleri yer değiştirmiş. Yolcu sayısı Flight._passengers listesinden, bagaj sayısı Passenger._bags listesinden okunur; her kural da kendi listesini tutan sınıftadır.
  • D yanlış: Uçağa binen yolcu olduğu için kuralların da onda olduğu düşünülebilir. Ama Passenger uçaktaki öteki yolcuları görmez; kaç kişinin bindiğini yalnız Flight bilir.

23. Doğru: D. move() önce take_out() çağırır ve ürün kaynaktan çıkar. Sonra put_in() hedefin dolu olduğunu görüp ValueError yükseltir. İki depo da kendi kuralını korudu, ama ürün artık hiçbir depoda yok. Bunu önlemek için iki deponun koşulu değişiklikten önce denetlenir: kaynakta ürün var mı, hedefte yer var mı? İkisi de uygunsa ürün taşınır.

  • A yanlış: Hata yükseldikten sonra işlemin yine tamamlandığı sanılabilir. Ama put_in() kapasiteyi denetleyip raise ile durur; append satırına gelinmez.
  • B yanlış: Taşımada ürünün bir depodan çıkıp ötekine girmesi gerektiği için iki depoda birden kalabileceği düşünülebilir. Ama take_out() ürünü kaynaktan gerçekten siler; hedefe ise hiç eklenmez.
  • C yanlış: Python’ın yarım kalan işlemi geri aldığı düşünülebilir. Ama böyle bir düzenek yoktur; geri koyan bir kod yazılmadıkça kaynaktan çıkan ürün geri dönmez.
  • E yanlış: Her depo kendi kuralını denetlediği için bütün sistemin de korunduğu sanılabilir. Ama hata ikinci adımda çıkar; birinci adımdaki değişiklik geri alınmaz.

24. Doğru: E. not in listedeki her elemanı == ile karşılaştırır ve == artık __eq__ metodunu kullanır. İkinci Seat(12) listedeki ilk Seat(12) ile eşit sayılır ve eklenmez. __eq__ eklemek, satırlarına hiç dokunulmayan bu döngünün davranışını da değiştirdi.

  • A yanlış: Değişiklikten önceki çıktı budur. __eq__ yalnız a == b yazılan satırları etkiliyormuş gibi düşünülürse çıktının değişmeyeceği sanılır. Ama in ve not in de eşitliği __eq__ ile sınar.
  • B yanlış: Eşit sayılan ikinci koltuğun ilkinin yerine geçtiği düşünülebilir. Ama not in koşulu False olunca hiçbir şey yapılmaz; ilk Seat(12) yerinde kalır ve sıra değişmez.
  • C yanlış: Kendi sınıfımızdan nesnelerin listede aranamayacağı sanılabilir. Ama in her nesneyle çalışır: __eq__ yazılmadan önce kimliğe, yazıldıktan sonra koltuk numarasına göre karşılaştırır.
  • D yanlış: Tekrar eden numaranın listeye hiç girmediği düşünülebilir. Ama ilk Seat(12) eklenirken listede eşiti yoktu; yalnız ikinci Seat(12) eklenmez.

25. Doğru: A. Python -O seçeneğiyle çalıştırıldığında assert satırları kaldırılır ve kural hata vermeden ortadan kalkar. İş kuralı programın normal işleyişinin parçasıdır ve if ...: raise ... ile korunmalıdır.

  • B yanlış: assert geliştirici kontrolü olarak anlatıldığı için hatasının yakalanamayacağı düşünülebilir. Ama AssertionError da yakalanabilir. Sorun, -O ile satırın kaldırılmasıdır.
  • C yanlış: assert koşul doğruysa geçtiği için yalnız bool değişkenlerle çalıştığı sanılabilir. Ama herhangi bir koşulu sınayabilir. amount > 0 de bir karşılaştırmadır.
  • D yanlış: assert bir fonksiyon gibi parantezle yazılmadığı için ikinci bir değer alamıyormuş gibi görünür. Ama virgülden sonra ikinci argüman olarak mesaj verilebilir.
  • E yanlış: assert test dosyalarında çok görüldüğü için oraya ait sanılabilir. Ama her yerde yazılabilir. Sorun, -O ile kaldırılmasıdır.

Dönem özeti

  • Nesne tasarımında sınıfları yazmak işin bir kısmıdır. Hangi nesnenin durumunu kimin ve hangi sırayla değiştireceğine de siz karar verirsiniz.
  • Bir iş kuralı, sınırladığı durumu tutan sınıfta durur. Üç kitap sınırı üyenin listesini sınırladığı için Member’dadır.
  • Kapsülleme, nesnenin içindeki değiştirilebilir (mutable) listeleri dışarıdan korumayı da gerektirir. Property iç listeyi değil, demet kopyasını döndürür.
  • Birden fazla nesneyi değiştiren işlemde nesneler arası tutarlılığı ayrıca düşünün: önce bütün kontroller, sonra bütün değişiklikler. Yalnız bir kaydı değiştiren iç adımları alt çizgiyle adlandırın. Dışarıya açık yol, işlemi yöneten sınıf olsun.
  • is iki adın aynı nesneyi gösterip göstermediğini, == ise iki nesnenin eşit sayılıp sayılmadığını sorar.
  • __eq__ tanımı in ve remove() gibi koleksiyon işlemlerini de etkiler. Bu etkiyi regresyon kontrolleriyle sınayın.
  • İş kuralını if ...: raise ... korur. assert geliştirirken ve test ederken kullanılır, python -O ile kaldırıldığı için iş kuralını korumaz.
  • Dönem sonunda sizden beklenen, küçük bir değişikliği gerekçesini açıklayarak yapmanız, kodun çalıştığını göstermeniz ve kontrollerle doğrulamanızdır.

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

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

  • Bir sistemi okurken hangi sınıfın hangi durumu koruduğunu belirler.
  • Birden çok nesneyi değiştiren işlemde nesneler arası tutarlılığı gözetir.
  • in ve list.remove() işlemlerinin aynı nesneyi ya da == ile eşit elemanı aradığını gösterir.
  • __eq__ eklemenin koleksiyon davranışını da değiştirdiğini fark eder ve etkiyi sınar.
  • İnvariant’ı raise ile, geliştirici kontrolünü assert ile yazar.
  • Bir iş kuralını, koruduğu durumun sahibi olan sınıfa koyar.
  • Bir tasarım değişikliğini regresyon kontrolleriyle doğrular.
Başa dön