Novou třídu v Pythonu definujeme prostřednictvím klíčového slova class. Za ním uvedeme jméno nové třídy a dvojtečkou otevřeme blok, v tomto bloku můžeme definovat metody naší nové třídy, pokud žádné metody definovat nechceme, použijeme klíčové slovo pass.

class PrazdnaTrida:
  pass

Metody definujeme stejně jako funkce klíčovým slovem def, jejich první parametr (obvykle nazývaný self) se při volání neuvádí a obsahuje instanci, pro kterou je metoda volána. Na rozdíl od jiných jazyků musíme při práci s instancí self vždy tento identifikátor uvést.

class MojeTrida:
  def moje_metoda(self):
    print self,": moje_metoda"

  def dalsi_metoda(self,a,b):
    print "Self=",self,"a=",a,"b=",b

Takto vytvořená třída se chová podobně jako funkce, můžeme ji zavolat, čímž získáme její instanci.

>>> a = MojeTrida()
>>> a
<__main__.MojeTrida instance at 0x403119cc>
>>> a.moje_metoda()
<__main__.MojeTrida instance at 0x403119cc> : moje_metoda

Metody, jejichž názvy začínají i končí dvěma podtržítky, mají speciální význam. Nejzajímavější je jistě metoda __init__, ta je volána (pokud existuje) při vytváření instancí dané třídy s parametry, které jsou při této operaci použity. Obdobným způsobem je před výmazem instance volána metoda __del__, ovšem její využívání přináší různé problémy, a proto se příliš nepoužívá.

Metoda __init__ je vhodné místo k vytvoření atributů instance (proměnných specifických pro danou instanci):

class Bod:
  def __init__(self,x=0,y=0):
    self.x = x
    self.y = y
  def posun(dx,dy):
    self.x = self.x + dx
    self.y = self.y + dy

Všimněte si že jsem parametrům x i y přiřadil výchozí hodnotu, obecně je možné v parametrech libovolné metody použít libovolnou možnost uvedenou v předminulém díle o funkcích, pouze je nutné počítat s tím, že v prvním argumentu bude vždy instance, se kterou budeme pracovat.

Instanci naší třídy Bod tedy můžeme vytvořit například těmito způsoby:

a = Bod()
b = Bod(1,1)
c = Bod(x=1,y=1)

Z příkladu doufám jasně vyplývá jakým způsobem s atributy instance manipulujeme, není to ovšem jediná možnost, instance jsou totiž interně implementovány jako slovníky, ke kterým můžeme přímo přistupovat pomocí atributu __dict__. Předchozí příklad tedy také můžeme zapsat jako:

class Bod:
  def __init__(self,x=0,y=0):
    self.__dict__["x"] = x
    self.__dict__["y"] = y
  def posun(dx,dy):
    self.__dict__["x"] = self.__dict__["x"] + dx
    self.__dict__["y"] = self.__dict__["y"] + dy

Ve skutečnosti je mezi oběma variantami jistý rozdíl, povíme si o něm v některém z dalších dílů spolu s takzvanými speciálními metodami.

Je také možné definovat atributy tříd, neboli proměnné spojené se třídou a nikoli jednotlivými instancemi. Provedeme to tak, že uvnitř bloku, ve kterém definujeme metody, nadefinujeme proměnnou:

class SerioveCislo:
  cislo = 0
  def __init__(self):
    SerioveCislo.cislo = SerioveCislo.cislo + 1
    self.cislo = SerioveCislo.cislo

V příkladu opět vidíme, jak k takové proměnné přistupujeme, druhý řádek metody __init__ ukazuje, že pokud vytvoříme atribut instance se stejným názvem jako atribut třídy, zastíní atribut instance atribut třídy. V našem případě budou mít tedy všechny instance výše uvedené třídy v atributu cislo svoje unikátní číslo.

>>> a=SerioveCislo()

>>> b=SerioveCislo()
>>> c=SerioveCislo()
>>> a.cislo
1
>>> c.cislo
3
>>> b.cislo
2

Při definování třídy můžeme do závorky za její jméno uvést seznam předků, v případě, že vznikne kolize jmen, má přednost dříve uvedená třída.

>>> class OdvozenaTrida(MojeTrida):
...     def nova_metoda(self,a,b):
...             MojeTrida.moje_metoda(self)
...             MojeTrida.dalsi_metoda(self,a,b)
... 
>>> b = OdvozenaTrida()
>>> b.nova_metoda(1,2)
<__main__.OdvozenaTrida instance at 0x40311bcc> : moje_metoda
Self= <__main__.OdvozenaTrida instance at 0x40311bcc> a= 1 b= 2

Z předchozího příkladu je také patrné, jak je možné volat metodu konkrétní třídy. Dodejme, že to je možné odkudkoli, nejen ze tříd od dané třídy odvozené. Taktéž jako parametr self můžeme předat celkem cokoli (většinou to ovšem povede k chybě s tím, že self postrádá nějaký atribut, se kterým daná metoda potřebuje pracovat).

Metody jsou ve skutečnosti také atributy, v případě tříd jsou to atributy s datovým typem funkce a v případě instancí se speciálním typem vázaná metoda (bound method). Vázaná metoda je funkce, jejíž první argument je vždy odpovídající instance. Z tohoto faktu vyplývá několik zajímavých důsledků:

• Do metody můžeme přiřazovat, což je mimochodem docela špatný nápad.
• Metodu můžeme uložit do proměnné, předat jako parametr...
• V podstatě nepotřebujeme žádné speciální prostředky pro realizaci toho, co je v jiných jazycích nazýváno reflexe - zkoumání a upravování tříd za běhu programu.

Pokud vás zaráží, že jsem vůbec nezmínil tzv. řízení přístupu, je to zcela správně, Python totiž podobný koncept vůbec nezavádí, s výjimkou možnosti zapsat před název metody nebo atributu dvě podtržítka, v tom případě Python daný název převede na _JménoTřídy__původní_jméno, například __nyaa ve třídě Neko převede na _Neko__nyaa.

Existuje funkce isinstance(něco, třída), vracející True v případě, že něco je instancí třídy třída (nebo některé třídy od ní odvozené), a issubclass(podtřída, třída) vrátí True tedy, je-li podtřída odvozena od třídy třída. Osobně pro tyto třídy nevidím velké využití, síla objektového modelu jazyka Python tkví právě v tom, že můžeme vzájemně zaměňovat instance na základě toho, jaké mají rozhraní a nikoli toho, od čeho je jejich třída odvozená, a proto mi přijde zbytečné tuto sílu omezovat nějakými explicitními kontrolami.

V příštím díle se podíváme na takzvané moduly, čímž ukončíme nudnou pouť po nutných základech jazyka Python a přesuneme se k jistě mnohem zajímavějšímu tématu - k různým funkcím, modulům a třídám, které nám Python nabízí.