Barış Yüksel

Sınıf Özellikleri ve Yeni Stil Sınıflar

Başlık biraz tuhaf oldu, insan ilk bakışta SOAP’ın ÇORBA olarak çevirildiği programlama kitaplarından ( Teşekkürler M.Çileli ) alıntılar arıyor. Buna yakın çevirilere rastlarsanız pek de şaşırmayın. O kitaplara bakakaldığınız anları yaşayıp ardına verdiğiniz tepki içerisinde adımın geçmemesi için belirli terim ve konu başlıklarının yanında ingilizcelerini yazmayı ihmal etmedim Bazı konu başlıklarını ise direkt ingilizce verdim. Lafı daha fazla uzatmadan konuya geçiyorum.

Yeni stil sınıflara (new-style classes) geçmeden önce, eski yapıda da kullanabildiğimiz Özel Yöntem İsimlerinden (Special Method Names) bahsedeyim.

Temel Uyarlama (Basic Costumization)

__init__(self[, ...])
Bildiğiniz gibi sınıf örneklendirildiğinde (instance) çalışır. Örneği hazırlama (initialization) amaçlıdır.

__del__(self)
Sınıf örneği silinirken çalışır. Tahmin edebileceğiniz gibi silme için kullanılır.

__repr__(self)
Sınıf örneği repr() yerleşik fonksiyonuna parametre olarak verildiğinde çalışır.

__str__(self)
Sınıf örneği str() yerleşik fonksiyonuna parametre olarak verildiğinde ve “print” ifadesiyle gönderildiğinde çalışır.

__hash__(self)
Sınıf örneği hash() yerleşik fonksiyonuna parametre olarak verildiğinde çalışır.

__nonzero__(self)
Sınıf örneğinin True/False değer testi yapıldığında çalışır. 0 veya 1 sonucunu dönmelidir.

Şimdi diğer özel yöntemlere geçmeden önce yukarıda açıkladıklarım için basit bir örnek yapalım.

class Sinif:
def __init__(self,ornStr=""):
self.ornStr = ornStr
self.ornList = ["a","b","c"]
def __del__(self):
print "__del__ çalıştı"
def __repr__(self):
return repr(self.ornList)
def __str__(self):
return str(self.ornStr)
def __hash__(self):
return hash(self.ornStr)
def __nonzero__(self):
if len(self.ornStr) > 0:
return 1
else:
return 0
ornek = Sinif("deneme") #__init__ calisti
print repr(ornek) #__repr__ calisti, cikti "['a','b','c']"
x = str(ornek) #__str__ calisti, x degiskenine "deneme" degeri atandi
print ornek #__str__ calisti, cikti "deneme"
print hash(ornek) #__hash__ calisti
print bool(ornek) #__nonzero__ calisti, ornStr uzunlugu 0′dan buyuk oldugu icin True dondu
if ornek is True: print "sonuc:true" #__nonzero__ calisti
del ornek #__del__ calisti, ornek silindi, cikti "__del__ çalıştı"

__lt__(self,diger)
__le__(self,diger)
__eq__(self,diger)
__ne__(self,diger)
__gt__(self,diger)
__ge__(self,diger)
Aynı sınıfın iki farklı örneği arasında mantıksal karşılaştırmalar sırasında çalışırlar. Sırasıyla x<=y, x==y, x!=y (x<>y),x>y, x>=y
Sonuç olarak Boolean değer döndürmek daha verimli olacaktır.

__cmp__(self,diger)
Eğer yukarıdaki fonksiyonlar tanımlanmamışsa mantıksal karşılaştırmalar sırasında çalışır. selfdiger durumunda pozitif bir sayı dönmelidir.

Yukarıdaki fonksiyonlar için basit birer örnek hazırlayalım.

class Sinif:
def __init__(self,sayi=0):
self.sayi = sayi
def __lt__(self,diger):
if self.sayi < diger.sayi:
print "kucuktur!"
return True
else:
print "kucuk degil!"
return False
orneka = Sinif(1)
ornekb = Sinif(2)
orneka < ornekb #__lt__ calisti, cikti "kucuktur!"
if orneka < ornekb: print "sonuc:kucuktur!" #sart saglanir

class Sinif:
def __init__(self,sayi=0):
self.sayi = 0
def __cmp__(self,diger):
if self.sayi < diger.sayi:
return -1
elif self.sayi == diger.sayi:
return 0
else:
return 1
orneka = Sinif(1)
ornekb = Sinif(2)
orneka < ornekb #True orneka == ornekb #False orneka > ornekb #False
#Burada __cmp__’nin -1,0 ya da 1 donmesine gore sonucun True/False olacagini yanilgisina kapilmayin. Verdiginiz degerler dogrultusunda yaptiginiz karsilastirmalar sonucu True/False sonucu alacaksiniz.

Niteliklere Erişimi Uyarlamak (Costumizing Attribute Access)

__getattr__(self,isim)
İstenilen nitelik bulunamadığı zaman çalışır.

__setattr__(self,isim,deger)
Örneğin niteliğine değer ataması yapılırken çalışır.

__delattr__(self,isim)
Örneğin niteliğinin “del” ifadesi ile silinmesi sırasında çalışır.

class Sinif:
a = 1
b = 2
def __getattr__(self,isim):
print "getattr!"
self.__class__.__dict__[isim] = -1
return -1
def __setattr__(self,isim,deger):
print "setattr!"
self.__class__.__dict__[isim] = deger
def __delattr__(self,isim):
print "delattr!"
del self.__class__.__dict__[isim]
ornek = Sinif()
print ornek.a #herhangi bir metod calismadi, cikti 1
print ornek.b #herhangi bir metod calismadi, cikti 2
print ornek.c #__getattr__ calisti, sinif niteliklerinin barindirildigi sozlukte (__dict__) "c" anahtarina karsilik -1 degeri atandi, cikti "getattr! -1"
print ornek.c #herhangi bir metod calismadi. bir onceki adimda "c" niteligi zaten olusturuldu, cikti -1
ornek.a = 4 #__setattr__ calisti, nitelige istenen deger verildi, cikti "setattr!"
del ornek.a #__delattr__ calisti, nitelik silindi, cikti "delattr!"
"""
Burada sinifin nitelik sozlugu (__dict__) yerine "self.isim = deger" ifadesini kullanmamamizin sebebi, "self.isim = deger" ifadesinin rekursif fonksiyon gibi davranmasina sebep olmasi. Bu nedenle bu ifade yerine sozlugu tercih etmek gerekiyor.
"""

Çağrılabilir Nesne Olarak İşlemek (Emulating Callable Objects)

__call__(self[, ...])
Sınıf örneğini bir fonksiyon gibi çağrıldığında çalışır.

class Sinif:
def __call__(self,*arg):
print arg[:2]
ornek = Sinif()
ornek(1,2,3) #__call__ calisti, gonderilen ilk 2 arguman yazdirildi, cikti (1,2)

Kapsayıcı Tür Olarak İşlemek (Emulating Container Types)

__len__(self)
Sınıf örneği len() yerleşik fonksiyonuna parametre olarak verildiğinde çalışır.

__getitem__(self,anahtar)
Sınıf örneğinin bir “ögesi” (örn:x[0],x["anahtar"] vb) istendiği zaman çalışır.

__setitem__(self,anahtar,deger)
Sınıf örneğinin bir ögesine değer ataması yapılırken çalışır.

__delitem__(self,anahtar)
Sınıf örneğinin bir ögesi silinirken çalışır.

__iter__(self)
Sınıf örneği iter() yerleşik fonksiyonuna parametre olarak verildiğinde çalışır. Bir iterator nesnesi dönmelidir.

__contains__(self,item)
Bir ögenin sınıf örneği ögeleri arasında olup olmadığı (1 in x, 1 not in x) denetlenirken çalışır. Boolean değer dönmelidir.

class Sinif:
dct = {"a1":"d1","a2":"d2","a3":"d3"}
def __getitem__(self,anahtar):
if self.__class__.__dict__["dct"].has_key(anahtar):
return self.__class__.__dict__["dct"][anahtar]
def __setitem__(self,anahtar,deger):
self.__class__.__dict__["dct"][anahtar] = deger
def __delitem__(self,anahtar):
del self.__class__.__dict__["dct"][anahtar]
def __iter__(self):
return iter(self.__class__.__dict__["dct"])
def __contains__(self,anahtar):
if anahtar in self.__class__.__dict__["dct"]:
return True
else:
return False
ornek = Sinif()
print ornek["a1"] #__getitem__ calisti, cikti "d1"
print ornek["a4"] = "d4" #__setitem__ calisti, sozlukte "a4" anahtarina karsilik "d4" degeri verildi
del ornek["a4"] #__delitem__ calisti, sozlukten "a4" anahtari silindi
iter(ornek) #__iter__ calisti, dictionary-keyiterator nesnesi olusturuldu
"a3" in ornek #__contains__ calisti, sozluk "a3" anahtarina sahip oldugu icin True degeri donduruldu
"a4" in ornek #__contains__ calisti, sozluk "a4" anahtarina sahip olmadigi icin False degeri donduruldu
"""
Burada da __*attr__ orneginde oldugu gibi "self[anahtar] = deger" ifadesinin rekursif cagri yapmasindan dolayi onun yerine sinifin nitelik barindiran sozlugunu tercih ediyoruz.
"""

Sayısal Tür Olarak İşlemek (Emulating Numeric Types)

__add__(self,diger)
__sub__(self,diger)
__mul__(self,diger)
__floordiv__(self,diger)
__mod__(self,diger)
__divmod__(self,diger)
__pow__(self,diger[, mod])
__lshift__(self,diger)
__rshift__(self,diger)
__and__(self,diger)
__xor__(self,diger)
__or__(self,diger)
Aynı sınıfın iki farklı örneği arasında matematiksel işlemler yapılırken çalışırlar. Sırasıyla +,-,*,//,%,divmod(),pow(),<<,>>,&,^,|
Örneğin x ve y’nin sınıf örnekleri olduğu düşünürsek, x+y işlemi yapıldığında x.__add__(y) çalışır.

__div__(self,diger)
__truediv__(self,diger)
Aynı sınıfın iki farklı örneği arasında bölme işlemi yapılırken çalışırlar. Eğer __future__ kütüphanesinin division modülü uygulamaya dahil edilmişse __truediv__(), edilmemişse __div__() fonksiyonu çalışır.

class Sinif:
def __init__(self,sayi):
self.sayi = sayi
def __add__(self,diger):
self.sayi = self.sayi + diger.sayi
orneka = Sinif(10)
ornekb = Sinif(20)
orneka + ornekb #__add__ calisti, orneka.sayi degeri artık 30
print orneka.sayi #cikti 30
#Sanirim digerleri icin ornek yapmaya gerek yok

Bu arada, ben floordiv’den (//) bi’ haberdim. Siz de benim gibi floordiv’in ne olduğunu bilmiyorsanız şöyle ifade edeyim. f(x,y): return (x – (x%y)) / y
Bölen olarak verilen sayının bölünende kaç adet bulunduğunu veriyor diyelim. Bölme işleminin tam sayı olarak sonuç vermesiyle karıştırmayın

__radd__(self,diger)
__rsub__(self,diger)
__rmul__(self,diger)
__rdiv__(self,diger)
__rmod__(self,diger)
__rdivmod__(self,diger)
__rpow__(self,diger)
__rlshift__(self,diger)
__rrshift__(self,diger)
__rand__(self,diger)
__rxor__(self,diger)
__ror__(self,diger)
İki örnek arasında matematiksel işlem yaparken ifadenin sağında kalan örneğin tanımlanmış fonksiyonu çalışır.
Örneğin x ve y’nin sınıf örnekleri olduğunu düşürsek, x+y işlemi sırasında y.__radd__(x) çalışır.

__iadd__(self,diger)
__isub__(self,diger)
__imul__(self,diger)
__idiv__(self,diger)
__imod__(self,diger)
__ipow__(self,diger[, mod])
__ilshift__(self,diger)
__irshift__(self,diger)
__iand__(self,diger)
__ixor__(self,diger)
__ior__(self,diger)
İki örnek arasında “kendi üzerine” matematiksel işlem yapılırken çalışır. Sırasıyla +=, -=, *=, /=, %=, **=, <<=, >>=, &=, ^=, |=
Örneğin x ve y’nin sınıf örnekleri olduğunu düşünürsek, x += y işlemi sırasında x.__iadd__(y) çalışır.

__neg__(self)
__pos__(self)
__abs__(self)
__invert__(self)
Sınıf örneğinin matematiksel olarak işaretini değiştirme, mutlak değerini alma ( abs() fonksiyonuna parametre olarak gönderme ) ve bitsel değilini alma işlemleri sırasında çalışırlar. Örneğin, x’in sınıf örneği olduğunu düşünürsek; -x ifadesi x.__neg__(), +x ifadesi x.__pos__(), abs(x) fonksiyonu x.__abs__() ve ~x ifadesi x.__invert__() çağrılarını yapar.

__complex__(self)
__int__(self)
__long__(self)
__float__(self)
Sınıf örneği sırasıyla complex(), int(), long(), float() fonksiyonlarına parametre olarak gönderildiğinde çalışırlar. Bu fonksiyonlar sonuç olarak uygun türü dönmelidir.

__oct__()
__hex__()
Sınıf örneği sırasıyla oct(), hex() fonksiyonlarına parametre olarak gönderildiğinde çalışırlar. Bu fonksiyonlar string bir değer dönmelidir.

__coerce__()
Python Reference Manuel kitabında “karışık-mod” üzerinde aritmetik işlemler yaparken çalıştığı aktarılmış. Bir kaç kurala sahip. Basit bir şekilde kural şu: “verileri işlem operatörünün işleyebileceği şekle dönüştür ve işlemin kurallarına uyacak şekilde bir tüpün 2 ögesi olarak döndür”. Sonuç olarak uygun verileri bir tüpün 2 ögesi olarak ya da işlem başarısızlığı durumunda None dönmesi gerekiyor. Bunu bir örnekle anlatmak uygun olacak.

class Sinif:
ornStr = "%s deneme %s"
def __coerce__(self,diger):
return (self.ornStr,diger)
ornek = Sinif()
print ornek % ("dnm","dnm")
"""
__coerce__ calisti, bir sinif ornegi ve bir tup ile moduler aritmek yapmaya calistik ancak __coerce__ fonksiyonumuzu moduler aritmetik islemiyle "string formatter" olacak sekilde tasarladigimiz icin gorevini o sekilde yerine getirdi.
cikti "dnm deneme dnm"
"""
print ornek * 3 # Bu sefer "%s deneme %s%s deneme %s%s deneme %s" ciktisini aldik

Yeni Stil Sınıflar (New-Style Classes)

Python 2.2 ile gelen yeni stil sınıfların, “class Sinif:” diyerek itelediğimiz eski yapıya göre en önemli farkı yerleşik türlerden (built-in types: int,float,str,tuple,dict vs.) türetilebilir olmasıdır. Bunlardan türetilmediği durumda object türünden türetilmesi gerekir.

class Sinif(object): pass
class MyList(list): pass

dict türünden türetilmiş bir sınıf örneği

class mydict(dict):
def __init__(self):
dict.__init__(self)
def __getitem__(self,anahtar):
try:
return dict.__getitem__(self,anahtar)
except:
return -1
def __setitem__(self,anahtar,deger):
dict.__setitem__(self,anahtar,deger+1) # deger+1
"""
>>> x = mydict()
>>> x
{}
>>> x["a"] = 0
>>> x["a"]
1
>>> x
{‘a’: 1}
>>> x["b"]
-1
"""

slots

Sınıf içerisinde __slots__’u tanımladığınız zaman sınıf örneği __dict__’e sahip olmayacaktır. Bu nedenle sizin __slots__’u tanımlayarak belirlediğiniz nitelikler dışında herhangi bir nitelik oluşturulamaz. __slots__’u tanımlarken bir list ile değer ataması yapılmalıdır.

class Sinif:
__slots__ = ["a","b"]
a = 1
b = 2
ornek = Sinif()
print ornek.a #cikti 1
print ornek.b #cikti 2
ornek.a = 0 #a niteligi 0 degerine sahip oldu
ornek.c = 3 #hata!

Descriptor

Bir sınıfın niteliğine erişim sırasında __get__(), __set__(), __delete__() metodları ile erişimin yönetilmesini sağlar. Bu yönteme “binding behavior” adı verilir. Descriptor yapısı; property,method,static method,class method ve super’in arkasındaki yapıdır.

class Desc(object):
def __init__(self,deger):
self.deger = deger
def __get__(self,nesne,sinif):
print "GET: ", nesne,sinif
return self.deger
def __set__(self,nesne,deger):
print "SET: ", nesne
self.deger = deger
def __delete__(self,nesne):
print "DEL: ", nesne
del self.deger
class Sinif(object):
x = Desc(10)
"""
>>> ornek = Sinif()
>>> ornek.x
GET: <__main__.Sinif object at 0xb7801fac>
10
>>> ornek.x = 11
SET: <__main__.Sinif object at 0xb7801fac>
>>> ornek.x
GET: <__main__.Sinif object at 0xb7801fac>
11
>>> del ornek.x
DEL: <__main__.Sinif object at 0xb7801fac>
"""

Burada buna benzer bir yapıyı __*attr__ fonksiyonlarını kullanarak oluşturabileceğinizi düşünebilirsiniz ancak bildiğiniz gibi __*attr__ fonksiyonları sınıfın bütün niteliklerini kapsarken Descriptor’lar sadece tanımladığınız nitelikleri kapsayacaktır.

Property

Descriptor oluşturmanın diğer bir yolu denilebilir. Prototip’i şu şekilde:
property(fget=None, fset=None, fdel=None, doc=None)

class Sinif(object):
def __init__(self):
self.__d = 10
def __getx(self):
print "__getx"
return self.__d
def __setx(self,deger):
print "__setx"
self.__d = deger
def __delx(self):
print "__delx"
del self.__d
OkuYazSil = property(fget=__getx,fset=__setx,fdel=__delx,doc="Oku-Yaz-Sil")
OkuYaz = property(fget=__getx,fset=__setx,doc="Oku-Yaz")
SadeceOku = property(fget=__getx,doc="Oku")
ornek = Sinif()
ornek.OkuYazSil #cikti "__getx 10"
ornek.OkuYazSil = 11 #cikti "__setx"
ornek.OkuYazSil #cikti "__getx 11"
ornek.OkuYaz #cikti "__getx 11"
ornek.OkuYaz = 12 #cikti "__setx"
"""
>>> del ornek.OkuYaz
Traceback (most recent call last):
File "", line 1, in
AttributeError: can’t delete attribute
>>>
"""

Property Descriptor’u “Descriptor HowTo Guide” kitabında şu şekilde verilmiş. Descriptor yapısının daha iyi kavranması için incelemekte fayda var.

class Property(object):
def __init__(self,fget=None,fset=None,fdel=None,doc=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
self.__doc__ = doc
def __get__(self,obj,objtype):
if obj is None:
return self
if self.fget is None:
raise AttributeError, "unreadable attribute"
return self.fget(obj)
def __set__(self,obj,value):
if self.fset is None:
raise AttributeError, "can’t set attribute"
return self.fset(obj)
def __delete__(self,obj):
if self.fdel is None:
raise AttributeError, "can’t delete attribute"
return self.fdel(obj)

Static Method

Statik metodların özelliği, çağrılırken sınıf örneğini parametre olarak (self) almaya ihtiyaç duymaz. Bu nedenle sınıf örneklendirilmeden metod çağrılabilir. staticmethod() da property() gibi bir descriptor’dur.

class Sinif:
def metod():
print "statik metod"
stmetod = staticmethod(metod)
Sinif.stmetod() #cikti "static method"

staticmethod descriptor’u şu şekilde:

class StaticMethod(object):
def __init__(self,f):
self.f = f
def __get__(self,obj,objtype=None):
return self.f

Class Method

Sınıf metodlarının statik metodlardan farkı, ilk parametre olarak sınıf referansını istemesidir. classmethod(), property() ve staticmethod() gibi bir başka descriptor’dur.

class Sinif(object):
def metod(cls):
print "sinif metodu", cls
clmetod = classmethod(metod)
Sinif.clmetod() #cikti "sinif metodu "
ornek = Sinif()
ornek.clmetod() #cikti "sinif metodu "

classmethod descriptor’u ise şu şekilde:

class ClassMethod(object):
def __init__(self,f):
self.f = f
def __get__(self,obj,objtype=None):
print "obj-objtype", obj,objtype
if objtype is None:
objtype = type(obj)
def newfunc(*args):
return self.f(objtype,*args)
return newfunc

Method Resolution Order, Super

Bir sınıfı tanımlarken bir veya birden çok sınıfı miras (inheritance) alarak tanımladığınızda sınıfa ait bir metodu çağırdığınız zaman aynı isime sahip metod taban sınıflarda (bases,superclass) yer alıyorsa çağrılmayacaktır. Örneğin:

class ASinif(object):
def metod(self):
print "A"
class BSinif(ASinif):
def metod(self):
print "B"
ornek = BSinif()
ornek.metod()# cikti "B"

Bu sorunu aşmak istediğiniz zaman kullandığınız genel yöntem şudur:

class ASinif(object):
def metod(self):
print "A"
class BSinif(ASinif):
def metod(self):
ASinif.metod(self)
print "B"
ornek = BSinif()
ornek.metod()# cikti "A B"

Bu yöntem kimi zaman yeterli bir çözüm olabilir ancak işler biraz karışıp birden fazla sınıfı miras alarak çalıştığınızda şöyle bir sorunla karşılaşmanız olasıdır.

class A(object):
def yaz(self):
print "A"
class B(A):
def yaz(self):
A.yaz(self)
print "B"
class C(A):
def yaz(self):
A.yaz(self)
print "C"
class D(B,C):
def yaz(self):
B.yaz(self)
C.yaz(self)
print "D"
ornek = D()
ornek.yaz() #cikti "A B A C D"

Bu örnekte olduğu gibi eğer super sınıflara (base) ait metodların sadece bir defa ve bir düzen içerisinde çağrılmasını istiyorsanız super()’de çareyi bulacaksınız. super()’i anlatmadan önce __mro__’dan bahsedelim.

__mro__, yeni stil sınıflarda sınıfın super sınıflarını bir tüp (tuple) içerisinde niteliktir. super(), super sınıflara ait metodları çağırırken __mro__ niteliğinden sıradaki sınıfı bulmak için yararlanır.

Örneğin yukarıda tanımladığımız D sınıfının __mro__’ı şu şekildedir:

"""
>>> D.__mro__
(<class ‘__main__.D’>, <class ‘__main__.B’>, <class ‘__main__.C’>, <class ‘__main__.A’>, <type ‘object’>)
"""

super() kullanılarak yapılan çağrılar, bu listeyi takip ederek yapılır. Şimdi üstteki örneği super() kullanarak tekrar yazalım.

super() kullanılırken, parametreler şu şekilde olmalı:
super(type,obj) obj parametresi yani örnek, type ise örneği alınan sınıftır.

class A(object):
def yaz(self):
print "A"
class B(A):
def yaz(self):
super(B,self).yaz()
print "B"
class C(A):
def yaz(self):
super(C,self).yaz()
print "C"
class D(B,C):
def yaz(self):
super(D,self).yaz()
print "D"
ornek = D()
ornek.yaz() #cikti "A C B D"
#super cagrisina oncelik tanindigi icin boyle bir sonuc aliyoruz.

new

Bir süper sınıfın alt sınıfı (yeni stil sınıflarda her sınıf object sınıfının bir alt sınıfıdır) örneklendirildiğinde sanıldığının aksine __init__ fonksiyonundan önce __new__ fonksiyonu çağrılır. __new__ fonksiyonu bir staticmethod olup, ilk parametresi sınıftır. __new__ fonksiyonu sınıf örneğini döndükten sonra __init__ fonksiyonu çalışır.

class inch(float):
def __new__(cls,arg=0.0):
return float.__new__(cls, arg*0.0254)
inch(12) #cikti 3.048

Descintro’da yer alan Singleton örneğini incelemek __new__ fonksiyonunu kavramak açısından yararlı olacak.

class Singleton(object):
def __new__(cls,*args,**kargs):
it = cls.__dict__.get("__it__")
if it is not None:
return it
cls.__it__ = it = object.__new__(cls)
it.init(*args,**kargs)
return it
def init(self,*args,**kargs):
pass
class MySingleton(Singleton):
def init(self):
print "init"
def __init__(self):
print "__init__"
orneka = MySingleton() #cikti "init __init__"
ornekb = MySingleton() #cikti "__init__"

Bu örneği açıklamak gerekirse: orneka oluşturulduğunda MySingleton sınıfının süper sınıfı Singleton’un __new__ metodu çağrılıyor. __new__ metoduna giden ilk parametre “MySingleton” sınıfı oluyor. MySingleton sınıfının nitelik sözlüğü __dict__’e bakılarak __it__ sınıf örneği ile tanımlanmışsa it değişkenine atanıp döndürülüyor, bu durumda MySingleton sınıfının sadece __init__ metodunun çağrılmasına sebep oluyor. Ancak burada MySingleton sınıfı henüz yeni örneklendirilmiş olduğu için __it__ tanımlanmamış, bu durumda “cls.__it__ = it = object.__new__(cls)” satırı çalışmaya başlıyor ve MySingleton sınıfı kendisinin __it__ niteliği ve Singleton sınıfının it değişkeni ile örneklendiriliyor. “it.init(*args, **kargs)” satırında gördüğünüz gibi MySingleton sınıfı örneğinin init metodu çağrılıyor. Ardına örnek döndürülüyor, __new__ metodunun görevi bitmiş olduğundan dolayı örneğin __init__ metodu çağrılmış oluyor. Bu nedenle “init __init__” çıktısını almış oluyoruz.

ornekb oluşturulduğunda tekrar Singleton sınıfının __new__ metodu çağrılıyor. Bu sefer MySingleton sınıfında __it__ niteliği sınıf örneği ile tanımlı olduğundan dolayı __new__ metodu bu tanımlı örneği dönüyor, bu sebepten dolayı sadece __init__ metodu çağrılmış oluyor ve “__init__” çıktısını alıyoruz.

Bu koca dökümanı geride bırakırken…
Bahsetmek isteyip de yazamadığım __metaclass__ konusu bir sonraki yazıda gelecek. Sonuçta burda yazdıklarımı ben de yazarken öğrendim ve __metaclass__ konusu son derece önemli bir konu. Şu sıralar küçük bir sağlık problemi yaşadığımdan dolayı fazla açıklamalarda bulunamadım, çoğunu özet geçmek zorunda kaldım. Bu nedenle aşağıda vereceğim kaynakları okumanızda yarar var.

descintro
Descriptor HowTo Guide
Python Language Referance
Introduction to New-Style Classes In Python – Micheal Fötsch
Python Attributes and Methods – Shalabh Chaturvedi
Python Types and Objects – Shalabh Chaturvedi

Ayrıca;
Bu blog’da yer alan Genel Kamu Lisansına (GPL, hepsi v3) sahip uygulamalar haricinde herhangi bir içerik herhangi bir lisans kapsamında değildir. İstenildiği gibi alınıp, kenarından köşesinden çırpılıp kullanılabilir. Kaynak gösterilmeden kullanılması bir nebze de olsa umrumda değildir. Burada tüm yazdıklarımı öğrenirken öğretmek amaçlı yazdığım için hatalar olabilir, kaynak göstermeden kullandığınız durumda ihale size kalır.

Tags: classic classes, classmethod, descriptors, new-style classes, özel yöntem isimleri, property, special method names, staticmethod, super, yeni stil sınıflar, __mro__
Posted in Python · Haziran 27th, 2010 · Comments (0)

twitter.com/brsyuksel