9. Sınıflar

Sınıflar hakkında konuşurken, evrensel olarak kabul edilmiş bir terminolojinin olmayışından dolayı arasıra Smalltalk ve C++ terimlerini kullanacağım. (Aslında, nesne yönelimi açısından Python'a daha çok benzeyen Modula-3 dili terimlerini kullanırdım; fakat bu dilden haberdar olan okuyucuların azınlıkta olduğunu sanıyorum.)

Ayrıca nesne yönelim kavramını bilenleri bir terminoloji tuzağına karşı uyarmalıyım: "Nesne" sözcüğü, Python'da "bir sınıfın gerçeklenmesi" anlamına gelmez. Smalltalk'da olmayan ancak C++ ve Modula-3'dekine benzer şekilde Python'daki veri türlerinin hepsi birer sınıf değildir: tamsayılar ve listeler gibi yerleşik veri türleri ile dosyalar sınıf değildir. Yine de tüm Python veri türleri için ortak bir kavramı paylaşmaları adına nesnelerdir demek yanlış olmaz.

Nesneler tek tek ve çoklu isimlerle (çoklu etki alanları içinde), aynı nesneye bağlı olabilir. Bu diğer dillerde kod isimlendirme (aliasing) olarak bilinir. Bu genellikle Python'da ilk bakışta anlaşılmaz ve değişmez temel türler (sayılar, dizgeler, demetler) ile çalışırken yoksayılabilir. Yine de kod isimlendirme, listeler sözlükler gibi değiştirilebilen nesneler ve yazılım dışındaki öğeler (dosyalar, pencereler, vs) için kullanılan bazı türlerinde katılımıyla Python kodunun kavramsallaştırılmasında (kasıtlı!) bir etkiye sahiptir. Bazı yönleriyle kod isimlendirme göstergelere benzer bir davranış sergilediğinden genellikle, yazılım yararına kullanılmıştır. Örneğin, sadece göstergesi aktarıldığından bir nesnenin aktarılması kolaydır; eğer bir işlev, bir bağımsız değişken olarak aktarılan bir nesneyi değiştirirse, işlevi çağıran değişikliği görecektir - bu, Pascal'daki gibi iki farklı bağımsız değişken aktarma gereksinimini ortadan kaldırır.

Sizi sınıflar ile tanışmadan önce, biraz da Python'un etki alanı kurallarından bahsetmem gerek. Sınıf tanımlamalarını tam olarak anlamak için etki ve isim alanlarının nasıl çalıştığını bilmeniz gerek. Bu konudaki bilgiler ileri seviyedeki her Python yazılımcısı için yaralıdır.

Birkaç tanım ile işe koyulalım.

Bir isim alanı isimler ile nesnelerin eşleşmesidir. Çoğu isim alanı şu anda Python sözlükleri olarak kodlanmışlardır, fakat bu hiçbir şekilde fark edilmez ve gelecekte değiştirilebilir. İsim alanlarına örnekler: yerleşik isimler kümesi (abs() gibi işlevler ve yerleşik istisna isimleri vs.), bir modül içindeki global isimler ve bir işlev çağrısındaki yerel isimler. Bir nesnenin özellikler kümesi de bir isim alanıdır. İsim alanlarına ilişkin bilinecek önemli şey farklı isim alanlarındaki isimlerin birbirileri ile hiçbir ilişkisi olmadığıdır. Örneğin, iki farklı modül karışıklık yaratmadan “maksimize” adlı birer işlev tanımlayabilir; kullanıcılar bu işlevleri önlerine modül adını ekleyerek kullanır.

Bu arada, bir noktadan sonra yazılan her herhangi bir isim için öznitelik sözcüğünü kullanıyorum. Örneğin, z.real ifadesinde real, z nesnesinin bir özniteliğidir. Modül içindeki isimlere atıflar da öznitelik atıflarıdır: modulAdi.fonkAdi ifadesinde modulAdi bir modül nesnesidir ve fonkAdi bunun bir özniteliğidir. Bir modülün öznitelikleri ile içinde tanımlı global değişkenler aynı isim alanını paylaşır. ^[71]

öznitelikler salt okunur veya yazılabilir olabilir. Yazılabilir oldukları durumda özniteliklere atama yapmak mümkündür. Modül öznitelikleri yazılabilirdir: modulAdi.sonuc = 42 gibi bir ifade kullanabilirsiniz. Yazılabilir öznitelikleri del deyimini kullanarak silmek de mümkündür. Örneğin del modulAdi.sonuc ifadesi modulAdi nesnesinden sonuc isimli özniteliği siler.

Farklı anlarda yaratılan isim alanlarının farklı ömürleri olur. Yerleşik isimleri içeren isim alanı Python yorumlayıcısı çalıştırıldığında yaratılır ve asla silinmez. Bir modüle ait global isim alanı modül tanımı okunduğunda yaratılır ve genellikle yorumlayıcı çalıştığı sürece silinmez. Yorumlayıcının bir dosyadan veya etkileşimli olarak çalıştırdığı deyimler de __main__ isimli bir modüle ait kabul edilir ve bunların da kendi global isim alanı vardır. Yerleşik isimler de __builtin__ isimli bir modülde bulunur.

Bir işleve ait yerel isim alanı işlev çağırıldığında yaratılır ve işlevden dönüldüğünde veya işlev içinde ele alınmamış bir istisna gerçekleştiğinde silinir. Tabii ki özyinelemeli çağrıların herbiri kendi yerel isim alanına sahiptir.

Bir etki alanı bir isim alanının doğrudan erişilebildiği bir metin bölgesidir. Burada “doğrudan erişilebilir” ifadesinin anlamı, yetersiz bir isim atfının isim alanında isim bulmaya teşebbüs etmesidir.

Etki alanları statik olarak belirlenmelerine rağmen, dinamik olarak kullanılır. İcranın herhangi bir anında isim alanlarına doğrudan erişilebilen iç içe geçmiş en az üç etki alanı vardır: ilk aranan ve yerel isimleri içeren en iç etki alanı; en yakın olanından başlanarak aranan çevreleyen işlevlerin isim alanları; daha sonra aranan ve o andaki modülün global değişkenlerini içeren orta etki alanı; ve yerleşik isimlerin bulunduğu isim alanı olan en dış etki alanı (en son aranır).

Eğer bir isim global olarak tanımlanmış ise tüm atıflar ve atamalar doğrudan modülün global isimlerini barındıran orta etki alanına gider. Zaten, en iç etki alanının dışındaki tüm isimler salt okunurdur.

Genellikle yerel etki alanı o an içinde bulunulan (yazılım metninde) işlevin yerel isimlerine atıfta bulunur. İşlevlerin dışında yerel etki alanı global etki alanı ile aynı isim alanıdır: modülün isim alanı. Sınıf tanımlamaları ayrıca yerel etki alanı içerisine bir başka isim alanı daha ekler.

Etki alanlarının metne bağlı olarak belirlendiğini anlamak önemlidir. Bir modül içinde tanımlı bir işlevin global etki alanı o modülün isim alanıdır; nereden çağırıldığı ya da hangi farklı isim ile çağırıldığı bir fark yaratmaz. Diğer yandan, asıl isim araması icra anında dinamik olarak yapılır; ancak dilin tanımı “derleme” sırasında yapılan statik isim çözümlemeye doğru değişmektedir ve dinamik isim çözümlemeye güvenmemelisiniz! Örneğin, yerel değişkenler şu anda statik olarak belirlenmektedir.

Python'a özgü bir tuhaflık da atamaların her zaman en iç etki alanına gitmesidir. Atamalar veri kopyalamaz; sadece nesnelere isimler bağlar. Aynı şey silme işlemleri için de geçerlidir: del x ifadesi x'in yerel etki alanı tarafından atfedilen isim alanındaki bağını kaldırır. Aslında, yeni isimler yaratan tüm işlemler yerel etki alanını kullanır. İşlev tanımları ve import deyimleri modül veya işlev adını yerel etki alanına bağlar. Bir değişkenin global etki alanında bulunduğunu belirtmek için global deyimi kullanılabilir.

Sınıflar ile bir miktar yeni sözdizim ve kavram ile üç yeni nesne türü tanıtacağız.

class SinifAdi:
    <deyim-1>
    .
    .
    .
    <deyim-N>

class benimSinif:
    "Basit bir sınıf örneği."
    i = 12345
    def f(self):
        return 'Merhaba'

x = benimSinif()

def __init__(self):
    self.data = []

>>> class karmasikSayi:
...     def __init__(self, gercekKsm, sanalKsm):
...         self.g = gercekKsm
...         self.s = sanalKsm
...
>>> x = karmasikSayi(3.0, -4.5)
>>> x.g, x.s
(3.0, -4.5)

x.sayac = 1
while x.sayac < 10:
    x.sayac = x.sayac * 2
print x.sayac
del x.sayac

x.f()

xf = x.f
while 1:
    print xf()

Veri öznitelikleri aynı isimli yöntem özniteliklerini bastırır. Büyük yazılımlardaki zor fark edilen isim çakışması hatalarından kaçınmak için çakışmaları en aza indirecek bir isimlendirme yöntemi kullanmak akıllıca olur. Yöntem isimlerini büyük harf ile başlatılırken, veri isimleri özel bir karakter (alt çizgi gibi) ile başlatılabilir. Yöntemler için fiil ve veri yapıları için isim olan kelimeler kullanılabilir.

Veri özniteliklerine o nesnenin kullanıcıları (“istemcileri”) başvuru yapabileceği gibi, yöntemler de bunlara başvuruda bulunabilir. Başka bir deyişle, sınıflar tamamen soyut veri türleri oluşturmak için kullanılamaz. Aslında, Python'da hiçbir şey veri saklamayı zorlamayı mümkün kılmaz.

Kullanıcılar nesnelerin veri özniteliklerini dikkatli kullanmalılar; çünkü istemciler yöntemler tarafından kullanılan önemli değişkenlere atama yaparak istenmeyen hatalara sebep olabilir. İstemcilerin, isim çakışmalarından kaçındıkları sürece, bir nesneye yöntemlerinin geçerliliğini etkilemeden kendi veri özniteliklerini ekleyebileceklerine dikkat edin.

Yöntem içinden veri özniteliklerine (ya da diğer yöntemlere!) başvuruda bulunmanın kestirme bir yolu yoktur. Bunun aslında yöntemlerin okunabilirliğini artırdığını düşünüyorum; bir yönteme göz attığınızda yerel değişkenler ile nesne değişkenlerini birbirilerine karıştırma şansı yoktur.

Usul olarak yöntemlerin ilk özniteliğine self adı verilir. Bu tamamen usule dayanır; self isminin Python için kesinlikle hiç bir özel anlamı yoktur. Bu usule uymazsanız yazılımınız diğer Python yazılımcıları tarafından daha zor okunur ve sınıf tarayıcısı (class browser) yazılımları da bu usule dayanıyor olabilir.

Sınıf özniteliği olan her işlev, o sınıfın nesneleri için bir yöntem tanımlar. İşlev tanımının sınıf tanımı içerisinde olması şart değildir; işlevi, sınıf içindeki yerel bir değişkene atamak da mümkündür. Örneğin:

# Sınıf dışında tanımlanmış işlev
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1
    def g(self):
        return 'Merhaba'
    h = g

Şimdi f, g ve h'nın hepsi C sınıfının özellikleri oldular ve aynı anda C sınıfının nesnelerinin de yöntemleridirler (g ve h birbirinin tamamen aynısıdır). Bu tür uygulamanın genellikle sadece okuyucunun kafasını karıştırmaya yaradığına dikkat edin. Yöntemler self öğesinin yöntem özelliğini kullanarak diğer yöntemleri çağırabilir:

class Bag:
    def __init__(self):
        self.data = []
    def add(self, x):
        self.data.append(x)
    def addtwice(self, x):
        self.add(x)
        self.add(x)

Yöntemler sıradan işlevlerin yaptığı şekilde global değişkenlere başvuru yapabilir. Bir yönteme ilişkin global etki alanı sınıf tanımının bulunduğu modüldür. Sınıfın kendisi asla global etki alanı olarak kullanılmaz. Bir yöntem içinde global veri kullanmak için ender olarak iyi bir sebep olduğu halde, global etki alanı kullanımın pek çok mantıklı sebebi vardır. Örneğin, global etki alanına yüklenmiş işlev ve modülleri, yöntemler ve bunun içinde tanımlanmış diğer işlev ve sınıflar kullanılabilir. Genellikle yöntemi içeren sınıfın kendisi bu global etki alanı içinde tanımlanmıştır ve bir sonraki kısımda bir yöntemin kendi sınıfına başvurmak istemesi için birkaç iyi sebep bulacağız!

Tabii ki, kalıtım desteği olmayan bir “sınıf” adına layık olmaz. Türetilmiş sınıf tanımının sözdizimi aşağıdaki gibidir:

class turemisSinifAdi(TemelSinifAdi):
    <deyim-1>
    .
    .
    .
    <deyim-N>

, TemelSinifAdi ismi türetilmiş sınıfın tanımının bulunduğu etki alanında tanımlı olmalıdır. Temel sınıf adı yerine bir ifade kullanmak da mümkündür. Bu temel sınıf adı başka bir modül içinde tanımlı olduğunda yararlıdır:

class turemisSinifAdi(modulAdi.TemelSinifAdi):

Bir türetilmiş sınıf tanımının işletilmesi bir temel sınıf ile aynıdır. Bir sınıf nesnesi yaratıldığında temel sınıf hatırlanır. Bu özellik başvurularını çözümlemede kullanılır; başvuruda bulunulan öznitelik o sınıfta yok ise temel sınıfta aranır. Bu kural temel sınıfın kendisi de başka bir sınıftan türetildiyse ardışık olarak çağırılır.

Türetilmiş sınıftan nesne oluşturmanın özel bir tarafı yoktur: turetilmisSinifAdi() o sınıfın yeni bir nesnesini yaratır. Yöntem başvuruları şu şekilde çözümlenirler: ilgili sınıf özelliği, gerekirse temel sınıflar zinciri taranarak, aranır ve yöntem başvurusu geçerli ise bu bir işlev verir.

Türetilmiş sınıflar temel sınıflarının yöntemlerini bastırabilir. Yöntemler aynı nesnenin diğer yöntemlerini çağırırken özel önceliklere sahip olmadıkları için aynı temel sınıfta tanımlı bir yöntemi çağıran temel sınıf yöntemi bunu bastıran bir türetilmiş sınıf yöntemini çağırmış olabilir. C++ yazılımcıları için not: Tüm Python yöntemleri sanaldır (virtual).

Türetilmiş sınıftaki bir bastıran yöntem aslında temel sınıftaki yöntemin yerini almak yerine onu geliştirmek isteyebilir. Temel sınıf yöntemini doğrudan çağırmanın basit bir yolu vardır: temelSinifadi.yontemAdi(self, argumanlar). Bu bazen istemciler için de faydalıdır. Bunun sadece, temel sınıf, global etki alanı içine doğrudan yüklendiyse çalıştığına dikkat edin.

class turemisSinifAdi(temel1, temel2, temel3):
    <ifade-1>
    .
    .
    .
    <ifade-N>

Sınıfa özel belirteçler (identifier) için sınırlı destek vardır. __spam formundaki (en az iki alt çizgilik bir önek ve en fazla bir alt çizgilik sonek) bir belirteç _sinifadi__spam şeklini alır. Burada sinifadi o anki sınıf adının sonek alt çizgileri atılmış olan halidir. Bu değişiklik belirtecin sözdizimsel konumuna bakılmaksızın yapılır ki bu sınıf üyesine özel değişkenler yaratılabilsin. Değiştirilen belirteç 255 karakteri aşarsa kırpılabilir. Sınıflar dışında veya sınıf adı sadece alt çizgilerden oluşuyorsa kırpma olmaz.

İsim değiştirmenin amacı sınıflara, türemiş sınıflarca tanımlanan nesne değişkenlerini dert etmeden veya sınıf dışındaki nesne değişkenleri ile uğraşmadan, kolayca özel nesne değişkenleri ve yöntemleri tanımlama yolu sağlamaktır. Değiştirme kurallarının genelde kazaları önlemeye yönelik olduğuna dikkat edin; ancak yine de buna niyet eden kişi özel değişkenlere ulaşıp bunları değiştirebilir. Bu bazı özel durumlarda kullanışlı da olabilir.

exec(), eval() veya evalfile() işlevlerine aktarılacak kod, çağıran sınıf adının o anki sınıf adı olduğunu düşünmez; bu da “ikilik derlenmiş” kod ile sınırlı global deyiminin etkisine benzer. Aynı kısıtlama getattr(), setattr() ve delattr() işlevleri için ve doğrudan başvurulduğunda __dict__ için de mevcuttur.

Bazan isimli veri öğelerini bir arada paketlemek, Pascal kayıtları ya da C veri yapılarına benzer bir veri türü oluşturmak kullanışlı olabilir. Bir boş sınıf ile bu yapılabilir:

class Eleman:
    pass

ali = Eleman() # Boş bir eleman kaydı yarat

# Kaydın alanlarını doldur
ali.isim = 'Ali Veli'
ali.bolum = 'Muhasebe'
ali.maas = 1000000

Soyut bir veri türü bekleyen Python koduna o veri türünün yöntemlerini taklit eden bir sınıf geçirilebilir. Örneğin bir dosya nesnesinden bir miktar veriyi biçimleyen bir işleviniz varsa, read() ve readline() yöntemleri olan ve veriyi bir dizgeden alan bir sınıfı o işleve bağımsız değişken olarak aktarabilirsiniz.

Yöntem nesnelerinin de öznitelikleri vardır: m.im_self kendinin tanımlı olduğu nesneyi çağıran bir yöntem nesnesidir ve m.im_func ise kendini oluşturan işlevi çağıran bir yöntem nesnesidir.

Kullanıcı tanımlı istisnalar artık dizge olmakla sınırlı değiller; sınıf da olabilir. Bu mekanizmayı kullanarak genişletilebilir istisna hiyerarşileri yaratılabilir.

raise deyimi için iki yeni biçem mevcut:

raise Sinif, gercekleme

raise gercekleme

İlk biçemde gercekleme Sinifa ait bir gerçekleme olmalıdır. İkinci biçem ise şunun kısaltmasıdır:

raise gercekleme.__class__, gercekleme

Bir except bloğu hem sınıflar hem de dizgeleri içerebilir. Bir except bloğu içindeki sınıf eğer aynı sınıf veya bir temel sınıf ise istisna ile uyumludur. Türetilmiş sınıf içeren bir except bloğu temel sınıf ile uyumlu değildir. Örneğin aşağıdaki yazılım B, C, D çıktısını o sırayla verir:

class B:
    pass
class C(B):
    pass
class D(C):
    pass
for c in [B, C, D]:
    try:
        raise c()
    except D:
        print "D"
    except C:
        print "C"
    except B:
        print "B"

Eğer except blokları ters sırayla yazılmış olsalardı (except B başta olacak şekilde) çıktı B, B, B olacaktı; çünkü uyan ilk except B bloğu tetiklenecekti.

Ele alınmamış sınıf istisnası için bir ileti yazılacağı zaman, önce sınıf adı yazılır, ardından iki nokta üst üste ve bir boşluk ve son olarak da gerçeklemenin yerleşik str() işlevinden geri döndürülen dizgenin karşılığı yazılır.