Python Jiří Znamenáček Objekty pro pokročilé 2016-04-xx

Python umožňuje provádět spoustu věcí jinde nemyslitelných. Koneckonců, všechno v Python'u je přece objekt, se kterým si můžeme dělat (téměř) všechno, co chceme:

>>> def fn(): ... pass ... >>> dir(fn) ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] >>> fn.haf = 'Já jsem funkce!' >>> fn.haf 'Já jsem funkce!'

Ale jak už to tak bývá, mocné prostředky se dají také velice snadno zneužít. Takže pozor na ně ^_~

Stejně jako jsou objekty konkrétními instancemi svých tříd (nebo vlastně také typů), jsou třídy instancemi svých metatříd:

Metatřídy jsou volatelné objekty, které slouží ke tvorbě tříd. Jejich návratovou hodnotou je tudíž volatelný objekt, který pak následně slouží jako konstruktor (nějaké) třídy.
V jiných jazycích by se pythoním metatřídám asi říkalo class factory.

Spoustu věcí, na které se dříve metatřídy především používaly, dnes už dokážou obstarat dekorátory tříd, které jsou ovšem podstatně mladšího data. Ale narozdíl od nich se metatřídy dědí (jsou to koneckonců vlastně „obyčejné“ typy, něco jako třídy na druhou), takže metatřídou „odekorované“ chování nových tříd mohou podědit i jejich potomci, což samozřejmě dekorátory nedokážou.

Než se začneme topit v metatřídách, začněmež od něčeho jednoduššího – zavedením nové instance třídy. Tento proces je (alespoň od dob zavedení „nových“ objektů ve dvojkovém Python'u) ve skutečnosti dvoustupňový – nejdříve je vytvořen objekt samotný, aby byl následně předán ke svému naplnění vstupními parametry vlastního konstruktoru:

  1. volající kontext si vyžádá zavedení nové instance třídy;
  2. tato nová instance třídy je vytvořena zavoláním metody __new__(cls[, …]) požadované třídy… Kde cls je reference na tuto třídu.
  3. …a následně je její jmenný prostor patřičně upraven voláním metody __init__(self[, …]) této třídy; Kde self je reference na nový objekt čerstvě vytvořený v předchozím kroku.
  4. takto vyrobený a upravený objekt instance je poté vrácen žadateli. Jinými slovy: Je přidán do jmenného prostoru jeho kontextu.

Na tomto procesu je zajímavé, že pythoní programátoři mají možnost se v obou krocích podle svého (zne)uvážení přehrabovat, protože jsou oba dostupné pod svými vlastními „magickými“ metodami.

Zatímco konstruktor instance třídy __init__() znají všichni jako své boty, vlastního stvořitele této instance __new__() vidí asi poprvé. Jde o to, že __init__() jako svůj první parametr (automaticky) dostává odkaz na právě zaváděnou instanci, takže mu ji někdo jiný musí nejdříve připravit. A tím někým je právě __new__().

Vzhledem k tomu, že __new__() tuto novou instanci přivede k existenci, nepřekvapí snad, že ji také vrací. Přitom nejsnažším způsobem, jak zajistit vytvoření správného typu objektu, je přenechat práci na svém rodiči (ať už je jím kdo chce):

>>> class Pokus: ... def __new__(cls): ... print('__new__:', cls) ... return super().__new__(cls) ... def __init__(self): ... print('__init__:', self) >>> p = Pokus() __new__: <class '__main__.Pokus'> __init__: <__main__.Pokus object at 0x0110DC50>

PS: Nenechte se rozhodit tím, že __new__(cls) dostává na vstupu automaticky referenci na svoji vlastní třídu. Ve skutečnosti je to statická metoda třídy (schválně si před ni zkuste připsat @staticmethod) s pevně určeným prvním parametrem. Navíc je to celé v interpretru zadrátovaná vlastnost, takže se prostě píše takhle. Netuším proč.

Metodu __new__() si pochopitelně můžete upravit k obrazu svému, ale jakmile se vám podaří nevrátit z ní referenci na správný typ objektu (zde tedy Pokus), odpovídající __init__() se pochopitelně nezavolá (protože se volá na příslušné třídě). Jako třeba když nevrátíte nic:

>>> class Pokus: ... def __new__(cls): ... print('__new__:', cls) ... def __init__(self): ... print('__init__:', self) >>> p = Pokus() __new__: <class '__main__.Pokus'>

Samozřejmě často není důvod vůbec __init__() volat, takže to koneckonců může být i žádané chování. Ale když zrovna není, tak víte, kam se podívat na pravděpodobného viníka.

Při tvorbě vlastních metatříd typicky musíte __new__() přepsat, protože – jak už nyní víme – to je právě to místo, které je zodpovědné za tvorbu nových tříd.

A pak ještě při dědění z neproměnných vestavěných typů: Má-li býti totiž nově vytvořený objekt co k čemu, nemůže to být pouhá reference na původní neproměnný typ, kterou jedinou můžete získat z __init__()'u – neproměnný typ je totiž od toho neproměnný, že ho nemůžete zaměnit za něco jiného ^_~

Kdyby ovšem přepsání kroku __new__() bylo to jediné, co by metatřídy dělaly, nikdo by je nepotřeboval a všichni by háčkovali obyčejné třídy (ne že by se metatřídy od tříd nějak extra lišily, že).

Ve skutečnosti umí metatřídy kompletně předepsat (a přepsat) způsob, jakým jsou za běhu (tedy dynamicky) vyrobeny nové typy (nebo – chcete-li – třídy). Na což mimochodem je – asi trochu překvapivě vzhledem ke svému běžnému použití – specializována funkce type().

Vytvoření nové třídy je vcelku náročný proces. I když do něj nebudete většinou potřebovat (natožpak chtít) zasahovat, vyplatí se o něm alespoň něco vědět. V podstatě jsou při zavádění nové třídy provedeny následující kroky, a to v uvedeném pořadí:

  1. volající kontext si vyžádá zavedení nové třídy;
  2. je nalezena nejvhodnější metatřída jako základ nově zaváděné třídy; Ve spoustě případů je jí právě type(), ale programátor může samozřejmě předepsat jinou.
  3. je zaveden nový jmenný prostor třídy (a to buď jako prázdný slovník zavoláním konstruktoru dict() nebo – je-li k dispozici – voláním metody __prepare__ na metatřídě);
  4. je vykonáno tělo definice třídy (čímž dojde k naplnění jejího jmenného prostoru, tedy zavedení atributů třídy);
  5. konstruktor metatřídy (spolu se jménem zaváděné třídy a případnými rodiči a vstupními parametry) je použit k vytvoření „instance“ nové třídy; Tímto konstruktorem bývá velmi často tedy type(). Přitom vrácený objekt nové třídy je právě ten, na který odkazuje metoda super() (bez parametrů!) z jejích instancí.
  6. obsahuje-li definice třídy dekorátory, je jim nově vytvořená instance „předhozena“, aby ji upravily k obrazu svému;
  7. výsledný objekt je namapován do jmenného prostoru volajícího kontextu.

Při běžném programování je pro nás asi nejdůležitější vědět, v jaké chvíli je vykonáván krok dekorátorů (a i tak se dekorování tříd nedělá moc často). Při „těžkém háčkování“ pomocí metaprogramování pak asi nalezení odpovídající metatřídy (což není triviální záležitost) a její aplikace.

Nejdůležitější metatřídu ze všech tedy všichni dobře znají – je jí totiž (jak už jsem říkal možná trochu překvapivě) stará dobrá známá funkce type().

Jak už víme, běžně slouží funkce type(OBJEKT) ke zjišťování typu OBJEKTu. Návratová hodnota přitom většinou odpovídá atributu OBJEKT.__class__.

Se třemi vstupními argumenty se však type promění na konstruktor tříd aneb tzv. metatřídu, což je popravdě skrytě její zdaleka nejčastější a nejdůležitější použití: 

        třída = type(JménoTřídy, RodičeTřídy, JmennýProstorTřídy)

Přitom platí následující korespondence mezi atributy a výslednou třídou:

Pro obecné metatřídy platí vlastně to samé – jejich odpovědností je převzít jméno třídy, seznam rodičů a slovník parametrů budoucí třídy a z těchto tří složek onu třídu vytvořit.

>>> X = type('X', (object,), dict(a=1)) >>> X <class '__main__.X'> >>> X.__class__ <class 'type'> >>> dir(X) ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a'] >>> X.a 1 >>> x = X() >>> x <__main__.X object at 0x00DCB890> >>> x.__class__ <class '__main__.X'> >>> dir(x) ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a'] >>> x.a 1

Z hlediska programátora fungují metatřídy celkem neviditelně – pokud si použití nějaké výslovně nevyžádá, odehrává se veškerá metatřídní „magie“ mimo jeho dohled: Při zavádění nové třídy se prostě zavolá nejvhodnější dostupný konstruktor, ve většině případů právě funkce type(), který požadovanou třídu vyrobí a vrátí nám ji.

Pokud chceme použít nějakou specifickou metatřídu, můžeme si ji při zavádění nové třídy vyžádat pomocí atributu konstruktoru metaclass:

class Třída(metaclass=Metatřída): pass

Tahle zdánlivě nevinná operace samozřejmě vyžaduje, aby konstruktor Metatřída existoval a choval se tak, jak se spořádaná metatřída chovat má. A to už taková švanda není. V dalším se tomu všemu podíváme na zoubek.

Bez metatřídy napíšeme..

class Třída: pass

..a zavolá se:

Třída = type(Jméno, Rodiče, JmennýProstor)

S metatřídou napíšeme..

class Třída(metaclass=Metatřída): pass

..a zavolá se (alespoň v typickém případě):

Třída = Metatřída(Jméno, Rodiče, JmennýProstor) # což odpovídá volání Třída = Metatřída.__new__(Metatřída, Jméno, Rodiče, JmennýProstor) Metatřída.__init__(Třída, Jméno, Rodiče, JmennýProstor)

PS: V reálném případě stačí, aby nějaký předek byl založen na metatřídě – Python pak příslušnou volací sekvenci dohledá sám.

Z praktického hlediska jsou metatřídy obyčejné třídy, na kterých ale definujete „magickou“ metodu __new__(), která je právě volána při „výrobě“ instancí tříd, případně __init__(), která je volána při naplnění nově vytvořené instance daty.

A to buď obě najednou nebo aspoň jednu z nich. Častější je zřejmě varianta pouze s __new__().

Stejně tak dobře můžeme ještě přepsat metodu __call__(), která se volá při zavádění instancí, čímž můžeme mimo jiné odseparovat, co třída dělá, od toho, jak je vytvořena.

Pokud nadefinujete také metodu __prepare__(), bude tato použita při přípravě jmenného prostoru třídy (jinak se použije běžný pythoní slovník dict()).

Příklad (upravený z dokumentace) bude určitě názornější. Připravme si následující metatřídu (která pro zajímavost definuje jak __new__(), tak i __prepare__()):

class OrderedClass(type): @classmethod def __prepare__(metacls, name, bases, **kwargs): print('__prepare__:', metacls, name, bases, kwargs) return collections.OrderedDict() def __new__(cls, name, bases, namespace, **kwargs): print('__new__:', cls, name, bases, namespace, kwargs) result = super().__new__(cls, name, bases, dict(namespace)) result.members = tuple(namespace) return result

Pokud třídu OrderedClass použijeme jako metatřídu, stane se přesně to, co bychom očekávali:

>>> class A(metaclass=OrderedClass): ... pass __prepare__: <class '__main__.OrderedClass'> A () {} __new__: <class '__main__.OrderedClass'> A () OrderedDict([ ('__module__', '__main__'), ('__qualname__', 'A') ]) {}

Uvedená metatřída byla použita jako konstruktor ke tvorbě nové třídy, tedy vlastně instance metatřídy, jak dokazuje:

>>> isinstance(A, OrderedClass) True >>> A.__class__ <class '__main__.OrderedClass'> >>> issubclass(A, OrderedClass) False

Byly proto zavolány obě dvě metody v uvedeném pořadí – nejdříve __prepare__() pro zavedení upraveného jmenného prostoru budoucí třídy a následně __new__() pro vlastní zavedení této třídy.

Jestě pro zajímavost – pro instanci třídy A platí:

>>> a = A() >>> a <__main__.A object at 0x0111C6D0> >>> a.__class__ <class '__main__.A'> >>> isinstance(a, A) True >>> isinstance(a, OrderedClass) False

Protože jsme uvedenou metatřídu zaváděli proto, abychom získali třídy, které si budou pamatovat pořadí svých atributů (zde konkrétně za pomoci atributu members), vyzkoušejme ještě tuto funkcionalitu:

>>> class A(metaclass=OrderedClass): ... def jedna(self): pass ... def dva(self): pass ... def tři(self): pass ... def čtyři(self): pass __prepare__: <class '__main__.OrderedClass'> A () {} __new__: <class '__main__.OrderedClass'> A () OrderedDict([ ('__module__', '__main__'), ('__qualname__', 'A'), ('jedna', <function A.jedna at 0x011027C8>), ('dva', <function A.dva at 0x011023D8>), ('tři', <function A.tři at 0x011026F0>), ('čtyři', <function A.čtyři at 0x01102780>) ]) {} >>> A.members ('__module__', '__qualname__', 'jedna', 'dva', 'tři', 'čtyři')

Z __new__() můžete popravdě vrátit cokoliv. Třebas i již existující instanci (pokud možno správného typu samozřejmě) místo čerstvě vyrobené nové.

Ale možná ještě vtipnější je, že pro napsání metatřídy nakonec nemusíte __new__() vůbec použít. Úplně stačí, pokud volatelný objekt použitý jako metatřída vrací příslušný nový typ. A volat se dá v Python'u všechno, co má nadefinováno metodu __call__(). Což jsou kromě tříd mimo jiné třeba i funkce ^_~

Začněmež rovnou od „obyčejných“ funkcí:

>>> def fn(*args, **kwargs): ... return type('X', (object,), dict(a=1)) >>> class F(metaclass=fn): ... pass # třída >>> F <class '__main__.X'> >>> F.__class__ <class 'type'> >>> F.a 1 # instance >>> F() <__main__.X object at 0x00FDEA70> >>> F().__class__ <class '__main__.X'> >>> F().a 1

To bylo nakonec celkem jednoduché. (Byť kvůli dynamické tvorbě třídy v kontextu funkce, který je po návratu z ní zapomenut, můžeme mít kapku problém s introspekcí.)

S třídami to ale může být horší. Když totiž šikovně přepíšete jejich metodu __call__(), nemusíte se v odůvodněných případech s __new__() vůbec babrat. Jako třeba v následujícím způsobu přípravy singletonu:

>>> class Singleton(type): ... def __init__(self, *args, **kwargs): ... print('__init__:', self, args, kwargs) ... super().__init__(*args, **kwargs) ... self.__instance = None ... def __call__(self, *args, **kwargs): ... print('__call__:', self, args, kwargs, self.__instance) ... if self.__instance is None: ... self.__instance = super().__call__(*args, **kwargs) ... return self.__instance >>> class Třída(metaclass=Singleton): ... def __init__(self, *args, **kwargs): ... print('Třída.__init__:', self, args, kwargs) ... self.args = args ... self.kwargs = kwargs __init__: <class '__main__.Třída'> ('Třída', (), { '__qualname__': 'Třída', '__module__': '__main__', '__init__': <function Třída.__init__ at 0x0113E108> }) {} # 1. volání: dojde k nastavení atributů >>> t = Třída(1, a=2) __call__: <class '__main__.Třída'> (1,) {'a': 2} None Třída.__init__: <__main__.Třída object at 0x011381F0> (1,) {'a': 2} >>> t.args, t.kwargs ((1,), {'a': 2}) # 2. volání: atributy se nepřepíší, protože jsou již jednou nastavené >>> t = Třída(3, a=4) __call__: <class '__main__.Třída'> (3,) {'a': 4} <__main__.Třída object at 0x011381F0> >>> t.args, t.kwargs ((1,), {'a': 2}) Volně podle Stack Overflow.

Jelikož zavolání instance vyvolá poděděnou metodu __call__() z příslušné metatřídy, která se aplikuje na volající instanci, dojde tím ke kontrole atributu __instance a podle jejího výsledku bude vytvoření pozměněné instance buď dovoleno nebo zakázáno.

V předchozím příkladu můžete stejně dobře použít i variantu bez super()..

class Singleton(type): def __init__(self, *args, **kwargs): self.__instance = None def __call__(self, *args, **kwargs): if self.__instance is None: self.__instance = super().__call__(*args, **kwargs) return self.__instance

..nebo dokonce úplně bez __init__():

class Singleton(type): __instance = None def __call__(self, *args, **kwargs): if self.__instance is None: self.__instance = super().__call__(*args, **kwargs) return self.__instance

Jen prostě instance musí mít dostupný atribut __instance. Jinak záleží, co konkrétně potřebujete v kterém kroku případně udělat (třeba toho chcete v rámci inicializace třídy „napáchat“ víc, pak ten __init__() využijete).

Na úrovni konkrétního objektu můžete samořejmě použít i variantu pomocí __dict__, ale tahle „metatřídní“ vám vyrobí singletony zadarmo všude pouhým odkazem na příslušnou metatřídu.

Jelikož sám OOP prakticky vůbec nepoužívám, návrhy na použití metatříd naprosto bez invence opisuji z dokumentace: