Ačkoli všechno v Python'u je objektem (dokonce i funkce se v něčem chovají jako objekty!), nepatří Python mezi „tvrdé“ OOP-jazyky, tedy programovací jazyky, které nejen umožňují používat při práci možnosti tzv. objektového programování (dnes už většina), ale dokonce to i vyžadují (jako např. Java).
Historicky třeba ani knihovna Python'u nebyla moc objektová, protože úžasné zapouzdření kódu do modulů ho pro většinu použití bohatě nahradí. Nicméně jsou místa, kde je v Python'u použití objektů (resp. tzv. tříd) zcela na místě a nikdo se mu nevyhýbá. A na jednom takovém si základy OOP v následujících slajdech vysvětlíme.
Mějme za úkol přebírat odněkud data a kopírovat je do (pythoního) seznamu, ale s vynecháním duplikátů. Kód by mohl vypadat například takto:
Co kdybychom však měli k dispozici datovou strukturu, která by se chovala úplně stejně jako seznam, pouze by nepřipouštěla zanesení duplikátů? Pak by kód mohl vypadat takto:
Python umožňuje takovou datovou strukturu vyrobit velmi snadno. Pojďme na to.
Chceme připravit datovou strukturu MůjSeznam, která se bude (skoro úplně) chovat jako seznam. To se v Python'u dělá zavedením tzv. třídy pomocí klíčového slova class, kde do závorek za jméno vytvářené třídy napíšeme rodiče, jehož vlastnosti chceme podědit:
Identifikátor MůjSeznam nyní múžete používat místo (vestavěné) funkce list a vytvořená struktura se bude opravdu chovat jako seznam:
Náš nový MůjSeznam se však zatím chová (prakticky) úplně stejně* jako vestavěný seznam list, duplikáty zatím neřeší.
MůjSeznam = list a ušetřit si řádku kódu a drobné rozdíly ve vnitřní struktuře :-)
Tělo třídy z předchozího slajdu je sugestivně prázdné pomocí objektu výpustky .... To naznačuje, že do něj můžeme něco napsat. Třebas definici funkce append(), která ale bude zahazovat duplikáty:
Než si kód vysvětlíme, podívejme se, jak se chová:
Tak, jak jsme chtěli – jako seznam a zahazuje duplikáty.
Podívejme se znovu na kód:
Třída MůjSeznam podědila všechny vlastnosti vestavěného seznamu list s jedinou výjimkou – metoda append() pro přidání prvku se na ní chová jinak. Přitom:
MůjSeznam() vyrobíme tzv. instanci třídy, v našem případě konkrétního zástupce modifikovaného typu seznam;
if prvek not in self);
super()), který to samozřejmě umí (metoda append() vestavěného typu list), jen tam prostě nepošleme všechny prvky (pouze neduplikáty).
Jediná divná věc je, že námi nadefinovaná metoda (tak se říkám funkcím, které patří k nějaké konkrétní instanci či třídě) append(self, prvek) obsahuje dva parametry, přestože se nadále v kódu volá pouze s jedním jako xs.append(123). Jak je to možné? Viz dále.
Kdyby autoři programovacího jazyka Python ho skutečně zamýšleli pro výuku, zařídili by, aby se předchozí kód psal například takto:
Ani byste nemuseli vědět, že @instance_method před definicí funkce označuje tzv. dekorátor, abyste zpozorněli a řekli si: „Aha, tahle funkce se asi nebude chovat úplně tak, jak bych na první pohled čekal!“ Pak už by úplně stačilo, aby vám někdo řekl (nebo jste si někde našli), že:
Metody instancí při svém volání dostanou automaticky na prvním místě jeden parametr navíc, a to právě odkaz na příslušnou instanci.
A od téhle chvíle dál byste si prostě pamatovali, že v Python'u při definici metody instance musíte na začátek parametrů připsat self, a bylo by vystaráno.
Bohužel v historii při vývoji Python'u došlo k rozhodnutí, že instanční metody potřebují lidi při vytváření tříd tak často, že jim ušetříme psaní a nebudeme je nijak označovat. Takže si holt musíte zapamatovat, že:
Funkce v těle třídy, pokud se mají chovat jako instanční metody, musí na prvním místě v seznamu parametrů navíc obsahovat referenci na instanci.
Že se této referenci říká zrovna self je sice velice výmluvné, ale kupodivu to není vyžadované (byť je to velmi doporučované). Zkuste si ji přejmenovat třebas na this:
Výsledek se bude chovat úplně stejně. Akorát ostatní pythoní programátoři vás asi nebudou mít moc rádi :-)
PS: Popravdě většina ostatních programovacích jazyků podporujících OOP to píše v podstatě takto..
..neboli reference na instanci se do metody explicitně nepředává jako jeden z jejích parametrů, ale „automagicky“ se objeví v těle metody pod klíčovým pojmenováním this (proto jsem ho také vybral). Takže jde spíš o to, jaká z variant se tvůrcům toho kterého jazyka víc líbila.
Na předchozím slajdu vás mohla zarazit věta „pokud se mají chovat jako instanční metody“. A znamená přesně to, co z ní vyplývá:
Metod ve třídách existuje více druhů a chovají se různě. (A také se různě zapisují.)
Postupně se s těmito dalšími druhy metod seznámíme.
Řekněme, že by vás zajímalo, kolik různých instancí vašeho upraveného seznamu už v programu používáte. Zjevně byste potřebovali ve chvíli, kdy vyrábíte novou instanci, někam zaznamenat, že vám právě jedna přibyla. Na to potřebujete dvě věci:
Druhý bod splníte tím, že čítač (proměnnou) zavedete v těle třídy, čímž bude dostupný jako prvek jejího jmenného prostoru. První bod pak umožňuje Python přepsáním (v definici třídy) speciální funkce jménem __init__() (skutečně jsou na začátku a na konci dvě podtržítka!), která se volá při zavádění nových instancí.
PS: Funkcím, či vlastně metodám, jejichž jméno začíná a končí na dvě podtržítka, se v Python'u říká magické metody. Je to běžné používaný terminus technicus a možná byl vybrán proto, co všechno s jejich pomocí můžete zařídit.
Příslušný kód může vypadat například takto:
Jeho funkcionalita je celkem průhledná:
MůjSeznam.čítač_instancí;
__init__() se chová jako každá jiná instanční metoda, tzn. dostává jako první parametr referenci na odpovídající instanci a funkce super() získá odkaz na rodiče naší třídy, na němž pak zavolá jeho metodu __init__() a provede inicializaci našeho upraveného seznamu prvním prvkem.
Co možná není na první pohled průhledné, je použití operátoru hvězdička * v kódu, ale to až později.
__init__() už k dispozici příslušný prázdný seznam, do kterého může rodič přidat první prvek, zajišťuje metoda __new__() ve spolupráci s funkcí type(), ale to už bychom zabředli do vnitřností OOP v Python'u více, než je zdrávo.
PS: Metodám, které zařídí vyrobení nové instance a její případné naplnění vstupními prvky, se obecně říká konstruktory. Budu tak nadále říkat i naší metodě __init__().
V úplnosti náš kód zatím vypadá takto..
..a chová se přesně tak, jak jsme chtěli:
Operátor hvězdičky * jsme museli do metody __init__() v předchozím kódu přidat, aby se náš upravený seznam choval jako vestavěný i při inicializaci, tzn. bez parametru vyrobil prázdný seznam a s parametrem ho v případě potřeby rozdělil na jednotlivé prvky:
Vysvětlení:
__init__(self, první_prvek), byl by právě jeden parametr vždy vyžadován a konstruktor by bez něj nešel zavolat:
super().__init__(první_prvek) bez hvězdičky by přeposlalo dál tuto jednici a výsledek by byl úplně jiný:
PS: Hvězdička samozřejmě umožní zadat libovolný počet pozičních parametrů, což v konstruktoru seznamu není dovoleno, ale o to už se postará metoda __init__() rodiče, tedy vestavěného typu seznam.
Kód MůjSeznam.čítač_instancí += 1 samozřejmě není moc hezký – pokud bychom kdo ví proč později třídu přejmenovali, museli bychom změnit i toto místo, což není nejšťastnější. Python nepřekvapivě umožňuje oddělit referenci na třídu podobným způsobem, jako jsme oddělili referenci na instanci pomocí prvního parametru self, jen se mu v tomto případě doporučuje říkat cls (od class):
@classmethod je tedy, jak už víme, tzv. dekorátor, a pokud je neznáte, stačí si pamatovat, že umí upravit, jak se jím odekorovaná funkce konkrétně chová. V našem případě zjevně takto označeným metodám podstrčí na prvním místě parametrů referenci na příslušnou třídu:
Kromě toho existuje ještě jeden dekorátor pro metody ve třídách – @staticmethod:
Nepřekvapivě zařizuje, že funkce se chovají tak, jak jsou napsané, ať už je voláte na instanci nebo přímo ve jmenném prostoru třídy:
V tomto případě tedy dekorátor @staticmethod naopak způsobí, že funkce definovaná ve jmenném prostoru třídy se chová pořád stejně, tj. nedostává na prvním místě parametrů podstrčenou žádnou referenci navíc.
Celkově tedy Python rozeznává u tříd tři druhy metod:
@instancemethod…
@classmethod, při volání dostanou navíc na prvním místě referenci na odpovídající třídu (která se tradičně označuje cls)
@staticmethod, při volání se chovají očekávaně (tj. Python do jejich parametrů nic nepřidává)
Celkově naše třída nyní vypadá takto:
Všechny objekty, které jsme uvnitř ní nadefinovali, jsou vidět v jejím jmenném prostoru při výpisu funkcí dir():
dir(MůjSeznam()) je úplně stejný.
Z výpisu atributů na předchozím slajdu jsem pro přehlednost vynechal magické metody, tj. všechny ty, jejichž jméno začíná a končí právě na dvě podtržítka.
Je jich tam totiž strašně moc :-) Samozřejmě mezi nimi naleznete náš nyní již starý známý __init__, dále metody, které vám asi něco připomenou (jako např. __add__, __contains__ nebo __len__), ale především hromadu dalších, které vám zatím asi nic neříkají. Ale když si ukážeme následující kód..
..začnete asi tušit, že magické metody vlastně řídí konkrétní chování objektů (tříd). Nejenom že spousta vestavěných funkcí z globálního jmenného prostoru vlastně „pouze“ volá odpovídající magické metody na příslušných objektech (namátkou kromě len() také třeba str() nebo format()), ale i většina operací s objekty se překládá na vhodné volání jejich magických metod (např. volání x < y ve skutečnosti způsobí zavolání x.__lt__(y) a podobně a smyčka for-in zase funguje jen a pouze díky přítomnosti magické metody __iter__).
Protože magické metody v Python'u opravdu můžou snad úplně za všechno, tady už to stačí a další najdete v několika samostatných přednáškách: kontext with-as, třídění a porovnávání, iterátory a cyklus for-in, další magické metody.
__dict__, __firstlineno__, __module__, __static_attributes__ a __weakref__.
Většina programovacích jazyků podporujících principy OOP zahrnuje ještě koncept tzv. privátních metod (či atributů). Takové jsou určeny pouze pro vnitřní potřeby třídy a mimo ni nejsou viditelné (a pochopitelně ani volatelné).
Python trochu překvapivě privátní atributy (včetně metod) nemá. Pokud je potřebujete, místo neexistujícího dekorátoru (například) @privatemethod se používá přidání dvou podtržítek před vlastní název atributu (a nejvýše jednoho podtržítka za něj; jinak byste zavedli magický název):
Nyní už atributy __schovaná_proměnná a __schovaná_statická_metoda pod jejich názvy ve výpisu funkce dir() nenajdete. Tedy alespoň ne přímo, protože ve skutečnosti tam jsou, pouze s trošku pozměněnými jmény:
Jak vidíte, došlo k úpravě jejich názvů ve formátu _JménoTřídy__JménoAtributu. Takže kdo to ví, i takto „schované“ atributy ve třídě najde. Nicméně jako na mnoha jiných místech v Python'u, která se řídí dohodnutým zvykem, se všichni tváří, že tam nejsou ^_~
Kromě podědění vlastností nějaké vestavěné – nebo námi vytvořené! – třídy, umožňuje Python vyrobit i třídy zdánlivě bez rodiče:
Ve skutečnosti i takovéto třídy mají svého rodiče – je jím univerzální prapředek všech objektů v Python'u object, jak ukazuje následující kód vypisující „rodný strom“ třídy:
Jedná se tedy v podstatě pouze o zkratku v zápisu, ale zrovna v tomto místě užitečnou (narozdíl od oněch nešťastných instančních metod).
Nabízí se otázka, k čemu vlastně takovéto obecné třídy, které se nesnaží napodobit nějaký vestavěný objekt, jsou. Protože třídy si otevírají vlastní kontext, většinou se používají na zapouzdření dat (i funkcí) do příslušného jmenného prostoru třídy..
..odkud se pak dají pomocí klasické tečkové notace vyvolat:
Samozřejmě můžete takovouto třídu použít i jako konstruktor, ale neoznačené funkce se pak stanou instančními metodami a vůbec všechno tohle okolo.
Jelikož všechno v Python'u je objekt (tedy vlastně původně nějaká třída), nepřekvapí, že k danému tématu se toho dá sepsat opravdu hodně. Zde je uspořádaný výběr některých témat, která jsem za ty roky učení vyprodukoval:
super()inspect)