0 dní v řadě · 0 bodů

Python pod kapotou · 30 min

Deskriptory a metatřídy

Co se doopravdy stane při čtení atributu, jak fungují property a metody a kdo vyrábí samotné třídy.

Hloubka
Úkoly
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)
Výstup
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)
Výstup
č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
Výstup
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ětev instance is None vrací samotný deskriptor, což je zvyk pro přístup přes třídu.
  • __set__ obslouží zápis, a proto i self.cena = cena v konstruktoru prochází kontrolou.
Úkol

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)
Výstup

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:

text
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. AttributeError

Na 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__)
Výstup
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())
Výstup
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
Výstup
True
5
Kvíz

Třída má nedatový deskriptor x a instance má v __dict__ klíč x. Co vrátí obj.x?

Úkol

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()
Výstup

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())
Výstup
<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)
Výstup
tělo třídy běží
2 20
text
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řídu

Vlastní 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
Výstup
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
Výstup
{'faktury': <class '__main__.Faktury'>, 'sklad': <class '__main__.Sklad'>}
type

Stejný 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čí:

text
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))
Výstup
['#0a0a0a', '#f2efe9']
2
Úkol

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ýstup

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ě")
Výstup
Ada 36
SELECT jmeno, vek FROM zakaznik
Kvíz

Chceš, aby se každý potomek třídy automaticky zaregistroval. Co zvolíš jako první?

Kvíz

Proč rex.stekni() dostane rex jako self?

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()
Výstup
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
Výstup
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
Výstup
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.