Polimorfizm ve duck typing
Geçen hafta alt sınıfın üst sınıftaki bir metodu override edebildiğini gördünüz. Bu hafta farklı sınıflardan nesneleri aynı kodla kullanacağız. Farklı sınıflardan nesnelerin aynı metot çağrısıyla, aynı döngüde ya da aynı fonksiyonda kullanılabilmesine polimorfizm denir. Python’da bunun için sınıfların ortak bir üst sınıftan türemesi her zaman gerekmez. Nesnenin sınıfına değil, hangi metotları olduğuna bakan bu yaklaşıma duck typing denir. Adı “Ördek gibi yürüyor ve ördek gibi vaklıyorsa ördektir” sözünden gelir. Örneklerin çoğu okulun duyuru programından: bir duyuru e-postayla, SMS’le ve okulun mobil uygulamasından gönderiliyor.
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ı
- Aynı metot çağrısının farklı nesnelerde farklı iş yapması
- Ortak üst sınıf olmadan polimorfizm (duck typing)
- Her yeni türde uzayan tür koşulu zincirinin neden kod kokusu sayıldığı
isinstance()kullanımının yerinde olduğu durumlarhasattr()sonucunun neyi söyleyip söylemediği- EAFP ile LBYL yaklaşımlarının farkı ve yalnız beklenen istisnayı yakalamak
- Polimorfizm ile kalıtımın farkı
Aynı çağrı, farklı davranış
Bir duyuruyu bütün kanallardan tek döngüyle göndermek istiyoruz. Aşağıdaki iki sınıfın ortak bir üst sınıfı yok, ama ikisinde de send(message) metodu var. Döngü çalışır mı? Çalışırsa ne yazar?
Döngü, nesnenin hangi sınıftan geldiğini bilmeden send() metodunu çağırır. Her nesne kendi sınıfındaki send() metodunu çalıştırır. Aynı çağrının farklı nesnelerde farklı iş yapması polimorfizmdir.
Kalıtım olmadan da polimorfizm
Sıra mobil uygulama kanalında. Bu kanalın sınıfını başka bir ekip yazdı. Geçen haftaki bilgiyle bütün kanalları ortak bir Notification üst sınıfından türetebilirdiniz. Aşağıda EmailNotification böyle yazıldı. AppNotification sınıfını yazan ekip ise onu Notification sınıfından türetmedi. Döngü ikinci nesnede hata verir mi? isinstance() satırları ne yazar?
AppNotification nesnesi bir Notification sayılmıyor, ama döngü onunla da çalıştı. Çağrı için gereken tek şey nesnede send(message) metodunun bulunması.
Nesnenin hangi sınıftan olduğuna değil, gereken metodu olup olmadığına bakın.
Duck typing’in kuralı budur.
Her yeni türde uzayan koşul zinciri
Farklı türdeki kanalları ayırmanın ilk akla gelen yolu, nesnenin türüne bakan bir if/elif zinciridir. type(nesne) nesnenin sınıfını verir.
Aşağıdaki sınıflarda gönderme metotlarının adları farklı. Bu yüzden send_notification() her türü ayrı bir dalda tanıyor. AppNotification sonradan eklendi ve fonksiyona dokunulmadı. Son satır ne yazar?
Her yeni kanal bu fonksiyona bir elif daha ekletir. Eklemeyi unutursanız fonksiyon hata da vermez: hiçbir dal çalışmayınca None döndürür. Kodun çalıştığı ama tasarımda bir sorun olduğunu gösteren böyle işaretlere kod kokusu (code smell) denir. Buradaki sorun, mesajın nasıl gönderileceğini nesnenin değil fonksiyonun bilmesi. Bütün sınıflarda aynı adlı send() metodu olursa fonksiyon tek satıra iner ve yeni bir kanal eklemek için onu değiştirmeniz gerekmez:
def send_notification(notification, message):
return notification.send(message)isinstance() nerede yerinde?
Tür kontrolü bazı yerlerde yerindedir: programa dışarıdan gelen verinin beklenen türde olup olmadığını denetlerken (sınır doğrulaması), bir nesneyi dosyaya ya da ağa yazmak için metne çevirirken (serileştirme) ya da karar gerçekten türe bağlıysa. Kod kokusu, nesnenin kendi metodunu çağırmak yerine her yeni türde uzayan bir koşul zinciriyle ne yapılacağını seçmektir. Tür kontrolü gerekiyorsa çoğu zaman isinstance() seçilir: type(x) is Sınıf yalnız tam o sınıfı kabul eder, isinstance(x, Sınıf) alt sınıfların nesnelerini de kabul eder.
hasattr() ne söyler, ne söylemez?
Listeye send() metodu olmayan bir nesne karışırsa program çökmesin, “Desteklenmiyor” yazsın. Önce şunu sorabilirsiniz: nesnede send var mı? Bir nesnede belirli bir adda nitelik ya da metot bulunup bulunmadığını hasattr(nesne, "ad") ile sorarsınız. İki satır ne yazar?
Ancak hasattr(obj, "send") yalnızca nesnede send adında bir şey bulunduğunu söyler. Bunun çağrılabilir bir metot mu yoksa sıradan bir nitelik mi olduğunu, message parametresini alıp almadığını ya da gerçekten mesaj gönderip göndermediğini söylemez. Örneğin obj.send = "evet" atanmış bir nesnede de hasattr(obj, "send") True verir. Bu yüzden duck typing’i “önce her şeyi hasattr ile kontrol et” diye anlamayın.
EAFP ve LBYL
Python kodunda iki yaklaşımın adını sık görebilirsiniz:
- LBYL (Look Before You Leap, “atlamadan önce bak”): İşi yapmadan önce koşulu kontrol edin.
- EAFP (Easier to Ask Forgiveness than Permission, “özür dilemek izin istemekten kolaydır”): İşi doğrudan yapmayı deneyin. Beklediğiniz hata çıkarsa onu uygun
exceptile yakalayın.
hasattr() ile önce sormak LBYL yaklaşımıdır:
if hasattr(notification, "send"):
result = notification.send(message)
else:
result = "Desteklenmiyor"EAFP yaklaşımında send() doğrudan çağrılır. Nesnede send yoksa Python AttributeError yükseltir ve except bu hatayı yakalar. Aşağıdaki Printer sınıfında send yok. SmsNotification sınıfının send() metodunda ise upper yanlış yazılmış. Üç satır ne yazar?
except Exception gibi geniş bir yakalama her hatayı yutar. Yalnız beklediğiniz hata türünü yakalayın. Hücre bir tuzak daha gösteriyor: AttributeError, send() metodunun içinde de oluşabilir. SmsNotification mesaj gönderebilen bir sınıf, ama metodun içindeki yazım hatası yüzünden “Desteklenmiyor” sonucunu aldı. Kendi programlama hatanız böylece gözden kaçar. Her bildirim nesnesinde send() bulunacağı baştan belliyse çoğu zaman en sade çözüm metodu doğrudan çağırmaktır.
Bu iki yaklaşımda 5. haftada gördüğünüz try/except bilgisini nesnelerin metotlarına uyguluyorsunuz. Hangisinin her zaman doğru olduğunu söyleyen bir kural yok. Bir yanda gereksiz ön kontrollerle uzayan kod, öbür yanda gerçek hataları da yutan geniş bir except var. İkisinin arasındaki dengeyi gözetin.
Davranış sözleşmesi
Duck typing’de de kurallar vardır. send(message) gibi ortak bir metodun ne aldığı, ne döndürdüğü ve hangi durumda hangi hatayı yükselttiği belli olmalıdır. Örneğin bu bölümdeki bütün bildirim sınıflarında send() bir metin alır ve bir metin döndürür. Bu kuralları yazan ayrı bir sınıf olmasa bile kuralların kendisi bir davranış sözleşmesidir: çağıran kod bu kurallara güvenerek yazılır.
Gerçek bir e-posta nasıl gider?
Şimdiye kadarki EmailNotification sınıfları yalnız bir metin döndürdü. Gerçek bir e-posta gönderilirken ve okunurken iki protokol kullanılır (protokol, bilgisayarların haberleşirken uyduğu kurallardır):
- SMTP (Simple Mail Transfer Protocol): E-posta programı iletiyi posta sunucusuna SMTP ile verir. Sunucular da iletiyi alıcının sunucusuna kadar SMTP ile birbirine aktarır.
- IMAP (Internet Message Access Protocol): Alıcının e-posta programı sunucudaki posta kutusunu IMAP ile okur ve yönetir: iletileri listeler, açar, klasöre taşır ya da siler.
Python’ın standart kütüphanesindeki EmailMessage sınıfı bir e-posta iletisi kurar. Gönderen, alıcı ve konu sözlükteki gibi köşeli parantezle atanır, iletinin metnini set_content() yazar. Hücre ağa bağlanmaz, yalnız iletiyi kurup yazdırır. print(msg) ne yazar?
Çıktı, SMTP’nin sunucuya taşıdığı ham metindir: önce başlık satırları, bir boş satır, ardından iletinin metni. Metne Türkçe harf yazıp yeniden çalıştırırsanız metin base64 denen bir kodlamaya çevrilir ve okunmaz hâle gelir. Alıcının e-posta programı onu geri çevirir.
Duyuru programı iletiyi kendisi göndermez, bu işi sunucuyla konuşan bir nesneye bırakır. Tarayıcıda gerçek bir sunucu yok. Onun yerine gönderilen iletileri sent listesinde biriktiren sahte bir FakeSmtp sınıfı yazıyoruz. EmailNotification bu kez nesne oluşturulurken iletiyi gönderecek nesneyi (smtp) ve alıcının adresini (to) alıyor. smtp nesnesini bir nitelikte tutması 9. haftadaki has-a ilişkisidir. Göndermeyi self.smtp.send_message(msg) çağrısıyla o nesneye bırakması da delegation’dır. Son üç satır ne yazar?
Gerçek gönderimde FakeSmtp yerine standart kütüphanedeki smtplib.SMTP nesnesi verilir:
import smtplib
with smtplib.SMTP("localhost", 8025) as smtp:
email = EmailNotification(smtp, "[email protected]")
print(email.send("Toplantı 14.00'te"))smtplib.SMTP nesnesinin de send_message(msg) metodu var. EmailNotification kendisine hangi nesnenin verildiğini bilmez, yalnız send_message(msg) çağırır. FakeSmtp ile smtplib.SMTP arasında hiçbir kalıtım ilişkisi yok: ortak üst sınıf olmadan polimorfizm, yani duck typing budur. with bloğu da 5. haftadaki dosyalarda olduğu gibi, blok bitince sunucuyla bağlantıyı kapatır.
Tarayıcıdaki kod hücreleri ağa çıkamaz, bu yüzden bu kod burada çalışmaz. "localhost" kendi bilgisayarınız demektir: gerçek gönderimi bilgisayarınızda çalışan bir deneme sunucusuyla yaparsınız. Adımları Python ile e-posta göndermek sayfası anlatıyor.
Fonksiyonlar da polimorfik davranabilir
len() tek bir fonksiyon, ama aşağıda üç farklı türle çağrılıyor. Üç satır ne yazar?
len() metinle, listeyle ve sözlükle aynı biçimde çalışır, çünkü üç türde de uzunluğu veren __len__ adlı özel bir metot vardır. len(x) yazdığınızda Python nesnenin __len__() metodunu çağırır. Bir işlemin çalışması için nesnede bulunması gereken metotlara protokol denir. 9. haftada Order sınıfına __len__ yazıp len(order) çağırmıştınız. 12. haftada başka özel metotlar yazıp kendi nesnelerinizi print() ve == gibi Python işlemleriyle de çalıştıracaksınız.
Polimorfizm ve kalıtım ayrımı
Kalıtım iki sınıf arasındaki bir ilişkidir: class SmsNotification(Notification) yazdığınızda SmsNotification üst sınıfın metotlarını devralır. Polimorfizm ise farklı nesnelerin aynı metot çağrısıyla kullanılabilmesidir. Kalıtım polimorfizmi kolaylaştırabilir. Ama Python’da ortak üst sınıf zorunlu değildir: bu bölümün ilk örneğinde kalıtım yoktu.
Soyut temel sınıf (ABC)
Duck typing’de ortak metodun ne yapacağı davranış sözleşmesinde yazılıdır, Python bunu denetlemez. Bir ödeme sınıfı pay() metodunu unutursa hata ancak metot çağrılınca ortaya çıkar. Bu beklentiyi koda yazmak isterseniz abc modülündeki soyut temel sınıfı (abstract base class, ABC) kullanırsınız:
from abc import ABC, abstractmethod
class Payment(ABC):
@abstractmethod
def pay(self, amount):
passPayment sınıfı ABC sınıfından türüyor. Metodun üstündeki @abstractmethod satırı 7. haftada tanıdığımız türden bir dekoratördür: pay() metodunu soyut metot, yani alt sınıfların yazması beklenen metot olarak işaretler. Eksik soyut metodu olan sınıftan nesne oluşturulamaz. Aşağıdaki CashPayment sınıfı pay() yerine yalnız refund() metodunu yazıyor. İlk print() ne yazar? Son satırda ne olur?
CashPayment() satırı TypeError yükseltir, çünkü sınıf pay() metodunu yazmadığı için hâlâ soyuttur. Son satırı Payment() yapıp yeniden çalıştırın: soyut sınıfın kendisinden de nesne oluşturulamaz.
Geçen haftaki Shape sınıfı aynı beklentiyi raise NotImplementedError ile yazıyordu. İkisi hatanın ne zaman çıktığında ayrılır: NotImplementedError eksik metot çağrılınca yükselir, ABC ise eksik sınıftan nesne oluşturulurken TypeError yükseltir. Duck typing için ABC gerekmez. Bu bölümün öteki örneklerinin hiçbiri ABC kullanmadı.
Bu haftanın işleri yan yana
Duyuru programındaki işleri önceki haftalarda nasıl yapardık, bu hafta nasıl yapıyoruz:
| İş | Önceki haftalarda | Bu haftaki Python yolu | Dikkat |
|---|---|---|---|
| Bir duyuruyu bütün kanallardan tek döngüyle göndermek | Döngüde türe bakan bir if/elif zinciri, ya da 10. haftadaki gibi ortak üst sınıf ve override |
Her sınıfta send(message), döngüde notification.send(message) |
Çağrı her nesnenin kendi sınıfındaki metoda gider |
| Başka ekibin yazdığı kanalı eklemek | Sınıflarını Notification sınıfından türetmelerini istersiniz |
Sınıfta send(message) bulunması yeter (duck typing) |
isinstance(x, Notification) False döndürse de çağrı çalışır |
| Yeni kanalda gönderme fonksiyonunu değiştirmemek | if/elif zincirine yeni bir dal eklersiniz |
return notification.send(message) |
Dal eklenmeyen türde zincir hata vermez, None döndürür |
send() metodu olmayan nesnede “Desteklenmiyor” yazmak |
Zincirin else dalında yazdırırsınız |
hasattr() ile önce sormak (LBYL) ya da try/except AttributeError (EAFP) |
except AttributeError, send() içindeki yazım hatasını da yakalar |
Türe bakan bir if/elif zinciri yazarsanız üçüncü satırdaki sorunla karşılaşırsınız: her yeni kanal gönderme fonksiyonunu değiştirmeyi gerektirir. Ortak üst sınıf ve override da çalışır, ama şart değil: ikinci satırdaki kanal üst sınıf olmadan da döngüde çalıştı. Gönderme işini fonksiyon yerine nesnenin kendisi bildiğinde dördüncü satırdaki kontrole de çoğu zaman gerek kalmaz. Her nesnede send() olacağı belliyse metodu doğrudan çağırırsınız.
Alıştırmalar
Koşul zincirini kaldır
Tür kontrollerini kaldırın: döngü yalnızca animal.speak() çağırsın ve çıktı aynı kalsın. Ardından bir Bird sınıfı ekleyin ve döngüye dokunmadan onun da çalıştığını gösterin.
Ortak davranışı tamamla
return payment.pay(amount)Rapor çıktıları
ConsoleReport, TextReport ve CompactReport sınıflarının her birine bir render(data) metodu yazın. Tek bir show_report(report, data) fonksiyonuyla üçünü de kullanın. Dördüncü bir rapor sınıfı ekleyin ve show_report() fonksiyonunu değiştirmeden onunla da çalıştığını gösterin.
Çalışır kod görevi: Dört rapor nesnesini bir listeye koyun, döngüyle dolaşıp her birinin render() sonucunu yazdırın. Ayrıca bir nesnede hasattr(..., "render") sonucuna bakın. Sonra çözümünüzün neden tür ya da nitelik kontrol eden bir if zincirine ihtiyaç duymadığını iki cümleyle açıklayın.
Tek sayfa özet
- Polimorfizmde aynı metot çağrısı her nesnede o nesnenin kendi işini yapar.
- Duck typing nesnenin sınıfına değil metotlarına bakar. Bu yüzden ortak bir üst sınıf her zaman gerekmez.
- Nesnenin türüne bakan
if/elifzinciri her yeni türde uzar ve dal eklenmeyen türde hata vermedenNonedöndürebilir. Nesnenin metodunu çağırırsanız yeni bir tür eklemek için çağıran kodu değiştirmeniz gerekmez. isinstance(), dışarıdan gelen veriyi doğrulamak gibi kararın gerçekten türe bağlı olduğu yerlerde kullanılır.hasattr()yalnız bir adın bulunup bulunmadığını söyler. Metodun sözleşmeye uygun çalışacağını garanti etmez.- LBYL işten önce koşulu kontrol eder, EAFP işi dener ve hatayı yakalar. EAFP’de yalnız beklediğiniz hata türünü yakalayın ve metodun içinde oluşan aynı türden hatanın da yakalanacağını unutmayın.
- Kalıtım sınıflar arasındaki bir ilişkidir. Polimorfizm nesneleri kullanma biçimidir ve kalıtım olmadan da mümkündür.
Bu bölümün kazanımları
Bu bölümü bitiren öğrenci:
- Aynı metot çağrısının farklı nesnelerde farklı iş yaptığını örnekle gösterir.
- Ortak üst sınıf olmadan da polimorfizmin mümkün olduğunu açıklar.
- Her yeni türde uzayan tür koşulu zincirini kod kokusu olarak tanır ve yerine ortak bir metot çağrısı koyar.
isinstance()kullanımının hangi durumda yerinde olduğunu belirler.hasattr()sonucunun neyi söyleyip neyi söylemediğini açıklar.- EAFP ile LBYL yaklaşımlarını karşılaştırır ve yalnız beklenen istisnayı yakalamanın gerekçesini açıklar.
- Polimorfizm ile kalıtımı birbirinden ayırır.