9. Sınıflar
***********

Sınıflar, verileri ve işlevleri bir arada tutan bir araçtır. Yeni bir
sınıf oluşturulurken, objeye ait yeni örnekler (instances)
oluşturulur. Sınıf örnekleri, durumlarını korumak için onlara
iliştirilmiş niteliklere sahip olabilir. Sınıfların durumunu modifiye
etmek için ise metotlar kullanılabilir.

Diğer programlama dilleriyle karşılaştırıldığında, Python'un sınıf
mekanizması olabildiğince az yeni sözdizimi ve semantik içeren
sınıflar ekler.  C++ ve Modula-3'te bulunan sınıf mekanizmalarının bir
karışımıdır.  Python sınıfları Nesne Yönelimli Programlama'nın tüm
standart özelliklerini sağlar: sınıf devralma mekanizması birden çok
temel sınıfa izin verir, türetilmiş bir sınıf temel sınıfının veya
sınıflarının herhangi bir metodunu geçersiz kılabilir ve bir metot
aynı ada sahip bir temel sınıfın metodunu çağırabilir.  Nesneler
farklı miktar ve türlerde veri içerebilir.  Modüller için olduğu gibi,
sınıflar da Python'un dinamik doğasına uygundur: çalışma sırasında
oluşturulurlar ve oluşturulduktan sonra da değiştirilebilirler.

C++ terminolojisinde, normalde sınıf üyeleri (veri üyeleri dahil)
*public* (aşağıdakine bakın Özel Değişkenler) ve tüm üye fonksiyonları
*virtual*' dır.  Modula-3'te olduğu gibi, nesnenin üyelerine
metotlarından ulaşmak için bir kısayol yoktur: metodun işlevi, çağrı
tarafından örtülü olarak sağlanan objeyi temsil eden açık bir
argümanla bildirilir.  Smalltalk'ta olduğu gibi, sınıfların kendileri
de birer nesnedir.  Bu sayede metotlar yeniden isimlendirilebilir veya
içe aktarılabilir.  C++ ve Modula-3'ün aksine, yerleşik türler
kullanıcının üzerlerine yapacağı geliştirmeler için temel sınıflar
olarak kullanılabilir.  Ayrıca, C++'ta olduğu gibi, özel sözdizimine
sahip çoğu yerleşik işleç (aritmetik işleçler, alt simgeleme vb.)
sınıf örnekleri için yeniden tanımlanabilir, geliştirilebilir.

(Sınıflara dair evrensel terimlerin yanı sıra, nadiren Smalltalk ve
C++ terimlerini kullanacağım. Onun yerine Modula-3 terimlerini
kullanacağım çünkü Python'un nesne yönelimli semantiğine C++'tan daha
yakın, yine de ancak çok az okuyucunun bunları duymuş olacağını tahmin
ediyorum.)


9.1. İsim ve Nesneler Hakkında Birkaç Şey
=========================================

Nesnelerin bireyselliği vardır ve birden çok ad (birden çok kapsamda)
aynı nesneye bağlanabilir.  Bu, diğer dillerde örtüşme (aliasing)
olarak bilinir.  Bu genellikle Python'a ilk bakışta takdir edilmeyen
bir özellik olsa da değiştirilemeyen veri türleriyle (sayılar,
dizeler, diziler) uğraşırken rahatlıkla göz ardı edilebilir.  Ancak,
örtüşmeler, listeler, sözlükler ve diğer türlerin çoğu gibi
değişebilir nesneleri içeren Python kodunun semantiği üzerinde
şaşırtıcı bir etkiye sahiptir. Diğer adlar bazı açılardan işaretçiler
(pointers) gibi davrandığından, bu genellikle programın yararına
kullanılır.  Örneğin, bir nesneyi geçirmek kolaydır çünkü uygulama
tarafından geçirilen şey yalnızca bir işaretçidir; bir fonksiyon
argüman olarak geçirilen bir nesneyi değiştirirse, çağıran bu
değişikliği görür --- bu Pascal'daki iki farklı bağımsız değişken
geçirme mekanizmasına olan gereksinimi ortadan kaldırır.


9.2. Python Etki Alanları ve Ad Alanları
========================================

Sınıflara başlamadan önce, size Python'un etki alanı kuralları
hakkında bir şey söylemeliyim.  Sınıf tanımlarında ad alanlarının
kullanımının bazı püf noktaları vardır ve neler olduğunu tam olarak
anlamak için etki alanlarının ve isimlerin nasıl çalıştığını bilmeniz
gerekir. Bu arada, bu konuda bilgi edinmek herhangi bir ileri düzey
Python programcısı için yararlıdır.

Haydi birkaç tanımlama ile başlayalım.

*Ad alanları* (namespace), adlardan nesnelere eşlemedir.  Çoğu isim şu
anda Python sözlükleri olarak uygulanmaktadır, ancak bu fark edilir
çapta bir fark yaratmaz (performans hariç) ve gelecekte değişebilir.
Ad alanlarına örnek olarak şunlar verilebilir: yerleşik isimler
("abs()" ve yerleşik özel durum adları gibi fonksiyonları içerir);
modüldeki global adlar; ve bir fonksiyon çağırmadaki yerel adlar.  Bir
bakıma, bir nesnenin nitelik kümesi de bir ad alanı oluşturur.
İsimler hakkında bilinmesi gereken önemli şey, farklı ad alanlarındaki
adlar arasında kesinlikle bir ilişki olmamasıdır; örneğin, iki farklı
modülün her ikisi de karışıklık olmadan "maximize" fonksiyonunu
tanımlayabilir --- modül kullanıcılarının modül adını örneklemesi
gerekir.

Bu arada, *nitelik* sözcüğünü bir noktayı takip eden herhangi bir isim
için kullanıyorum. Mesela,  "z.real" ifadesinde "real", "z" nesnesine
ait bir niteliktir. Açıkçası, modüllerde isimlere yapılan referanslar
nitelik referanslarıdır: "modname.funcname" ifadesinde "modname" bir
modül nesnesi ve "funcname" onun bir niteliğidir. Bu durumda, modülün
nitelikleri ve modüldeki global değişkenler arasında bir eşleşme olur:
aynı ad alanını paylaşmaları! [1]

Attributes may be read-only or writable.  In the latter case,
assignment to attributes is possible.  Module attributes are writable:
you can write "modname.the_answer = 42".  Writable attributes may also
be deleted with the "del" statement.  For example, "del
modname.the_answer" will remove the attribute "the_answer" from the
object named by "modname".

Ad alanları farklı anlarda oluşturulur ve farklı yaşam sürelerine
sahiptir.  Yerleşik adları içeren ad alanı, Python yorumlayıcısı
başlatıldığında oluşturulur ve hiçbir zaman silinmez.  Modül tanımı
okunduğunda modül için genel ad alanı oluşturulur; normalde, modül ad
alanları da yorumlayıcı çıkıp bitene kadar sürer.  Bir komut
dosyasından veya etkileşimli olarak okunan yorumlayıcının en üst düzey
çağrısı tarafından yürütülen ifadeler "__main__" adlı bir modülün
parçası olarak kabul edilir, bu nedenle kendi genel ad alanlarına
sahiptirler.  (Yerleşik isimler aslında bir modülde de yaşar; buna
"builtins".)

Bir işlevin yerel ad alanı, bir fonksiyon çağrıldığında oluşturulur ve
fonksiyon başa çıkamadığı bir hata veya istisna ile karşılaştığında
silinir.  (Aslında, bir bakıma ad alanı unutulmaktadır diyebiliriz.)
Tabii ki, özyinelemeli çağrıların her birinin kendi yerel ad alanı
vardır.

*scope*, bir ad alanının doğrudan erişilebilir olduğu Python
programının metinsel bölgesidir.  Burada "Doğrudan erişilebilir",
niteliksiz bir başvurunun hedeflediği ismi ad alanında bulmaya
çalıştığı anlamına gelir.

Kapsamlar statik olarak belirlense de, dinamik olarak kullanılırlar.
Yürütme sırasında herhangi bir zamanda, ad alanlarına doğrudan
erişilebilen 3 veya 4 iç içe kapsam vardır:

* en içte bulunan kapsam, ilk aranan olmakla birlikte yerel isimleri
  içerir

* en yakın kapsayan kapsamdan başlayarak aranan kapsayan
  fonksiyonların kapsamları yerel olmayan, aynı zamanda genel olmayan
  adlar içerir

* sondan bir önceki kapsam, geçerli modülün genel adlarını içerir

* en dıştaki kapsam (en son aranan), yerleşik adlar içeren ad alanıdır

Bir ad global olarak bildirilirse, tüm başvurular ve atamalar doğrudan
modülün genel adlarını içeren orta kapsama gider.  En iç kapsamın
dışında bulunan değişkenleri yeniden bağlamak için "nonlocal" ifadesi
kullanılabilir; yerel olarak bildirilmezse de, bu değişkenler salt
okunurdur (böyle bir değişken düzenlenirse, aynı adlı dış değişkeni
değiştirmeden en iç kapsamda *yeni* bir yerel değişken oluşturur).

Genellikle, yerel kapsam (metinsel olarak) geçerli fonksiyonun yerel
adlarına başvurur.  Dış fonksiyonlarda, yerel kapsam genel kapsamla
aynı ad alanına başvurur: modülün ad alanı. Sınıf tanımları yerel
kapsamda başka bir ad alanı yerleştirir.

Kapsamların metinsel olarak belirlendiğini fark etmek önemlidir: bir
modülde tanımlanan bir işlevin genel kapsamı, işlevin nereden veya
hangi diğer adla adlandırıldığından bağımsız olarak modülün ad
alanıdır.  Öte yandan, gerçek ad araması dinamik olarak yapılır,
çalışma zamanında --- ancak, dil tanımı statik ad çözümlemelerine
doğru, "derleme" zamanında gelişir, bu nedenle dinamik ad
çözümlemesini güvenmeyin!  (Aslında, yerel değişkenler zaten statik
olarak belirlenir.)

Python'un özel bir cilvesi, eğer "global" veya "nonlocal" deyimi
geçerli değilse -- isimlere yapılan atamaların her zaman en içteki
kapsama girmesidir. Atamalar verileri kopyalamaz --- adları nesnelere
bağlarlar.  Aynı şey silme için de geçerlidir: "del x" deyimi, "x"
bağlamasını yerel kapsam tarafından başvurulan ad alanından kaldırır.
Aslında, yeni adlar tanıtan tüm işlemler yerel kapsamı kullanır:
özellikle, "import" ifadeleri ve işlev tanımları modül veya işlev
adını yerel kapsamda bağlar.

"global" deyimi, belirli değişkenlerin genel kapsamda yaşadığını ve
orada geri alınması gerektiğini belirtmek için kullanılabilir;
"nonlocal" deyimi, belirli değişkenlerin bir çevreleme kapsamında
yaşadığını ve orada geri alınması gerektiğini gösterir.


9.2.1. Kapsamlar ve Ad Alanları Örneği
--------------------------------------

Bu, farklı kapsamlara ve ad alanlarına başvurmayı ve "global" ve
"nonlocal" değişken bağlamasını nasıl etkileyeceğini gösteren bir
örnektir:

   def scope_test():
       def do_local():
           spam = "local spam"

       def do_nonlocal():
           nonlocal spam
           spam = "nonlocal spam"

       def do_global():
           global spam
           spam = "global spam"

       spam = "test spam"
       do_local()
       print("After local assignment:", spam)
       do_nonlocal()
       print("After nonlocal assignment:", spam)
       do_global()
       print("After global assignment:", spam)

   scope_test()
   print("In global scope:", spam)

Örnek kodun çıktısı şudur:

   After local assignment: test spam
   After nonlocal assignment: nonlocal spam
   After global assignment: nonlocal spam
   In global scope: global spam

Varsayılan atama olan *local* atamasının *scope_test*'in *spam*
bağlamasını nasıl değiştirmediğini unutmayın.  "nonlocal" ataması
*scope_test*'in *spam* bağlamasını değiştirdi, hatta "global" ataması
modül düzeyindeki bağlamasını değiştirdi.

Ayrıca "global" atamasından önce *spam* için herhangi bir bağlama
olmadığını görebilirsiniz.


9.3. Sınıflara İlk Bakış
========================

Sınıflar biraz yeni söz dizimi, üç yeni nesne türü ve bazı yeni
semantiklere sahiptir.


9.3.1. Sınıf Tanımlama Söz Dizimi
---------------------------------

Sınıf tanımlamasının en basit biçimi şöyledir:

   class ClassName:
       <statement-1>
       .
       .
       .
       <statement-N>

Sınıf tanımlamaları, fonksiyon tanımlamaları ("def" deyimleri) ile
aynı şekilde, herhangi bir etkiye sahip olmadan önce yürütülmelidir.
(Bir sınıf tanımını "if" ifadesinin bir dalına veya bir fonksiyonun
içine yerleştirebilirsiniz.)

Uygulamada, bir sınıf tanımı içindeki ifadeler genellikle fonksiyon
tanımlamaları olacaktır, ancak diğer ifadelere de izin verilir ve daha
sonra bahsedeceğimiz üzere bazen yararlılardır. Bir sınıfın içindeki
fonksiyon tanımları normalde, yöntemler için çağırma kuralları
tarafından dikte edilen tuhaf bir bağımsız değişken listesi biçimine
sahiptir --- bu daha sonra açıklanacak.

Sınıf tanımı girildiğinde, yeni bir ad alanı oluşturulur ve yerel
kapsam olarak kullanılır --- böylece yerel değişkenlere yapılan tüm
atamalar bu yeni ad alanına gider.  Özellikle, fonksiyon tanımlamaları
yeni fonksiyonların adını buraya bağlar.

When a class definition is left normally (via the end), a *class
object* is created.  This is basically a wrapper around the contents
of the namespace created by the class definition; we'll learn more
about class objects in the next section.  The original local scope
(the one in effect just before the class definition was entered) is
reinstated, and the class object is bound here to the class name given
in the class definition header ("ClassName" in the example).


9.3.2. Sınıf Nesneleri
----------------------

Sınıf nesneleri iki tür işlemi destekler: nitelik referansları ve
örnekleme.

*Nitelik referansları*, Python'daki tüm nitelik referansları için
kullanılan standart söz dizimi olan "obj.name" kullanır.  Geçerli
nitelik adları, sınıf nesnesi oluşturulduğunda sınıfın ad alanında
bulunan tüm adlardır.  Yani, sınıf tanımı şöyle görünüyorsa:

   class MyClass:
       """A simple example class"""
       i = 12345

       def f(self):
           return 'hello world'

then "MyClass.i" and "MyClass.f" are valid attribute references,
returning an integer and a function object, respectively. Class
attributes can also be assigned to, so you can change the value of
"MyClass.i" by assignment. "__doc__" is also a valid attribute,
returning the docstring belonging to the class: ""A simple example
class"".

Sınıf *örnekleme* fonksiyon notasyonunu kullanır.  Sınıf nesnesinin,
sınıfın yeni bir örneğini döndüren parametresiz bir fonksiyon olduğunu
varsayın. Örneğin (yukarıdaki sınıfı varsayarsak):

   x = MyClass()

sınıfın yeni bir *örnek* öğesini oluşturur ve bu nesneyi "x" yerel
değişkenine atar.

The instantiation operation ("calling" a class object) creates an
empty object. Many classes like to create objects with instances
customized to a specific initial state. Therefore a class may define a
special method named "__init__()", like this:

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

When a class defines an "__init__()" method, class instantiation
automatically invokes "__init__()" for the newly created class
instance.  So in this example, a new, initialized instance can be
obtained by:

   x = MyClass()

Of course, the "__init__()" method may have arguments for greater
flexibility.  In that case, arguments given to the class instantiation
operator are passed on to "__init__()".  For example,

   >>> class Complex:
   ...     def __init__(self, realpart, imagpart):
   ...         self.r = realpart
   ...         self.i = imagpart
   ...
   >>> x = Complex(3.0, -4.5)
   >>> x.r, x.i
   (3.0, -4.5)


9.3.3. Örnek Nesneleri
----------------------

Şimdi örnek nesnelerle ne yapabiliriz?  Örnek nesneleri tarafından
anlaşılan tek işlemler nitelik başvurularıdır.  İki tür geçerli
öznitelik adı vardır: veri nitelikleri ve metotları.

*Data attributes* correspond to "instance variables" in Smalltalk, and
to "data members" in C++.  Data attributes need not be declared; like
local variables, they spring into existence when they are first
assigned to.  For example, if "x" is the instance of "MyClass" created
above, the following piece of code will print the value "16", without
leaving a trace:

   x.counter = 1
   while x.counter < 10:
       x.counter = x.counter * 2
   print(x.counter)
   del x.counter

The other kind of instance attribute reference is a *method*. A method
is a function that "belongs to" an object.

Örnek nesnesinin geçerli metot adları nesnenin sınıfına bağlıdır.
Fonksiyon nesneleri olan bir sınıfın tüm nitelikleri, örneklerinin
karşılık gelen fonksiyonlarını tanımlar.  Bu nedenle, örneğimizde,
"x.f" geçerli bir metot referansıdır, ne de olsa "MyClass.f" bir
fonksiyondur ancak "MyClass.i" fonksiyon olmadığından "x.i" değildir.
Ancak "x.f", "MyClass.f" ile aynı şey değildir çünkü bir fonksiyon
nesnesi değil, *metot nesnesi* 'dir.


9.3.4. Metot Nesneleri
----------------------

Genellikle, bir metot bağlandıktan hemen sonra çağrılır:

   x.f()

If "x = MyClass()", as above, this will return the string "'hello
world'". However, it is not necessary to call a method right away:
"x.f" is a method object, and can be stored away and called at a later
time.  For example:

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

daima "hello world" yazdırmaya devam edecek.

What exactly happens when a method is called?  You may have noticed
that "x.f()" was called without an argument above, even though the
function definition for "f()" specified an argument.  What happened to
the argument? Surely Python raises an exception when a function that
requires an argument is called without any --- even if the argument
isn't actually used...

Aslında, cevabı tahmin etmiş olabilirsiniz: yöntemlerle ilgili özel
şey, örnek nesnesinin fonksiyonun ilk argüman olarak geçirilmesidir.
Örneğimizde, "x.f()" çağrısı tam olarak "MyClass.f(x)" ile eş
değerdir.  Genel olarak, *n* tane argümana sahip bir metodu çağırmak,
ilk argümandan önce metodun örnek nesnesi eklenerek oluşturulan bir
argüman listesiyle karşılık gelen fonksiyonu çağırmaya eş değerdir.

In general, methods work as follows.  When a non-data attribute of an
instance is referenced, the instance's class is searched. If the name
denotes a valid class attribute that is a function object, references
to both the instance object and the function object are packed into a
method object.  When the method object is called with an argument
list, a new argument list is constructed from the instance object and
the argument list, and the function object is called with this new
argument list.


9.3.5. Sınıf ve Örnek Değişkenleri
----------------------------------

Genel olarak, örnek değişkenleri o örneğe özgü veriler içindir ve
sınıf değişkenleri sınıfın tüm örnekleri tarafından paylaşılan
nitelikler ile metotlar içindir:

   class Dog:

       kind = 'canine'         # class variable shared by all instances

       def __init__(self, name):
           self.name = name    # instance variable unique to each instance

   >>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.kind                  # shared by all dogs
   'canine'
   >>> e.kind                  # shared by all dogs
   'canine'
   >>> d.name                  # unique to d
   'Fido'
   >>> e.name                  # unique to e
   'Buddy'

As discussed in İsim ve Nesneler Hakkında Birkaç Şey, shared data can
have possibly surprising effects involving *mutable* objects such as
lists and dictionaries. For example, the *tricks* list in the
following code should not be used as a class variable because just a
single list would be shared by all *Dog* instances:

   class Dog:

       tricks = []             # mistaken use of a class variable

       def __init__(self, name):
           self.name = name

       def add_trick(self, trick):
           self.tricks.append(trick)

   >>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.add_trick('roll over')
   >>> e.add_trick('play dead')
   >>> d.tricks                # unexpectedly shared by all dogs
   ['roll over', 'play dead']

Doğru olan ise veriyi paylaşmak yerine bir örnek değişkeni
kullanmaktır:

   class Dog:

       def __init__(self, name):
           self.name = name
           self.tricks = []    # creates a new empty list for each dog

       def add_trick(self, trick):
           self.tricks.append(trick)

   >>> d = Dog('Fido')
   >>> e = Dog('Buddy')
   >>> d.add_trick('roll over')
   >>> e.add_trick('play dead')
   >>> d.tricks
   ['roll over']
   >>> e.tricks
   ['play dead']


9.4. Rastgele Açıklamalar
=========================

Aynı nitelik adı hem bir örnekte hem de bir sınıfta oluşuyorsa,
nitelik araması örneğe öncelik verir:

   >>> class Warehouse:
   ...    purpose = 'storage'
   ...    region = 'west'
   ...
   >>> w1 = Warehouse()
   >>> print(w1.purpose, w1.region)
   storage west
   >>> w2 = Warehouse()
   >>> w2.region = 'east'
   >>> print(w2.purpose, w2.region)
   storage east

Veri niteliklerine metotların yanı sıra bir nesnenin sıradan
kullanıcıları ("istemciler") tarafından başvurulabilir.  Başka bir
deyişle, sınıflar saf soyut veri türlerini uygulamak için
kullanılamaz.  Aslında, Python'daki hiçbir şey, veri gizlemeyi
zorlamaz. Bu durum geleneksel kullanımından dolayı bu şekildedir.
(Öte yandan, C ile yazılan Python uygulamaları, uygulama ayrıntılarını
tamamen gizleyebilir ve gerekirse bir nesneye erişimi kontrol
edebilir; bu, C ile yazılmış Python uzantıları tarafından
kullanılabilir.)

İstemciler veri niteliklerini dikkatle kullanmalıdır --- istemciler
veri özniteliklerini damgalayarak yöntemler tarafından tutulan
değişmezleri bozabilir.  İstemcilerin, metotların geçerliliğini
etkilemeden bir örnek nesnesine kendi veri niteliklerini
ekleyebileceğini unutmayın. Tabii ki burada da ad çakışmalarından
kaçınılmalıdır, adlandırma kuralları ise kaçınmak için oldukça faydalı
olabilir.

Yöntemlerin içinden veri niteliklerine (veya diğer metotlara!)
başvurmak için kısa yol yoktur.  Bu aslında metotların
okunabilirliğini arttırıyor, çünkü bir metoda bakarken yerel
değişkenleri ve örnek değişkenlerini karıştırma ihtimali bırakmamış
oluyoruz.

Genellikle, bir metodun ilk bağımsız değişkenine "self" denir.  Bu bir
kullanım geleneğinden başka bir şey değildir, yani "self" adının
Python için kesinlikle özel bir anlamı yoktur.  Bununla birlikte,
kurala uymadığınızda kodunuzun diğer Python programcıları tarafından
daha az okunabilir olabileceğini ve yazılabilecek potansiyel bir
*sınıf tarayıcısı* programının bu kurala dayanıyor olabileceğini
unutmayın.

Sınıf niteliği olan herhangi bir fonksiyon nesnesi, bu sınıfın
örnekleri için bir metot tanımlar.  Fonksiyon tanımının metinsel
olarak sınıf tanımına dahil olması gerekli değildir: sınıftaki yerel
bir değişkene fonksiyon nesnesi atamak da uygundur.  Mesela:

   # Function defined outside the class
   def f1(self, x, y):
       return min(x, x+y)

   class C:
       f = f1

       def g(self):
           return 'hello world'

       h = g

Now "f", "g" and "h" are all attributes of class "C" that refer to
function objects, and consequently they are all methods of instances
of "C" --- "h" being exactly equivalent to "g".  Note that this
practice usually only serves to confuse the reader of a program.

Metotlar, "self" bağımsız değişkeninin metot niteliklerini kullanarak
diğer metotları ç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)

Metotlar, global adlara sıradan işlevler gibi başvuru yapabilir.  Bir
metotla ilişkili genel kapsam, tanımını içeren modüldür.  (Bir sınıf
hiçbir zaman genel kapsam olarak kullanılmaz.)  Global verileri bir
metotta kullanmak için nadiren iyi bir nedenle karşılaşılsa da, genel
kapsamın birçok meşru kullanımı vardır: bir kere, genel kapsamlıya içe
aktarılan fonksiyon ve modüller, metotlar ve içinde tanımlanan
fonksiyonlar ve sınıflar tarafından kullanılabilir.  Genellikle,
metodu içeren sınıfın kendisi bu genel kapsamda tanımlanır ve sonraki
bölümde bir yöntemin kendi sınıfına başvurmak istemesinin bazı iyi
nedenlerini bulacağız.

Her değer bir nesnedir ve bu nedenle bir *sınıf* (*type* olarak da
adlandırılır) bulundurur. "object.__class__" olarak depolanır.


9.5. Kalıtım
============

Tabii ki, bir dil özelliği kalıtımı desteklemeden "sınıf" adına layık
olmaz.  Türetilmiş sınıf tanımının söz dizimi şöyle görünür:

   class DerivedClassName(BaseClassName):
       <statement-1>
       .
       .
       .
       <statement-N>

The name "BaseClassName" must be defined in a namespace accessible
from the scope containing the derived class definition.  In place of a
base class name, other arbitrary expressions are also allowed.  This
can be useful, for example, when the base class is defined in another
module:

   class DerivedClassName(modname.BaseClassName):

Türetilmiş bir sınıf tanımının yürütülmesi, temel sınıfla aynı şekilde
devam eder. Sınıf nesnesi inşa edildiğinde, temel sınıf hatırlanır.
Bu, nitelik başvurularını çözmek için kullanılır: istenen nitelik
sınıfta bulunmazsa, arama temel sınıfa bakmaya devam eder.  Temel
sınıfın kendisi başka bir sınıftan türetilmişse, bu kural özyinelemeli
olarak uygulanır.

Türetilmiş sınıfların somutlaştırılmasında özel bir şey yoktur:
"DerivedClassName()" sınıfın yeni bir örneğini oluşturur.  Metot
başvuruları aşağıdaki gibi çözümlenir: ilgili sınıf niteliği aranır,
gerekirse temel sınıflar zincirinin aşağısına inilir ve bu bir
fonksiyon nesnesi veriyorsa metot başvurusu geçerlidir.

Türetilmiş sınıflar, temel sınıflarının metotlarını geçersiz
kılabilir.  Metotlar aynı nesnenin diğer yöntemlerini çağırırken özel
ayrıcalıkları olmadığından, aynı temel sınıfta tanımlanan başka bir
metodu çağıran bir temel sınıfın metodu, onu geçersiz kılan türetilmiş
bir sınıfın metodunu çağırabilir.  (C++ programcıları için:
Python'daki tüm yöntemler etkili bir şekilde "sanal".)

Türetilmiş bir sınıfta geçersiz kılma yöntemi aslında yalnızca aynı
adlı temel sınıf yöntemini değiştirmek yerine genişletmek isteyebilir.
Temel sınıf metodunu doğrudan çağırmanın basit bir yolu vardır: sadece
"BaseClassName.methodname(self, arguments)" çağırın.  Bu bazen
müşteriler için de yararlıdır.  (Bunun yalnızca temel sınıfa genel
kapsamda "BaseClassName" olarak erişilebiliyorsa çalıştığını
unutmayın.)

Python'un kalıtımla çalışan iki yerleşik fonksiyonu vardır:

* Bir örneğin türünü denetlemek için "isinstance()" kullanın:
  "isinstance(obj, int)" yalnızca "obj.__class__" "int" veya "int"
  sınıfından türetilmiş bir sınıfsa "True" olacaktır.

* Sınıf kalıtımını denetlemek için "issubclass()" kullanın:
  "issubclass(bool, int)" "True" 'dur, çünkü "bool" "int" 'in bir alt
  sınıfıdır.  Ancak, "issubclass(float, int)" "False" olduğundan
  "float", "int" alt sınıfı değildir.


9.5.1. Çoklu Kalıtım
--------------------

Python, çoklu kalıtım biçimini de destekler.  Birden çok temel sınıf
içeren bir sınıf tanımı şöyle görünür:

   class DerivedClassName(Base1, Base2, Base3):
       <statement-1>
       .
       .
       .
       <statement-N>

For most purposes, in the simplest cases, you can think of the search
for attributes inherited from a parent class as depth-first, left-to-
right, not searching twice in the same class where there is an overlap
in the hierarchy. Thus, if an attribute is not found in
"DerivedClassName", it is searched for in "Base1", then (recursively)
in the base classes of "Base1", and if it was not found there, it was
searched for in "Base2", and so on.

Aslında, durum bundan biraz daha karmaşıktır: yöntem çözümleme sırası,
"super()" için işbirliği çağrılarını desteklemek için dinamik olarak
değişir.  Bu yaklaşım, diğer bazı çoklu kalıtım dillerinde sonraki
çağrı yöntemi olarak bilinir ve tekli kalıtım dillerinde bulunan süper
çağrıdan daha güçlüdür.

Dynamic ordering is necessary because all cases of multiple
inheritance exhibit one or more diamond relationships (where at least
one of the parent classes can be accessed through multiple paths from
the bottommost class).  For example, all classes inherit from
"object", so any case of multiple inheritance provides more than one
path to reach "object".  To keep the base classes from being accessed
more than once, the dynamic algorithm linearizes the search order in a
way that preserves the left-to-right ordering specified in each class,
that calls each parent only once, and that is monotonic (meaning that
a class can be subclassed without affecting the precedence order of
its parents). Taken together, these properties make it possible to
design reliable and extensible classes with multiple inheritance.  For
more detail, see The Python 2.3 Method Resolution Order.

In some cases multiple inheritance is not allowed; see Multiple
inheritance for details.


9.6. Özel Değişkenler
=====================

Python'da bir nesnenin içinden erişilmesi dışında asla erişilemeyen
"özel" örnek değişkenleri yoktur.  Ancak, çoğu Python kodu tarafından
izlenen bir kural vardır: alt çizgi (örneğin "_spam") ile öneklenmiş
bir ad API'nin genel olmayan bir parçası olarak kabul edilmelidir (bir
fonksiyon, metot veya veri üyesi olsun).  Bir uygulama detayıdır ve
önceden haber verilmeksizin değiştirilebilir.

Sınıf-özel üyeler için geçerli bir kullanım örneği olduğundan (yani
alt sınıflar tarafından tanımlanan adlara sahip adların ad çakışmasını
önlemek için), *name mangling* adı verilen böyle bir mekanizma için
sınırlı destek vardır.  "__spam" formunun herhangi bir tanımlayıcısı
(en az iki satır altı, en fazla bir alt çizgi) metinsel olarak
"_classname__spam" ile değiştirilir;  Bu mangling, bir sınıfın tanımı
içinde gerçekleştiği sürece tanımlayıcının söz dizimsel konumuna
bakılmaksızın yapılır.

Ayrıca bakınız:

  The private name mangling specifications for details and special
  cases.

Ad mangling, alt sınıfların sınıf içi metot çağrılarını kesmeden
metotları geçersiz kılmasına izin vermek için yararlıdır.  Mesela:

   class Mapping:
       def __init__(self, iterable):
           self.items_list = []
           self.__update(iterable)

       def update(self, iterable):
           for item in iterable:
               self.items_list.append(item)

       __update = update   # private copy of original update() method

   class MappingSubclass(Mapping):

       def update(self, keys, values):
           # provides new signature for update()
           # but does not break __init__()
           for item in zip(keys, values):
               self.items_list.append(item)

Yukarıdaki örnek, "MappingSubclass" sırasıyla "Mapping" sınıfında
"_Mapping__update" ve "mappingSubclass" sınıfında
"_MappingSubclass__update" ile değiştirildiği için "__update"
tanımlayıcısı tanıtsa bile çalışır.

Mangling kurallarının çoğunlukla kazaları önlemek için tasarlandığını
unutmayın; özel olarak kabul edilen bir değişkene erişmek veya
değiştirmek hala mümkündür.  Bu, hata ayıklayıcı gibi özel durumlarda
bile yararlı olabilir.

"exec()" veya "eval()" koduna geçirilen kodun çağırma sınıfının sınıf
adını geçerli sınıf olarak görmediğine dikkat edin; bu, etkisi aynı
şekilde birlikte bayt derlenmiş kodla sınırlı olan "global" deyiminin
etkisine benzer.  Aynı kısıtlama "getattr()", "setattr()" ve
"delattr()" ve doğrudan "__dict__" atıfta bulunurken de geçerlidir.


9.7. Oranlar ve Bitişler
========================

Bazen, birkaç adlandırılmış veri öğesini bir araya getirerek Pascal
*record* 'u veya C *struct* 'ına benzer bir veri türüne sahip olmak
yararlıdır. Deyimsel yaklaşım, bu amaç için "dataclasses"
kullanmaktır:

   from dataclasses import dataclass

   @dataclass
   class Employee:
       name: str
       dept: str
       salary: int

   >>> john = Employee('john', 'computer lab', 1000)
   >>> john.dept
   'computer lab'
   >>> john.salary
   1000

A piece of Python code that expects a particular abstract data type
can often be passed a class that emulates the methods of that data
type instead.  For instance, if you have a function that formats some
data from a file object, you can define a class with methods "read()"
and "readline()" that get the data from a string buffer instead, and
pass it as an argument.

Instance method objects have attributes, too: "m.__self__" is the
instance object with the method "m()", and "m.__func__" is the
function object corresponding to the method.


9.8. Yineleyiciler
==================

Şimdiye kadar büyük olasılıkla çoğu kapsayıcı nesnenin bir "for"
deyimi kullanılarak döngüye alınabileceğini fark etmişsinizdir:

   for element in [1, 2, 3]:
       print(element)
   for element in (1, 2, 3):
       print(element)
   for key in {'one':1, 'two':2}:
       print(key)
   for char in "123":
       print(char)
   for line in open("myfile.txt"):
       print(line, end='')

Bu erişim tarzı açık, özlü ve kullanışlıdır.  Yineleyicilerin
kullanımı Python'u istila eder ve birleştirir.  Perde arkasında "for"
deyimi kapsayıcı nesne üzerinde "iter()" öğesini çağırır.  Fonksiyon,
kapsayıcıdaki öğelere teker teker erişen "__next__()" metodunu
tanımlayan bir yineleyici nesnesi döndürür.  Başka öğe olmadığında,
"__next__()", "for" döngüsünün sonlandırılacağını bildiren bir
"StopIteration" hatası oluşturur.  "next()" yerleşik fonksiyonunu
kullanarak "__next__()" yöntemini çağırabilirsiniz; Bu örnek, her
şeyin nasıl çalıştığını gösterir:

   >>> s = 'abc'
   >>> it = iter(s)
   >>> it
   <str_iterator object at 0x10c90e650>
   >>> next(it)
   'a'
   >>> next(it)
   'b'
   >>> next(it)
   'c'
   >>> next(it)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
       next(it)
   StopIteration

Having seen the mechanics behind the iterator protocol, it is easy to
add iterator behavior to your classes.  Define an "__iter__()" method
which returns an object with a "__next__()" method.  If the class
defines "__next__()", then "__iter__()" can just return "self":

   class Reverse:
       """Iterator for looping over a sequence backwards."""
       def __init__(self, data):
           self.data = data
           self.index = len(data)

       def __iter__(self):
           return self

       def __next__(self):
           if self.index == 0:
               raise StopIteration
           self.index = self.index - 1
           return self.data[self.index]

   >>> rev = Reverse('spam')
   >>> iter(rev)
   <__main__.Reverse object at 0x00A1DB50>
   >>> for char in rev:
   ...     print(char)
   ...
   m
   a
   p
   s


9.9. Üreteçler
==============

*Üreteçler* yineleyiciler oluşturmak için basit ve güçlü bir araçtır.
Normal fonksiyonlar gibi yazılırlar, ancak veri döndürmek
istediklerinde "yield" deyimini kullanırlar.  Üzerinde her "next()"
çağrıldığı zaman, üreteç kaldığı yerden devam eder (tüm veri
değerlerini ve hangi deyimin en son yürütüldüğını hatırlar).  Bu
örnek, üreteçlerin oluşturulmasının ne kadar da kolay olabileceğini
gösterir:

   def reverse(data):
       for index in range(len(data)-1, -1, -1):
           yield data[index]

   >>> for char in reverse('golf'):
   ...     print(char)
   ...
   f
   l
   o
   g

Anything that can be done with generators can also be done with class-
based iterators as described in the previous section.  What makes
generators so compact is that the "__iter__()" and "__next__()"
methods are created automatically.

Başka bir önemli özellik, yerel değişkenlerin ve yürütme durumunun
çağrılar arasında otomatik olarak kaydedilmesidir.  Bu, fonksiyonun
yazılmasını kolaylaştırdı ve "self.index" ve "self.data" gibi
değişkenleri kullanmaya kıyasla çok daha net hale getirdi.

Otomatik metot oluşturma ve kaydetme programı durumuna ek olarak,
üreteçler sonlandırıldığında otomatik olarak "StopIteration" 'ı
yükseltirler. Birlikte, bu özellikler normal bir işlev yazmaktan daha
fazla çaba harcamadan yinelemeler oluşturmayı kolaylaştırır.


9.10. Üreteç İfadeleri
======================

Bazı basit üreteçler, listelere benzer bir söz dizimi kullanılarak ve
köşeli ayraçlar yerine parantezlerle kısaca kodlanabilir. Bu ifadeler,
üreteçlerin kapsayıcı bir fonksiyon tarafından hemen kullanıldığı
durumlar için tasarlanmıştır.  Üreteç ifadeleri tam üreteç
tanımlarından daha kompakt ancak daha az çok yönlüdür ve aynı
özellikle liste anlamalarından daha bellek dostu olma eğilimindedir.

Örnekler:

   >>> sum(i*i for i in range(10))                 # sum of squares
   285

   >>> xvec = [10, 20, 30]
   >>> yvec = [7, 5, 3]
   >>> sum(x*y for x,y in zip(xvec, yvec))         # dot product
   260

   >>> unique_words = set(word for line in page  for word in line.split())

   >>> valedictorian = max((student.gpa, student.name) for student in graduates)

   >>> data = 'golf'
   >>> list(data[i] for i in range(len(data)-1, -1, -1))
   ['f', 'l', 'o', 'g']

   >>> x = [[1,2,3], [], [4, 5]]
   >>> g = (*i for i in x)
   >>> list(g)
   [1, 2, 3, 4, 5]

In most cases, generator expressions must be wrapped in parentheses.
As a special case, however, when provided as the sole argument to a
function (as in the examples involving "sum", "set", "max", and "list"
above), the generator expression does not need to be wrapped in an
additional set of parentheses.  That is to say, the following two
pieces of code are semantically equivalent:

   >>> f(x for x in y)
   >>> f((x for x in y))

as are the following:

   >>> f(*x for x in y)
   >>> f((*x for x in y))

-[ Dipnotlar ]-

[1] Except for one thing.  Module objects have a secret read-only
    attribute called "__dict__" which returns the dictionary used to
    implement the module's namespace; the name "__dict__" is an
    attribute but not a global name. Obviously, using this violates
    the abstraction of namespace implementation, and should be
    restricted to things like post-mortem debuggers.
