Nesne tabanlı programlamaya giriş yaparken, bu programlama yaklaşımının oldukça geniş kapsamlı bir konu olduğunu söylemiştik. Bu bölümde de bu geniş kapsamlı konunun ileri düzey yönlerini ele almaya devam edeceğiz.
Ayrıca bu bölümü bitirdikten sonra, nesne tabanlı programlamanın yoğun bir şekilde kullanıldığı ‘grafik arayüz tasarlama’ konusundan da söz edebileceğiz. Böylece, bu zamana kadar gördüğümüz komut satırı uygulamalarından sonra, bu bölümle birlikte ilk kez düğmeli-menülü modern arayüzleri tanımaya da başlayacağız. Üstelik grafik arayüzlü programlar üzerinde çalışmak, nesne tabanlı programlamanın özellikle karmaşık yönlerini çok daha kolay ve net bir şekilde anlamamızı da sağlayacak.
Bu bölümde, yine nesne tabanlı programlamaya ait bir kavram olan ‘miras alma’dan söz edeceğiz. Bütün ayrıntılarıyla ele alacağımız miras alma, nesne tabanlı programlamanın en önemli konularından birisidir. Hatta nesne tabanlı programlamayı faydalı bir programlama yaklaşımı haline getiren özelliklerin başında miras alma gelir dersek çok da abartmış olmayız. Ayrıca miras alma konusu, komut satırında çalışan programların yanı sıra grafik arayüzlü programlar da yazabilmemizin önündeki son engel olacak. Bu bölümü tamamladıktan sonra, grafik arayüzlü programlar yazmamızı sağlayacak özel modüllerin belgelerinden yararlanabilmeye ve grafik arayüzlü programların kodlarını okuyup anlamaya başlayabileceğiz.
Daha önce de söylediğimiz gibi, Python programlama dilinin temel felsefesi, bir kez yazılan kodları en verimli şekilde tekrar tekrar kullanabilmeye dayanır. Genel olarak baktığımızda dilin hemen hemen bütün öğeleri bu amaca hizmet edecek şekilde tasarlanmıştır. İşte bu başlık altında ele alacağımız ‘miras alma’ kavramı da kodların tekrar tekrar kullanılabilmesi felsefesine katkı sunan bir özelliktir.
İsterseniz miras alma konusunu anlatmaya basit bir örnekle başlayalım.
Diyelim ki bir oyun yazıyorsunuz. Bu oyun içinde askerler, işçiler, yöneticiler, krallar, kraliçeler ve bunun gibi oyuncu türleri olacak. Bu oyuncuları ve kabiliyetlerini mesela şöyle tanımlayabilirsiniz:
def __init__(self, isim, rütbe):
self.rütbe = rütbe
self.güç = 100
self.güç = 70
self.güç = 20
Burada asker, işçi ve yöneticinin her biri için ayrı bir sınıf tanımladık. Her sınıfın bir ismi, rütbesi ve gücü var. Ayrıca her sınıf; hareket etme, puan kazanma ve puan kaybetme gibi kabiliyetlere sahip.
Bu kodların oyuncular.py adlı bir dosyada bulunduğunu varsayarsak, mesela bir asker oluşturmak için yukarıdaki kodları şöyle kullanabiliriz:
>>> import oyuncular
>>> asker1 = oyuncular.Asker('Mehmet', 'er')
Asker() sınıfının isim ve rütbe parametrelerini belirtmek suretiyle bir asker nesnesi oluşturduk. Tıpkı Python’da gördüğümüz başka nesneler gibi, bu nesne de çeşitli nitelik ve metotlardan oluşuyor:
'__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'güç',
'hareket_et', 'isim', 'puan_kaybet', 'puan_kazan', 'rütbe']
Bu nitelik ve metotları asker nesnesi üzerine nasıl uygulayacağımızı biliyorsunuz:
Aynı şekilde öteki İşçi() ve Yönetici() sınıflarını da örnekleyip kullanabiliriz. Bu konuda bir problem yok. Ancak yukarıdaki kodları incelediğinizde, aynı kodların sürekli tekrarlandığını göreceksiniz. Gördüğünüz gibi, aynı nitelik ve metotları her sınıf için yeniden tanımlıyoruz. Bu durumun Python’ın mantalitesine aykırı olduğunu tahmin etmek hiç zor değil. Peki acaba yukarıdaki kodları nasıl daha ‘Pythonvari’ hale getirebiliriz?
Bu noktada ilk olarak taban sınıflardan söz etmemiz gerekiyor.
Taban sınıflar (base classes) miras alma konusunun önemli kavramlarından biridir. Dilerseniz taban sınıfın ne olduğu anlayabilmek için, yukarıda verdiğimiz örneği temel alarak çok basit bir uygulama yapalım.
Öncelikle yukarıda verdiğimiz örneği tekrar önümüze alalım:
Bu örnekte, Asker(), İşçi() ve Yönetici() adlı sınıfların içeriğine baktığımızda pek çok metot ve niteliğin aslında birbiriyle aynı olduğunu görüyoruz. Gelin isterseniz bütün sınıflarda ortak olan bu nitelik ve metotları tek bir sınıf altında toplayalım.
Asker(), İşçi() ve Yönetici() sınıflarının, yazdığımız programdaki oyuncuları temsil ettiğini düşünürsek, ortak nitelik ve metotları barındıran sınıfımızı da Oyuncu() olarak adlandırmamız mantıksız olmayacaktır:
self.güç = 0
İşte burada Oyuncu() adlı sınıf, bir ‘taban sınıf’ olarak adlandırılır. Taban sınıf denen şey, birkaç farklı sınıfta ortak olan nitelik ve metotları barındıran bir sınıf türüdür. İngilizcede base class olarak adlandırılan taban sınıflar, ayrıca üst sınıf (super class) veya ebeveyn sınıf (parent class) olarak da adlandırılır. Biz bu makalede taban sınıf ismini tercih edeceğiz.
Yukarıdaki Oyuncu() adlı taban sınıf da, İşçi(), Asker(), Yönetici() gibi sınıfların hepsinde ortak olarak bulunacak nitelik ve metotları barındıracak. Öteki bütün sınıflar, ortak nitelik ve metotlarını her defasında tek tek yeniden tanımlamak yerine, Oyuncu() adlı bu taban sınıftan devralacak. Peki ama nasıl? İşte bunu anlamak için de ‘alt sınıf’ adlı bir kavrama değinmemiz gerekiyor.
Bir taban sınıftan türeyen bütün sınıflar, o taban sınıfın alt sınıflarıdır. (subclass). Alt sınıflar, kendilerinden türedikleri taban sınıfların metot ve niteliklerini miras yoluyla devralır.
Anlattığımız bu soyut şeyleri anlamanın en kolay yolu somut bir örnek üzerinden ilerlemektir. Mesela, biraz önce tanımladığımız Oyuncu() adlı taban sınıftan bir alt sınıf türetelim:
Burada Asker() sınıfını tanımlarken, bu sınıfın parantezleri içine Oyuncu() sınıfının adını yazdığımıza dikkat edin. İşte bu şekilde bir sınıfın parantezleri içinde başka bir sınıfın adını belirtirsek, o sınıf, parantez içinde belirttiğimiz sınıfın bir alt sınıfı olmuş olur. Yani mesela yukarıdaki gibi Asker() sınıfının parantezleri arasına Oyuncu() sınıfının adını yazdığımızda, Asker() adlı sınıf;
Oyuncu() adlı sınıfı miras almış,
Oyuncu() adlı sınıfın bütün metot ve niteliklerini devralmış,
Oyuncu() adlı sınıftan türemiş oluyor.
Bu sayede Oyuncu() sınıfında tanımlanan bütün nitelik ve metotlara Asker() sınıfından da erişebiliyoruz:
>>> asker1 = oyuncular.Asker('Ahmet', 'Er')
Örnek olması açısından, Oyuncu() sınıfından türeyen (miras alan) birkaç alt sınıf daha tanımlayalım:
Tanımladığımız bu İşçi() ve Yönetici() sınıfları da tıpkı Asker() sınıfı gibi Oyuncu() adlı sınıftan miras aldığı için, Oyuncu() sınıfının sahip olduğu tüm nitelik ve metotlara sahiptirler.
Buraya kadar anlattıklarımızı özetleyecek olursak, şu sınıf bir taban sınıftır:
Bu taban sınıf, kendisinden türeyecek alt sınıfların ortak nitelik ve metotlarını tanımlar.
Şu sınıflar ise, yukarıdaki taban sınıftan türeyen birer alt sınıftır:
Bu alt sınıflar, Oyuncu() adlı taban sınıfın bütün nitelik ve metotlarını miras yoluyla devralır. Yani Oyuncu() adlı taban/ebeveyn/üst sınıfın nitelik ve metotlarına, Asker(), İşçi() ve Yönetici() adlı alt sınıflardan erişebiliriz:
>>> asker1 = Asker('Ahmet', 'İstihkamcı')
>>> işçi1 = İşçi('Mehmet', 'Usta')
>>> yönetici1 = Yönetici('Selim', 'Müdür')
İşte bu mekanizmaya miras alma (inheritance) adı verilir. Miras alma mekanizması, bir kez yazılan kodların farklı yerlerde kullanılabilmesini sağlayan, bu bakımdan da programcıyı kod tekrarına düşmekten kurtaran oldukça faydalı bir araçtır. İlerleyen sayfalarda miras alma mekanizmasının başka faydalarını da göreceğiz.
Miras Alma Türleri¶
Tahmin edebileceğiniz gibi, miras alma yalnızca bir sınıfın parantezleri arasına başka bir sınıfı yazarak ilgili sınıfın bütün nitelik ve metotlarını kayıtsız şartsız devralmaktan ibaret değildir. Bir sınıf, muhtemelen, miras aldığı nitelik ve metotlar üzerinde birtakım değişiklikler de yapmak isteyecektir. Esasında miras alma mekanizmasının işleyişi bakımından kabaca üç ihtimalden söz edebiliriz:
Miras alınan sınıfın bütün nitelik ve metotları alt sınıfa olduğu gibi devredilir.
Miras alınan sınıfın bazı nitelik ve metotları alt sınıfta yeniden tanımlanır.
Miras alınan sınıfın bazı nitelik ve metotları alt sınıfta değişikliğe uğratılır.
Bu ihtimallerden ilkini zaten görmüştük. Bir sınıfın parantezleri arasına başka bir sınıfın adını yazdıktan sonra eğer alt sınıfta herhangi bir değişiklik yapmazsak, taban sınıftaki nitelik ve metotlar olduğu gibi alt sınıflara aktarılacaktır.
Burada Asker() sınıfı, miras aldığı Oyuncu() sınıfının sanki bir kopyası gibidir. Dolayısıyla Oyuncu() sınıfının bütün nitelik ve metotlarına Asker() sınıfı altından da aynen erişebiliriz.
Yani yukarıdaki kod, Oyuncu() adlı sınıfın bütün nitelik ve metotlarının Asker() sınıfı tarafından miras alınmasını sağlar. Bu şekilde, Oyuncu() sınıfı içinde hangi metot veya nitelik nasıl tanımlanmışsa, Asker() sınıfına da o şekilde devredilir.
Taban sınıfımızın şu şekilde tanımlandığını biliyoruz:
Dolayısıyla bu taban sınıfta hangi nitelik ve metotlar hangi değerlere sahipse aşağıdaki Asker(), İşçi() ve Yönetici() sınıfları da o değerlere sahip olacaktır:
Ancak, dediğimiz gibi, miras almada tek seçenek bütün metot ve nitelikleri olduğu gibi alt sınıflara aktarmak değildir. Zaten öyle olsaydı miras alma mekanizmasının pek bir anlamı olmazdı. Biz miras aldığımız sınıflar üzerinde, içinde bulunduğumuz durumun gerektirdiği birtakım değişiklikleri yapabilmeliyiz ki bu mekanizmanın ilgi çekici bir yanı olsun.
Ayrıca eğer bir taban sınıfı alt sınıflara olduğu gibi aktaracaksanız, taban sınıftan gelen metot ve nitelikler üzerinde herhangi bir değişiklik yapmayacaksanız ve alt sınıflara da herhangi bir nitelik ilave etmeyecekseniz, alt sınıflar tanımlamak yerine doğrudan taban sınıfın örneklerinden yararlanmak daha akıllıca ve pratik bir tercih olabilir:
>>> asker = Oyuncu('Ahmet', 'Er')
>>> işçi = Oyuncu('Mehmet', 'Usta')
>>> yönetici = Oyuncu('Selim', 'Müdür')
Burada asker, işçi ve yönetici için ayrı ayrı alt sınıflar tanımlamak yerine, her biri için doğrudan Oyuncu() sınıfını farklı isim ve rütbe değerleriyle örnekleyerek istediğimiz şeyi elde ettik.
İlerleyen derslerde miras alma alternatiflerinden daha ayrıntılı bir şekilde söz edeceğiz, ama dilerseniz şimdi konuyu daha fazla dağıtmadan miras alınan metot ve niteliklerin alt sınıflar içinde nasıl yeniden tanımlanacağını, nasıl değişikliğe uğratılacağını ve alt sınıflara nasıl yeni nitelik ve metotlar ekleneceğini incelemeye geçelim ve ilk örneklerimizi vermeye başlayalım.
Hatırlarsanız bir önceki başlıkta şöyle bir kod yazmıştık:
Burada Oyuncu() sınıfını bütünüyle alt sınıfa aktardık. Peki ya biz bir taban sınıfı olduğu gibi miras almak yerine, bazı nitelikleri üzerinde değişiklik yaparak miras almak istersek ne olacak? Mesela taban sınıf içinde self.güç değeri 0. Biz bu değerin Asker(), İşçi() ve Yönetici() örnekleri için birbirinden farklı olmasını isteyebiliriz. Veya taban sınıfı olduğu gibi miras almakla birlikte, alt sınıflardan herhangi birine ilave nitelik veya nitelikler eklemek de isteyebiliriz. Diyelim ki biz Asker() sınıfı için, öteki sınıflardan farklı olarak, bir de memleket niteliği tanımlamak istiyoruz. Peki bu durumda ne yapacağız?
İşte bunun için Asker() sınıfını şu şekilde yazabiliriz:
memleket = 'Arpaçbahşiş'
Burada Asker() sınıfına memleket adlı bir sınıf niteliği eklemiş olduk. Dolayısıyla Asker() sınıfı, Oyuncu() adlı taban sınıftan miras alınan bütün nitelik ve metotlarla birlikte bir de memleket niteliğine sahip olmuş oldu:
>>> asker = Asker('Ahmet', 'binbaşı')
Elbette, bu niteliği öbür alt sınıflarda tanımlamadığımız için bu nitelik yalnızca Asker() sınıfına özgüdür.
Aynı şekilde, bir taban sınıftan türeyen bir alt sınıfa yeni bir sınıf metodu, örnek metodu veya statik metot da ekleyebiliriz:
Kural şu: Eğer alt sınıfa eklenen herhangi bir nitelik veya metot taban sınıfta zaten varsa, alt sınıfa eklenen nitelik ve metotlar taban sınıftaki metot ve niteliklerin yerine geçecektir. Yani diyelim ki taban sınıfımız şu:
Bu sınıfın nitelik ve metotlarını miras yoluyla devralan Asker() sınıfımız ise şu:
Şimdi bu sınıf içinde hareket_et() adlı bir örnek metodu tanımlayalım:
print('yeni hareket_et() metodu')
Eğer taban sınıfta hareket_et() adlı bir metot olmasaydı, Asker() adlı alt sınıf, taban sınıftan miras alınan öteki metot ve niteliklerle birlikte bir de hareket_et() adlı yeni bir örnek metoduna sahip olmuş olacaktı. Ancak taban sınıfta zaten hareket_et() adlı bir örnek metodu olduğu için, alt sınıfta tanımladığımız aynı adlı örnek metodu, taban sınıftaki metodun yerine geçip üzerine yazıyor.
Buraya kadar her şey tamam. Artık bir taban sınıfa ait metodu alt sınıfa miras yoluyla aktarırken nasıl yeniden tanımlayacağımızı öğrendik. Ayrıca alt sınıflara nasıl yeni metot ve nitelik ekleyeceğimizi de biliyoruz. Ama mesela, self.isim ve self.rütbe değişkenlerini korurken, taban sınıf içinde 0 değeri ile gösterilen self.güç değişkenini Asker(), İşçi() ve Yönetici() sınıflarının her biri içinde nasıl farklı bir değerle göstereceğimizi bilmiyoruz. Yani self.güç değerini Asker() sınıfı içinde 100, İşçi() sınıfı içinde 70, Yönetici() sınıfı içinde ise 50 ile göstermek istesek nasıl bir yol takip etmemiz gerektiği konusunda bir fikrimiz yok. İsterseniz şu ana kadar bildiğimiz yöntemleri kullanarak bu amacımızı gerçekleştirmeyi bir deneyelim:
self.güç = 50
Burada taban sınıfın __init__() metodunu alt sınıflarda yeniden tanımladık. Bu kodları bu şekilde yazıp çalıştırdığımızda self.güç değerinin her bir alt sınıf için istediğimiz değere sahip olduğunu görürüz. Ancak burada şöyle bir sorun var. Bu kodları bu şekilde yazarak self.isim ve self.rütbe değişkenlerinin değerini maalesef kaybettik…
__init__() metodunun parametre listesine isim ve rütbe parametrelerini yazdığımız halde bunları kodlarımız içinde herhangi bir şekilde kullanmadığımız için, bu parametrelerin listede görünüyor olması bir şey ifade etmiyor. Yani alt sınıflarda tanımladığımız __init__() metodu bizden isim ve rütbe adlı iki parametre bekliyor olsa da, bu parametrelerin değerini kodlar içinde kullanmadığımız için bu parametrelere değer atamamız herhangi bir amaca hizmet etmiyor.
Gelin bu söylediklerimizi kanıtlayalım:
>>> asker = oyuncular.Asker('Ahmet', 'Er')
AttributeError: 'Asker' object has no attribute 'rütbe'
AttributeError: 'Asker' object has no attribute 'isim'
Bu sorunu çözmek için alt sınıflarımızı şu şekilde yazabiliriz:
Burada self.isim ve self.rütbe değişkenlerini her bir alt sınıf için tekrar tanımladık. Bu küçük örnekte pek sorun olmayabilir, ama taban sınıfın __init__() metodunun içinde çok daha karmaşık işlemlerin yapıldığı durumlarda yukarıdaki yaklaşım hiç de pratik olmayacaktır. Ayrıca eğer miras alma işlemini, içeriğini bilmediğiniz veya başka bir dosyada bulunan bir sınıftan yapıyorsanız yukarıdaki yöntem tamamen kullanışsız olacaktır. Ayrıca aynı şeyleri tekrar tekrar yazmak miras alma mekanizmasının ruhuna tamamen aykırıdır. Çünkü biz miras alma işlemini zaten aynı şeyleri tekrar tekrar yazmaktan kurtulmak için yapıyoruz.
Bu arada, yukarıda yapmak istediğimiz şeyi şununla karıştırmayın: Biz elbette taban sınıftaki bir niteliği, örnekleme sırasında değiştirme imkanına her koşulda sahibiz. Yani taban ve alt sınıfların şöyle tanımlanmış olduğunu varsayarsak:
Her bir alt sınıfın güç değişkenini şu şekilde değiştirebiliriz:
Gördüğünüz gibi şu anda askerin gücü 0. Bunu 100 yapalım:
>>> asker.güç = 100
Aynı şeyi öteki İşçi() ve Yönetici() sınıflarının örnekleri üzerinde de yapabiliriz. Ama bizim istediğimiz bu değil. Biz, Asker() sınıfını örneklediğimiz anda gücü 100, İşçi() sınıfını örneklediğimiz anda gücü 70, Yönetici() sınıfını örneklediğimiz anda ise gücü 50 olsun istiyoruz.
İşte tam bu noktada imdadımıza yepyeni bir fonksiyon yetişecek. Bu yeni fonksiyonun adı super().
Hatırlarsanız, taban sınıflardan ilk kez bahsederken, bunlara üst sınıf da dendiğini söylemiştik. Üst sınıf kavramının İngilizcesi super class’tır. İşte bu bölümde inceleyeceğimiz super() fonksiyonunun adı da buradaki ‘super’, yani ‘üst’ kelimesinden gelir. Miras alınan üst sınıfa atıfta bulunan super() fonksiyonu, miras aldığımız bir üst sınıfın nitelik ve metotları üzerinde değişiklik yaparken, mevcut özellikleri de muhafaza edebilmemizi sağlar.
Bir önceki başlıkta verdiğimiz örnek üzerinden super() fonksiyonunu açıklamaya çalışalım:
Bu kodlarda, Oyuncu() adlı taban sınıfı miras alan Asker() sınıfı, __init__() metodu içinde self.güç değerini yeniden tanımlıyor. Ancak bu şekilde taban sınıfın __init__() metodu silindiği için, self.isim ve self.rütbe değişkenlerini kaybediyoruz. İşte bu sorunu, üst sınıfa atıfta bulunan super() fonksiyonu ile çözebiliriz.
Burada __init__() metodu içinde şöyle bir satır kullandığımızı görüyorsunuz:
İşte bu satırda super() fonksiyonu, tam da adının anlamına uygun olarak, miras alınan üst sınıfın __init__() metodu içindeki kodların, miras alan alt sınıfın __init__() metodu içine aktarılmasını sağlıyor. Böylece hem taban sınıfın __init__() metodu içindeki self.isim ve self.rütbe niteliklerini korumuş, hem de self.güç adlı yeni bir nitelik ekleme imkanı elde etmiş oluyoruz:
Bu bilgiyi öteki alt sınıflara da uygulayalım:
Gördüğünüz gibi, super() fonksiyonu sayesinde taban sınıfın değiştirmek istediğimiz niteliklerine yeni değerler atarken, değiştirmek istemediğimiz nitelikleri ise aynı şekilde muhafaza ettik.
Bu arada eğer taban sınıfın __init__() metodundaki parametre listesini alt sınıfta da tek tek tekrar etmek sizi rahatsız ediyorsa yukarıdaki kodları şöyle de yazabilirsiniz:
def __init__(self, *arglar):
Yıldızlı parametreleri önceki derslerimizden hatırlıyor olmalısınız. Bildiğiniz gibi, tek yıldızlı parametreler bir fonksiyonun bütün konumlu (positional) argümanlarını, parametrelerin parantez içinde geçtiği sırayı dikkate alarak bir demet içinde toplar. İşte yukarıda da bu özellikten faydalanıyoruz. Eğer taban sınıfta isimli (keyword) argümanlar da olsaydı, o zaman da çift yıldızlı argümanları kullanabilirdik.
Tek ve çift yıldızlı argümanlar genellikle şu şekilde gösterilir:
Böylece konumlu argümanları bir demet içinde, isimli argümanları ise bir sözlük içinde toplamış oluyoruz. Bu da bizi üst (ya da taban) sınıfın parametre listesini alt sınıflarda tekrar etme derdinden kurtarıyor.
Bu arada, miras alınan taban sınıfa atıfta bulunan super() fonksiyonu, Python programlama diline sonradan eklenmiş bir özelliktir. Bu fonksiyon gelmeden önce taban sınıfa atıfta bulunabilmek için doğrudan o sınıfın adını kullanıyorduk:
Oyuncu.__init__(self, isim, rütbe)
Gördüğünüz gibi, eski yöntemde taban sınıfın adını iki kez kullanmamız gerekiyor. Ayrıca __init__() fonksiyonunun parametre listesinde ilk sıraya yine self kelimesini de eklemek zorunda kalıyoruz.
İsterseniz yukarıda gösterdiğimiz eski yöntemi kullanmaya devam edebilirsiniz elbette. Ancak super() fonksiyonunu kullanmak eski yönteme göre biraz daha pratiktir.
Yukarıdaki örneklerde super() fonksiyonunu __init__() metodu içinde kullandık. Ancak elbette super() fonksiyonunu yalnızca __init__() fonksiyonu içinde kullanmak zorunda değiliz. Bu fonksiyonu başka fonksiyonlar içinde de kullanabiliriz:
Bu örneğin, super() fonksiyonunun nasıl işlediğini daha iyi anlamanızı sağladığını zannediyorum. Gördüğünüz gibi, taban sınıfın hareket_et() adlı metodunu alt sınıfta tanımladığımız aynı adlı fonksiyon içinde super() fonksiyonu yardımıyla genişlettik, yani taban sınıfın hareket_et() adlı fonksiyonuna yeni bir işlev ekledik:
Burada super().hareket_et() satırıyla taban sınıfın hareket_et() adlı metodunu alt sınıfta tanımladığımız yeni hareket_et() metodu içinde çalıştırarak, bu metodun kabiliyetlerini yeni hareket_et() metoduna aktarıyoruz.
Biz buraya gelinceye kadar Python’da sınıfları iki farklı şekilde tanımlayabileceğimizi öğrendik:
Sınıf tanımlarken parantez kullansak da olur kullanmasak da. Eğer miras alacağınız bir sınıf yoksa parantezsiz yazımı tercih edebilir, parantezli yazım tarzını ise başka bir sınıftan miras aldığınız durumlar için saklayabilirsiniz:
Ancak sağda solda incelediğiniz Python kodlarında bazen şöyle bir sınıf tanımlama şekli de görürseniz şaşırmayın:
Python’ın 3.x öncesi sürümlerinde sınıflar yeni ve eski tip olmak üzere ikiye ayrılıyordu. Bu sürümlerde eski tip sınıflar şöyle tanımlanıyordu:
Yeni tip sınıflar ise şöyle:
Yani eski tip sınıflar öntanımlı olarak herhangi bir taban sınıftan miras almazken, yeni tip sınıfların object adlı bir sınıftan miras alması gerekiyordu. Dolayısıyla, tanımladığınız bir sınıfta object sınıfını miras almadığınızda, yeni tip sınıflarla birlikte gelen özelliklerden yararlanamıyordunuz. Mesela önceki derslerde öğrendiğimiz @property bezeyicisi yeni tip sınıflarla gelen bir özelliktir. Eğer Python 3 öncesi bir sürüm için kod yazıyorsanız ve eğer @property bezeyicisini kullanmak istiyorsanız tanımladığınız sınıflarda açık açık object sınıfını miras almalısınız.
Python 3’te ise bütün sınıflar yeni tip sınıftır. Dolayısıyla object sınıfını miras alsanız da almasanız da, tanımladığınız bütün sınıflar öntanımlı olarak object sınıfını miras alacaktır. Yani Python 3 açısından şu üç tanımlama arasında bir fark bulunmaz:
Bunların hepsi de Python 3 açısından birer yeni tip sınıftır. Daha doğrusu Python 3’te bütün sınıflar bir yeni tip sınıf olduğu için, yukarıdaki sınıf tanımlamaları hep aynı tipte sınıflara işaret eder. Python 2’de ise ilk iki tanımlama eski tip sınıfları gösterirken, yalnızca üçüncü tanımlama yeni tip sınıfları gösterir.
Geldik bir bölümün daha sonuna… Böylece miras almaya ilişkin temel konuları incelemiş olduk. Bu bölümde öğrendiklerimiz sayesinde, etrafta gördüğümüz, miras alma mekanizmasının kullanıldığı kodların çok büyük bir bölümünü anlayabilecek duruma geldik. Bu mekanizmaya ilişkin olarak öğrenmemiz gerekenlerin geri kalanını da bir sonraki bölümde, grafik arayüz tasarımı konusuyla birlikte ele alacağız.