Lidsky řečeno
Sáhneš do šuplíku a vezmeš si, co tam leží. To je obyčejný atribut. Teď si představ, že u šuplíku stojí vrátný: ptáš se na totéž, ale on si ověří, kdo jsi, věc spočítá nebo ji odmítne vydat. To je deskriptor. A metatřída je dílna, která nevyrábí sušenky ani vykrajovátka na ně, ale stroj na vykrajovátka. Třída je vykrajovátko, instance je sušenka.
Co se stane při obj.x
Tečka vypadá nevinně. Python ale při obj.x prochází víc míst. Každá instance má vlastní slovník __dict__ a každá třída také.
class Hrnek:
barva = "bílá"
h = Hrnek()
print(h.barva, h.__dict__)
h.barva = "černá"
print(h.barva, h.__dict__, Hrnek.barva)
del h.barva
print(h.barva)
bílá {}
černá {'barva': 'černá'} bílá
bíláDokud instance barvu nemá, našel se atribut ve třídě. Přiřazení ho založilo v instanci a ta dostala přednost. Třídy se to nedotklo. Tohle platí, dokud ve třídě leží obyčejná hodnota. Když tam ale leží objekt se speciálními metodami, Python ho nevrátí, nýbrž se ho zeptá.
První deskriptor
Deskriptor je objekt uložený jako atribut třídy, který má aspoň jednu z metod __get__, __set__, __delete__. Při čtení zavolá Python jeho __get__ a vrátí to, co metoda vrátí.
class Hlasatel:
def __get__(self, instance, owner=None):
print(f"čtu: instance={instance!r}, třída={owner.__name__}")
return 42
class Stroj:
hodnota = Hlasatel()
def __repr__(self):
return "<stroj>"
s = Stroj()
print(s.hodnota)
print(Stroj.hodnota)
čtu: instance=<stroj>, třída=Stroj 42 čtu: instance=None, třída=Stroj 42
instance je objekt, přes který se čte. Při čtení přímo ze třídy je to None. owner je třída.
Užitečný příklad: cena a množství musí být kladné. S property z lekce property a zapouzdření bys psal skoro stejný getter a setter pro každý atribut. Deskriptor pravidlo napíše jednou a použije se, kolikrát chceš.
class KladneCislo:
def __set_name__(self, owner, name):
self.jmeno = name
def __get__(self, instance, owner=None):
if instance is None:
return self
return instance.__dict__[self.jmeno]
def __set__(self, instance, hodnota):
if hodnota <= 0:
raise ValueError(f"{self.jmeno} musí být kladné, přišlo {hodnota}")
instance.__dict__[self.jmeno] = hodnota
class Polozka:
cena = KladneCislo()
mnozstvi = KladneCislo()
def __init__(self, cena, mnozstvi):
self.cena = cena
self.mnozstvi = mnozstvi
p = Polozka(120, 3)
print(p.cena * p.mnozstvi)
print(p.__dict__)
p.mnozstvi = -1
360
{'cena': 120, 'mnozstvi': 3}Tři metody, tři role:
__set_name__zavolá Python jednou při vzniku třídy a řekne deskriptoru, jak se v ní jmenuje. Odpadne psaníKladneCislo("cena").__get__obslouží čtení. Větevinstance is Nonevrací samotný deskriptor, což je zvyk pro přístup přes třídu.__set__obslouží zápis, a proto iself.cena = cenav konstruktoru prochází kontrolou.
Hlídač rozsahu
Napiš deskriptor Rozsah(minimum, maximum). Při zápisu hodnoty mimo interval (krajní hodnoty jsou povolené) vyvolá ValueError a původní hodnota zůstane. Každá instance má vlastní hodnotu a jedna třída může mít víc takových atributů.
class Rozsah:
def __init__(self, minimum, maximum):
self.minimum = minimum
self.maximum = maximum
class Teplomer:
stupne = Rozsah(-30, 50)
Datový a nedatový deskriptor
Rozhoduje, jestli má deskriptor metodu pro zápis.
- Datový má
__set__nebo__delete__. Má přednost před__dict__instance. - Nedatový má jen
__get__. Hodnota v__dict__instance ho přebije.
Celé pořadí při čtení obj.x:
1. datový deskriptor ve třídě (nebo v jejích předcích)
2. obj.__dict__
3. nedatový deskriptor nebo obyčejný atribut třídy
4. metoda __getattr__, pokud ji třída má
5. AttributeErrorNa bodě 2 a 3 stojí chytrý trik: nedatový deskriptor spočítá drahou hodnotu a uloží ji do instance pod svým vlastním jménem. Příště se k němu Python už nedostane, protože slovník instance vyhraje. Stejně funguje functools.cached_property.
class Lina:
def __init__(self, funkce):
self.funkce = funkce
self.jmeno = funkce.__name__
def __get__(self, instance, owner=None):
if instance is None:
return self
print("počítám...")
hodnota = self.funkce(instance)
instance.__dict__[self.jmeno] = hodnota
return hodnota
class Report:
@Lina
def soucet(self):
return sum(range(1000))
r = Report()
print(r.soucet)
print(r.soucet)
print(r.__dict__)
počítám...
499500
499500
{'soucet': 499500}Deskriptory používáš dávno, jen o tom nevíš. Každá funkce je nedatový deskriptor a právě takhle vzniká self. Ve třídě leží obyčejná funkce. Teprve čtení přes instanci zavolá její __get__ a ten vrátí vázanou metodu, tedy funkci spojenou s instancí.
class Pes:
def __init__(self, jmeno):
self.jmeno = jmeno
def stekni(self):
return f"{self.jmeno}: haf"
rex = Pes("Rex")
funkce = Pes.__dict__["stekni"]
print(type(funkce).__name__, hasattr(funkce, "__get__"), hasattr(funkce, "__set__"))
vazana = funkce.__get__(rex, Pes)
print(vazana())
print(rex.stekni.__self__ is rex, rex.stekni.__func__ is funkce)
rex.stekni = lambda: "mňau"
print(rex.stekni())
function True False Rex: haf True True mňau
Poslední řádek je nedatový deskriptor v praxi: záznam v instanci přebil metodu. U property to neprojde, protože je to datový deskriptor, i když mu setter nedáš.
class Kruh:
@property
def polomer(self):
return 5
k = Kruh()
print(hasattr(property, "__set__"))
k.__dict__["polomer"] = 99
print(k.polomer)
k.polomer = 1
True 5
Třída má nedatový deskriptor x a instance má v __dict__ klíč x. Co vrátí obj.x?
Nedatový deskriptor má jen __get__, takže slovník instance má přednost. Datový deskriptor by to otočil.
Zapsat jen jednou
Napiš deskriptor JenJednou. První zápis do atributu projde, každý další u téže instance vyvolá AttributeError. Jiná instance může svou hodnotu nastavit nezávisle. Čtení vrací uloženou hodnotu.
class JenJednou:
pass
class Faktura:
cislo = JenJednou()
Třída je taky objekt
Instanci vyrobila třída. Kdo vyrobil třídu? Funkce type s jedním argumentem vrací typ objektu, se třemi argumenty novou třídu vytvoří. Třída, která vyrábí třídy, se jmenuje metatřída a výchozí je právě type.
class Kocka:
pass
print(type(Kocka()))
print(type(Kocka))
print(type(type))
Pes = type("Pes", (), {"zvuk": "haf", "mluv": lambda self: self.zvuk})
print(Pes, Pes().mluv())
<class '__main__.Kocka'> <class 'type'> <class 'type'> <class '__main__.Pes'> haf
Příkaz class je pohodlný zápis pro totéž. Tělo třídy je obyčejný kód, který se provede hned při definici. Co v něm vznikne, skončí ve slovníku a ten se předá metatřídě.
class Ukazka:
print("tělo třídy běží")
a = 1 + 1
b = a * 10
print(Ukazka.a, Ukazka.b)
tělo třídy běží 2 20
class Jmeno(Predek, metaclass=Meta):
...tělo...
1. Python určí metatřídu (tady Meta, jinak metatřídu předků, jinak type)
2. připraví prázdný jmenný prostor: Meta.__prepare__(...)
3. provede tělo a jména uloží do něj
4. zavolá Meta("Jmeno", (Predek,), jmenny_prostor), to vrátí hotovou tříduVlastní metatřída a lehčí cesta
Metatřída je potomek type. Může třídu při vzniku zkontrolovat nebo upravit. Tahle trvá na tom, že každý potomek základní třídy má atribut nazev.
class SNazvem(type):
def __new__(mcs, jmeno, predci, prostor):
if predci and "nazev" not in prostor:
raise TypeError(f"třída {jmeno} musí mít atribut nazev")
return super().__new__(mcs, jmeno, predci, prostor)
class Modul(metaclass=SNazvem):
pass
class Faktury(Modul):
nazev = "faktury"
print(type(Faktury).__name__, Faktury.nazev)
class Sklad(Modul):
pass
SNazvem faktury
Chyba přišla už při definici třídy, ne až někde za běhu. Jenže metatřída je těžký nástroj: každý potomek ji zdědí a dvě různé metatřídy se spolu špatně snášejí. Skoro vždy stačí háček __init_subclass__. Python ho zavolá na předkovi pokaždé, když vznikne potomek.
class Modul:
registr = {}
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
if "nazev" not in cls.__dict__:
raise TypeError(f"třída {cls.__name__} musí mít atribut nazev")
Modul.registr[cls.nazev] = cls
class Faktury(Modul):
nazev = "faktury"
class Sklad(Modul):
nazev = "sklad"
print(Modul.registr)
print(type(Faktury).__name__)
class Rozbity(Modul):
pass
{'faktury': <class '__main__.Faktury'>, 'sklad': <class '__main__.Sklad'>}
typeStejný výsledek, žádná metatřída a type(Faktury) zůstává type. Postupuj podle tohoto žebříčku a zastav se na první příčce, která stačí:
1. obyčejná funkce nebo dědičnost
2. dekorátor třídy
3. __set_name__ a __init_subclass__
4. metatřída, jen když potřebuješ __prepare__, __call__
nebo operátory přímo na tříděPoslední příčka je to, co umí jen metatřída: chování samotné třídy. Proto jde iterovat přes Enum a volat na něm len. Metody metatřídy jsou pro třídu tím, čím jsou metody třídy pro instanci.
class Vycet(type):
def __iter__(cls):
return (v for k, v in vars(cls).items() if k.isupper())
def __len__(cls):
return sum(1 for _ in cls)
class Barvy(metaclass=Vycet):
CERNA = "#0a0a0a"
SLONOVINA = "#f2efe9"
print(list(Barvy))
print(len(Barvy))
['#0a0a0a', '#f2efe9'] 2
Registr exportérů
Doplň třídu Exporter tak, aby se každý potomek sám zapsal do slovníku Exporter.registr pod příponou zadanou v hlavičce třídy: class Csv(Exporter, pripona="csv"). Když je přípona už obsazená, vyvolej ValueError. Použij __init_subclass__, metatřídu k tomu nepotřebuješ.
class Exporter:
registr = {}
Všechno dohromady: malé ORM
Knihovny jako SQLAlchemy nebo Django dovolují popsat tabulku třídou. Základ jde napsat na pár řádcích: deskriptor hlídá typ každého pole a __init_subclass__ si pole posbírá. Pořadí vychází správně, protože __set_name__ proběhne dřív než __init_subclass__.
class Pole:
def __init__(self, typ):
self.typ = typ
def __set_name__(self, owner, name):
self.jmeno = name
def __get__(self, instance, owner=None):
return self if instance is None else instance.__dict__[self.jmeno]
def __set__(self, instance, hodnota):
if not isinstance(hodnota, self.typ):
raise TypeError(f"{self.jmeno}: čekám {self.typ.__name__}")
instance.__dict__[self.jmeno] = hodnota
class Model:
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
cls.pole = [h for h in vars(cls).values() if isinstance(h, Pole)]
def __init__(self, **hodnoty):
for p in self.pole:
setattr(self, p.jmeno, hodnoty[p.jmeno])
@classmethod
def sql(cls):
sloupce = ", ".join(p.jmeno for p in cls.pole)
return f"SELECT {sloupce} FROM {cls.__name__.lower()}"
class Zakaznik(Model):
jmeno = Pole(str)
vek = Pole(int)
z = Zakaznik(jmeno="Ada", vek=36)
print(z.jmeno, z.vek)
print(Zakaznik.sql())
Zakaznik(jmeno="Linus", vek="hodně")
Ada 36 SELECT jmeno, vek FROM zakaznik
Chceš, aby se každý potomek třídy automaticky zaregistroval. Co zvolíš jako první?
__init_subclass__ běží při vzniku každého potomka a nepřináší problémy metatříd. Deskriptor se váže k atributu, ne ke vzniku podtřídy.
Proč rex.stekni() dostane rex jako self?
Funkce leží jen ve třídě. Čtení přes instanci vyrobí vázanou metodu, která má __self__ a __func__.
Pod kapotou · přesné pořadí při vzniku třídy
type.__new__ uvnitř sebe volá __set_name__ a potom __init_subclass__. Metoda __init__ metatřídy proto běží až nakonec a vidí třídu hotovou. Volání Trida() je ve skutečnosti type(Trida).__call__(Trida), takže přepsání Meta.__call__ ovládá vznik instancí, včetně toho, jestli se __init__ vůbec zavolá.
class Stopar:
def __set_name__(self, owner, name):
print("4 __set_name__", name)
class Meta(type):
@classmethod
def __prepare__(mcs, name, bases):
print("1 __prepare__")
return {}
def __new__(mcs, name, bases, ns):
print("3 Meta.__new__ začíná")
cls = super().__new__(mcs, name, bases, ns)
print("6 Meta.__new__ končí")
return cls
def __init__(cls, name, bases, ns):
print("7 Meta.__init__")
super().__init__(name, bases, ns)
def __call__(cls, *args):
print("8 Meta.__call__")
return super().__call__(*args)
class Zaklad:
def __init_subclass__(cls):
print("5 __init_subclass__")
class Vec(Zaklad, metaclass=Meta):
print("2 tělo třídy")
a = Stopar()
Vec()
1 __prepare__ 2 tělo třídy 3 Meta.__new__ začíná 4 __set_name__ a 5 __init_subclass__ 6 Meta.__new__ končí 7 Meta.__init__ 8 Meta.__call__
Od Pythonu 3.12 se výjimka z __set_name__ už nebalí do RuntimeError, projde beze změny a kontext je v poznámce (PEP 678).
__prepare__ může vrátit vlastní mapování a sledovat tak tělo třídy zevnitř. Takhle enum hlídá duplicitní členy. Následující metatřída odhalí metodu definovanou dvakrát, což je chyba, kterou Python jinak tiše spolkne.
class BezDuplicit(dict):
def __setitem__(self, klic, hodnota):
if klic in self and not klic.startswith("__"):
raise TypeError(f"{klic} je ve třídě definováno dvakrát")
super().__setitem__(klic, hodnota)
class Prisna(type):
@classmethod
def __prepare__(mcs, name, bases):
return BezDuplicit()
class Api(metaclass=Prisna):
def nacti(self):
return 1
print("první nacti prošlo")
def nacti(self):
return 2
první nacti prošlo
Pod kapotou · pasti v produkci
Speciální metody se hledají na typu. Implicitní volání jako len(x) obchází slovník instance i __getattribute__, jednak kvůli rychlosti, jednak aby hash(Trida) nezavolal metodu určenou pro instance.
__getattr__ maskuje chyby. AttributeError vyhozený uvnitř property nebo __get__ způsobí, že Python zkusí __getattr__. Skutečná chyba zmizí a dostaneš nesmyslnou hodnotu, typicky u proxy objektů.
Konflikt metatříd. Metatřída potomka musí být podtřídou metatříd všech předků. Narazíš na to třeba při kombinaci ABC (metatřída ABCMeta) s třídou z frameworku s vlastní metatřídou. Řešením je společný potomek obou metatříd, a právě proto je __init_subclass__ tak příjemný.
class Krabice:
def __len__(self):
return 1
k = Krabice()
k.__len__ = lambda: 99
print(len(k), k.__len__())
class Ucet:
@property
def zustatek(self):
return self._data.preklep
def __init__(self):
self._data = {}
def __getattr__(self, jmeno):
return f"náhrada za {jmeno}"
print(Ucet().zustatek)
class MetaA(type):
pass
class MetaB(type):
pass
class A(metaclass=MetaA):
pass
class B(metaclass=MetaB):
pass
class C(A, B):
pass
1 99 náhrada za zustatek
Algoritmus čtení je v object.__getattribute__ (v C _PyObject_GenericGetAttrWithDict). Nejdřív _PyType_Lookup projde MRO a výsledek si drží v cache podle verze typu. Proto je změna třídy za běhu dražší, než vypadá: zneplatní cache i specializované instrukce interpretu.
Sloty jsou deskriptory. __slots__ = ("x",) vytvoří ve třídě member_descriptor, tedy datový deskriptor nad pevnou pozicí v objektu. classmethod, staticmethod i property jsou také deskriptory. Objekty bez __dict__ nemůžou použít ukládání z této lekce ani cached_property. Mají-li slot __weakref__, pomůže WeakKeyDictionary v deskriptoru. Klíčování podle id(instance) je chyba, protože id se po zániku objektu recykluje.
cached_property od 3.12 nepoužívá zámek. Starý zámek sdílely všechny instance třídy a brzdil vícevláknové aplikace. Výpočet teď může proběhnout souběžně vícekrát, takže pokud to vadí, zamkni si ho sám.
Kde to najdeš: abc.ABCMeta, enum.EnumType, ModelBase v Djangu a ModelMetaclass v pydanticu jsou metatřídy, InstrumentedAttribute v SQLAlchemy je deskriptor.