12. Třídy a instance

1. Objektově orientované programování
2. Vytvoření třídy
3. Atributy
4. Inicializační metoda a 'self'
5. Instance jako parametry
6. Obdélníky
7. Instance jako výstupní hodnoty
8. Instance jsou měnitelné
9. Stejnost
10. Kopírování
11. Glosář
12. Cvičení

12.1 Objektově orientované programování

Python je objektově orientovaný jazyk, který podporuje objektově orientované programování (OOP).

Objektově orientované programování má své kořeny již v šedesátých letech, ale až v osmdesátých letech se stalo hlavním programovacím postupem při tvorbě nového software. Bylo vyvinuto jako nástroj pro zvládnutí zvyšující se velikosti a složitosti softwarových systémů a pro usnadnění jejich pozdějších úprav.

Až dosud jsme psali programy s použitím procedurálních programovacích postupů. Těžištěm procedurálního programování je psaní funkcí neboli procedur, které operují s daty. Při objektově orientovaném programování je pozornost zaměřena na vytváření objektů, které obsahují jak data, tak funkční vlastnosti.

12.2 Vytvoření třídy

Třída ve své podstatě definuje nový, složený datový typ. Různé vestavěné typy - třídy Pythonu (str, int, float, ...) používáme již od počátečních kapitol.

Nejjednodušší definice třídy vypadá takto:

class Emanuel:
    pass

Záhlaví složené z klíčového slova class, názvu třídy a dvojtečky je vše, co jednoduchá třída potřebuje.
Později se dovíme, že třída může dědit ze své nadtřídy, v tom případě by před dvojtečkou byl název supertřídy v závorkách.
Následuje odsazené tělo třídy, které bude obsahovat řadu dalších objektů. V naší demonstraci jsme použili pouze jedno klíčové slovo pass, které nedělá nic.

• vytvořit datový atribut třídy Emanuel

  >>> Emanuel.strom = "ořech"
  >>>        
  

• vytvořit samostatný objekt - instanci třídy Emanuel

  >>> eman = Emanuel()
  >>>        
  

• vytvořit datový atribut instance

  >>> eman.les = 158
  >>>        
  

Nebudeme ale předbihat. Konstrukci třídy si krok po kroku vysvětlíme na konkretním případě třídy Point.

Uvažme koncept matematického bodu. Ve dvourozměrném prostoru (rovině) reprezentují bod dvě čísla (souřadnice) s kterými lze zacházet jako s jediným objektem. V matematickém zápisu bodu se tyto dvě souřadnice, oddělené čárkou, uvádějí v závorce. Například, (0, 0) představuje počátek souřadnic, (x, y) představuje bod ve vzdálenosti x ve vodorovném a y ve svislém směru od počátku.

V Pythonu rovněž vyjadříme bod pomocí dvou číselných hodot. Otázkou je, jak tyto dvě hodnoty seskupit do složeného objektu. Rychlé a mírně ušmudlané řešení je použití seznamu nebo entice a pro některé aplikace to může být řešení nejlepší.

Alternativou je definovat třídu (class), jejíž jednoduché složení jsme si právě ukázali.

class Point: 
    pass

Definice třídy se mohou vyskytnout kdekoli v programu, ale obvykle se umisťují poblíž počátku (po příkazech import).

Vytvořením třídy Point vytvoříme prototyp možných konkretních objektů, neboli instancí  třídy. Vytvoření nové instance připomíná volání funkce:

>>> type(Point) 
<class 'type'>       # type je třída, třída je type

>>> p = Point()      # vytvoření instance !  
>>> type(p)
<class '__main__.Point'>    # nemáme to jednoduché

Bezejmenná instance třídy Point je přiřazena proměnné p.




12.3 Atributy

Slovem atribut označujeme obecně vlastnosti nějakého subjektu, v tomto případě jím označujeme objekty třídy a instance. Atributy třídy i instance jsou dvojího druhu - datové a funkční.

Datovými atributy jsou proměnné třídy i instance, funkčními atributy jsou metody, což jsou funkce, definované uvnitř třídy a volané pro objekt (instanci) tečkovou notací. Atributem je také případný dokumentační řetězec.

Pro instanci i třídu lze určit atributy i dodatečně (jak jsme již viděli v předběžné ukázce):

>>> p.x = 3   # datový atribut 'x' instance 'p'  
>>> p.y = 4   # datový atribut 'y' instance 'p' 

>>> Point.a = "alef"   # datový atribut 'a' třídy Point

Tato skladba je podobná skladbě pro výběr atributu z modulu, např. math.pi nebo string.ascii_uppercase. Jak moduly, tak i třídy a instance vytvářejí své vlastní jmenné prostory. Přístup k jejich jménům (atributům) je v obou případech stejný - přes tečkovou notaci. V naší ukázce vytváříme atributy tím, že jim přiřazujeme hodnoty.

Ověřme si to:

>>> p.x, p.y
(3,4)
>>> Point.a
'alef'

Tečkovou notaci můžeme použít jako součást jakéhokoliv výrazu, takže následující příkazy jsou legální:

>>> print('%d  %d' % (p.x, p.y))
3 4
>>> print(p.x*p.x + p.y*p.y)
25




12.4 Inicializační metoda a 'self'

Protože naše třída Point má představovat matematické body v dvojrozměrném prostoru, všechny její instance by měly mít atributy x a y. Tak tomu však u našich objektů třídy Point zatím není:

>>> p2 = Point()   # vytvořili jsme instanci  

>>> p2.x = 8       # vytvořili jsme atribut přiřazením hodnoty
>>> p2.y           # bez přiřazení atribut 'y' neexistuje!
Traceback (most recent call last):
    File "<stdin>", line 1, in?
AttributeError: Point instance has no attribute 'y' 
>>>    

Abychom při každé deklaraci (instantiation) objektu nemuseli vytvářet proměnné, použijeme tak zvanou inicializační metodu __init__, kterou přidáme na začátek třídy a pomocí níž potřebné atributy objektu zavedeme. Této metodě se také říká konstruktor.

 class Point:
     def __init__(self, x=0, y=0): 
         self.x = x
         self.y = y    

Prvním parametrem definice __init__ je povinné slovo self, které ostatně musí obsahovat každá definice uvnitř třídy. Další parametry s počáteční hodnotou zajišťují, že každá nově vytvořená instance bude implicitně obsahovat datové atributy x, y, zde s počáteční nulovou hodnotou.

Užitečnost konstruktoru si ukážeme ve spojení s další metodou, která určí vzdálenost bodu od počátku souřadnic:

 class Point:
     def __init__(self, x=0, y=0):  # konstruktor 
         self.x = x
         self.y = y
     def distance_from_origin(self):   # metoda třídy
         return(self.x**2 + self.y**2)**0.5		 

Atributy x a y se vytvoří automaticky při deklaraci objektu:

>>> p = Point()
>>> p.x, p.y
(0, 0)

Dokonce je možné jim při deklaraci objektu přiřadit hodnoty:

>>> g = Point(3,4)
>>> g.x, g.y
(3, 4)
>>> g.distance_from_origin()
5.0




12.5 Instance jako parametry

Instanci můžeme zadat jako parametr obvyklým způsobem:

def print_point(obj):
    print('%s, %s' % (obj.x, obj.y))

>>> print_point(g)
3, 4
>>> print_point(p)
0, 0




12.6 Obdélníky

Řekněme, že chceme, aby třída představovala obdélník. Otázkou je, jakou informaci musíme poskytnout, abychom určili obdélník? Pro zjednodušení předpokládejme, že je obdélník orientován buďto vodorovně nebo svisle, nikdy není pootočen.

Máme několik možností: můžeme určit střed obdélníka (dvě souřadnice) a jeho velikost (šířku a výšku), nebo můžeme určit jeden z jeho rohů a velikost, nebo můžeme určit polohu dvou protilehlých bodů. Zvolíme si levý horní roh obdélníka a jeho velikost.

class Rectangle:
    def __init__(self, posice, w, h): 
        self.corner = posice
	self.width = w
	self.height = h

Parametr 'posice' předpokládá zadání dvojice čísel - entici. Pro její vložení můžeme použít nepojmenovaný objekt třídy Point:

>>> box = Rectangle(Point(), 100, 200)

Objektu Point() jsme nezadali žádné argumenty, protože nám zřejmě vyhovují jeho implicitní hodnoty. Kdybychom chtěli mít počátek obdélníka jinde než v bodě (0,0), mohli bychom například zadat:

>>> box = Rectangle(Point(10,50), 100, 200)
>>> box.corner.x, box.corner.y
(10,50)
>>> box.width, box.height
(100,200)

Vzájemné vztahy objektů vidíme na následujícím obrázku: atribut 'corner' objektu 'box' odkazuje na objekt třídy Point s atributy 'x' a 'y'.






12.7 Instance jako výstupní hodnota

Instance může být výstupní hodnotou funkce. Například, funkce find_center přijímá instanci třídy Rectangle jako argument a vrací instanci třídy Point, která obsahuje souřadnice středu zadaného obdélníka:

def find_center(obj):
    p = Point() 
    p.x = obj.corner.x + obj.width/2.0
    p.y = obj.corner.y + obj.height/2.0
    return p

Když si definice tříd Point, Rectangle a funkcí find_center, print_point vložíme do jednoho skriptu, můžeme v konzole Pythonu psát:

>>> box = Rectangle(Point(40,60), 100, 200)
>>> center = find_center(box)
>>> print_point(center)
90.0, 160.0

Je také možné deklarovat instanci s použitím entice,

>>> boot = Rectangle((40,60), 100, 200)

instance obsahuje atribut 'corner' ale hodnoty tohoto atributu nemají jména:

>>> boot.corner
(40,60)
>>> boot.corner.x
AttributeError: 'tuple' object has no attribute 'x'

Pro takto deklarovaný objekt nám samozřejmě nebudou chodit funkce distance_from_origin(), print_point(obj) a find_center(obj), protože všechny používají jména x,y. Bude nám chodit funkce grow_rectangle(obj, dwidth, dheight).


12.8 Instance jsou měnitelné

Změnu instance můžeme provést změnou některého z jejich atributů a to přiřazením. Abychom například změnili velikost obdélníka bez změny jeho polohy, změníme hodnoty width a height:

box.width = box.width + 50
box.height = box.height + 100

Změnu atributů můžeme zobecnit do funkce:

def grow_rectangle(obj, dwidth, dheight):
    obj.width += dwidth
    obj.height += dheight

Můžeme také napsat funkci pro změnu polohy obdélníka:

def move_rectangle(obj, dx, dy):
    obj.corner.x += dx
    obj.corner.y += dy




12.9 Stejnost

Význam slova "stejný" se na první pohled zdá být úplně jasný, ale po krátkém zamyšlení si uvědomíme, že tomu tak docela být nemusí.

Řekneme-li například, že "Honza a já máme stejné auto", máme na mysli skutečnost, že jsou to auta stejné značky, ale jde o dvě různá auta. Řekneme-li, "Honza a já máme stejnou matku", nejspíš tím chceme říci, že se jedná o jednu osobu a že jsme bratři.

Když hovoříme o objektech, setkáváme se s podobnou víceznačností. Řekneme-li například, že dvě instance třídy Point jsou stejné, má to znamenat, že obsahují stejná data (souřadnice), nebo že to jsou skutečně tytéž objekty?

Připomeňme si, že každý objekt má své jedinečné identifikační číslo (id), typ a hodnotu. Pro určení stejnosti dvou ID používáme operátor is, pro určení stejnosti dvou hodnot používáme operátor ==.

Instance tříd jsou složené a měnitelé objekty a z hlediska "stejnosti" se chovají odlišně než například seznamy:

>>> a = Point(3,4)
>>> b = Point(3,4)
>>> c = b
>>> id(a), id(b), id(c)
(78667568, 78667688, 78667688)
>>> id(a) != id(b) and id(b) == id(c)
True

I když a a b mají stejné souřadnice, jsou to různé objekty. Teprve přiřazením b k c vytvoříme aliasy téhož objektu.

Porovnávání (==) pouze odkazů na objekty, nikoliv jejich obsahů se nazývá mělká rovnost (shallow equality):

>>> a is b, a == b
(False, False)    # proč to druhé False? - viz poznámka
>>> b is c, b == c
(True, True)      # odpovídá očekávání

Poznámka pro zvídavé: Neidentické instance třídy se normálně
porovnávají jako "non-equal" pokud třída nemá
definovanou metodu __eq__()  viz  dokumentace Python 3.6 

Porovnávání (==) obsahů objektů se nazývá hluboká rovnost (deep equality):

>>> a.x is b.x, a.x == b.x
(True, True)    # oba atributy 'x' mají stejné ID i hodnoty
>>> b.x is c.x, b.x == c.x
(True, True)    # dtto

Pro tento typ porovnání si napíšeme funkci same_coords:

def same_coords(p1, p2):
    return (p1.x == p2.x) and (p1.y == p2.y)

Funkci zavoláme pro vytvořené objekty a, b, c  :

>>> same_coords(a,b)
True
>>> same_coords(b,c)
True

Závěrečné hodnocení je takové, že odkazují-li dvě proměnné na různé objekty se stejnými hodnotami má mělká rovnost hodnotu False, hluboká rovnost hodnotu True.

Odkazují-li dvě proměnné ke stejnému objektu, jejich mělká i hlubokou rovnost má hodnotu True.




12.10 Kopírování

Užívání aliasů může učinit program méně přehledným, protože změny provedené na jednom místě se mohou nečekaně projevit na místě jiném. Je obtížné sledovat všechny proměnné, které se k danému objektu mohou vztahovat.

Kopírování objektu je často vhodnou alternativou k aliasování. Modul copy obsahuje funkci copy, která vyrobí duplikát libovolného objektu:

>>> import copy
>>> p1 = Point(3,4)
>>> p2 = copy.copy(p1) 
>>> p1 is p2
False                # mají různá ID
>>> same_coords(p1, p2)
True                 # mají stejné souřadnice

Poté, co importujeme modul copy, můžeme použít funkci copy k vytvoření nové instance třídy Point. Instance p1 a p2 nejsou týmž objektem, ale obsahují stejná data.

Takto vytvořené kopii říkáme mělká kopie (shallow copy) a je postačující pro objekty, které neobsahují vnořené objekty.

Pro instanci třídy Rectangle, která obsahuje atribut corner, jenž má své další atributy, není funkce copy příliš vhodná. Kopíruje totiž jen odkaz na objekt třídy Point, takže jak starý objekt p1, tak nový objekt p2 odkazují k jediné instanci třídy Point.

Vytvoříme-li obdélník b1 a jeho kopii b2 funkcí copy, potom zobrazení vnitřní struktury popsané operace vypadá takto:



To zcela určitě není to, co jsme si přáli. Invokace grow_rect pro obdélník b1 nebude mít vliv na obdélník b2, ale invokace move_rect pro jeden z obdélníků ovlivní oba, protože oba sdílejí stejný atribut corner s parametry x, y. Toto chování je zmatečné a náchylné k chybám.

Naštěstí modul copy obsahuje funkci deepcopy, která kopíruje i vnořené objekty. Jistě nás nepřekvapí, když se dozvíme, že tato operace se nazývá hluboká kopie .

>>> b2 = copy.deepcopy(b1)

Nyní jsou b1 a b2 zcela oddělené objekty.




12.11 Glosář

třída (class) Uživatelsky definovaný typ. Třídu lze považovat za prototyp objektů, určující jejich vlastnosti a chování.

instance Konkretní objekt určité třídy.

objekt (object) Všechno v Pythonu je objekt. Zejména 'instance' se často označuje jako objekt.

konstruktor (constructor) Metoda __init__, kterou Python automaticky použije při tvorbě nové instance.

atribut (attribute) Společné označení pro proměnné třídy i objektů a metody.

mělká rovnost (shallow equality) Rovnost odkazů, nebo dvou odkazů, které ukazují na stejný objekt.

hluboká rovnost (deep equality) Rovnost hodnot, nebo dvou odkazů, které ukazují na objekty se stejnými hodnotami.

mělká kopie (shallow copy) Kopie objektu včetně odkazů na vnořené objekty provedená příkazem copy.copy(item); vnořené objekty se nezkopírují, pouze odkazy.

hluboká kopie (deep copy) Kopie objektu včetně jeho vnořených objektů provedená příkazem copy.deepcopy(item)




12.12 Cvičení

1. Stejně jako jsme porovnávali tři objekty a,b,c v odstavci 13.9 proveďte porovnání tří seznamů sa, sb, sc;   sa = [1, 2, 3].
2. Do třídy Rectangle vložte metodu area, která vrací plochu obdélníka

   r = Rectangle(Point(0,0), 50,100)
   # test: r.area() --> 5000
   

3. Do třídy Rectangle vložte metodu perimeter, která vrací obvod obdélníka

   r = Rectangle(Point(0,0), 50,100)
   # test: r.perimeter() --> 300
   

4. Do třídy Rectangle vložte metodu flip, která zamění jeho šířku za výšku a obráceně
5. Ke třídě Point přidejte metodu sklon, která vrátí sklon spojnice mezi bodem x,y a počátkem 0,0. Její evokace může vypadat takto:

   >>> Point(4,10).sklon()
   2.5
   

   Sklon vyjádříte jako tangetu úhlu. Ošetřte případ, kdy úhel=0 nebo úhel=90.