0 dní v řadě · 0 bodů

Objekty · 26 min

Dědičnost, super a MRO

Jak nová třída převezme a upraví chování jiné. Přepisování metod, super, isinstance, více rodičů a pořadí, ve kterém Python hledá.

Hloubka
Úkoly
Lidsky řečeno

Recept na bábovku začíná větou „jako základní těsto, ale přidej kakao“. Autor nemusí znovu vypisovat mouku a vejce. A když se změní základní recept, změní se i všechny, které z něj vycházejí. Přesně tak funguje dědičnost: nová třída říká „jako tamta, ale s touhle změnou“. Má to i stinnou stránku. Pokazíš základní těsto a pokazíš všechny bábovky.

Skoro stejné třídy

Přepravní firma vozí běžné zásilky. Pak přibudou křehké, které stojí o 40 Kč víc. První nápad je zkopírovat třídu a změnit jeden řádek.

python
class Zasilka:
    def __init__(self, adresat, vaha_kg):
        self.adresat = adresat
        self.vaha_kg = vaha_kg

    def cena(self):
        return 50 + self.vaha_kg * 30

class KrehkaZasilka:
    def __init__(self, adresat, vaha_kg):   # the same again
        self.adresat = adresat
        self.vaha_kg = vaha_kg

    def cena(self):
        return 50 + self.vaha_kg * 30 + 40  # one small change

Až se základní sazba změní, musíš ji opravit na dvou místech. Za rok jich bude pět a na jedno zapomeneš. Dědičnost umožní napsat jen ten rozdíl.

Potomek přebírá všechno

Jméno třídy v závorce za class určí rodiče. Nová třída je jeho potomek a umí všechno, co rodič.

class Zasilka:
    sazba_za_kg = 30

    def __init__(self, adresat, vaha_kg):
        self.adresat = adresat
        self.vaha_kg = vaha_kg

    def cena(self):
        return 50 + self.vaha_kg * self.sazba_za_kg

class Tezka(Zasilka):
    sazba_za_kg = 45

class Obycejna(Zasilka):
    pass

print(Obycejna("Eva", 2).cena())
print(Tezka("Ota", 2).cena())
print(Tezka("Ota", 2).adresat)
Výstup
110
140
Ota

Tezka nemá vlastní __init__ ani cena, a přesto je používá. Hledání atributu z minulé lekce se jen prodloužilo:

text
objekt  ->  Tezka  ->  Zasilka  ->  object

Python jde zleva a vezme první nález. sazba_za_kg najde už v Tezka, cena až v Zasilka. Na konci řady je vždy vestavěná třída object, předek všech tříd.

Přepsání metody a super

Když potomek definuje metodu se stejným jménem, jeho verze má přednost. Říká se tomu přepsání. Často nechceš rodiče úplně nahradit, jen k jeho výsledku něco přidat. Na to je super(): dává přístup k verzi, která je v řadě další.

class Zasilka:
    def __init__(self, adresat, vaha_kg):
        self.adresat = adresat
        self.vaha_kg = vaha_kg

    def cena(self):
        return 50 + self.vaha_kg * 30

    def stitek(self):
        return f"{self.adresat}: {self.vaha_kg} kg, {self.cena()} Kč"

class Krehka(Zasilka):
    def cena(self):
        return super().cena() + 40

print(Zasilka("Eva", 2).stitek())
print(Krehka("Ota", 2).stitek())
Výstup
Eva: 2 kg, 110 Kč
Ota: 2 kg, 150 Kč

Tohle je nejdůležitější místo lekce. stitek je napsaný v rodiči a o křehkých zásilkách nic neví. Přesto u Krehka ukázal vyšší cenu. Volá totiž self.cena() a self je křehká zásilka, takže hledání začne u ní. Rodič tak může určit postup a potomci jen doplní jednotlivé kroky.

Stejně se řeší __init__. Když potomek potřebuje další údaj, napíše vlastní __init__ a o zbytek požádá rodiče.

class Zasilka:
    def __init__(self, adresat, vaha_kg):
        self.adresat = adresat
        self.vaha_kg = vaha_kg

    def cena(self):
        return 50 + self.vaha_kg * 30

class Pojistena(Zasilka):
    def __init__(self, adresat, vaha_kg, hodnota):
        super().__init__(adresat, vaha_kg)
        self.hodnota = hodnota

    def cena(self):
        return super().cena() + self.hodnota // 100

zasilka = Pojistena("Iva", 1, 5000)
print(zasilka.adresat, zasilka.hodnota)
print(zasilka.cena())
Výstup
Iva 5000
130
Úkol

Roční tarif se slevou

Třída Tarif je hotová. Napiš jejího potomka RocniTarif, který při vytvoření dostane navíc sleva_procent. Přepiš cena_za_rok tak, aby použila cenu rodiče a odečetla z ní slevu. Tarif za 100 Kč měsíčně se slevou 10 % stojí 1080 Kč za rok.

class Tarif:
    def __init__(self, nazev, mesicne):
        self.nazev = nazev
        self.mesicne = mesicne

    def cena_za_rok(self):
        return self.mesicne * 12

class RocniTarif(Tarif):
    pass  # doplň
Výstup

Je to druh: isinstance

Instance potomka je zároveň instancí rodiče. Díky tomu můžeš různé zásilky zpracovávat jedním kódem a nepotřebuješ žádné if podle typu. Každý objekt sám ví, jak spočítat svou cenu. Tomu se říká polymorfismus.

class Zasilka:
    def cena(self):
        return 100

class Krehka(Zasilka):
    def cena(self):
        return super().cena() + 40

class Expres(Zasilka):
    def cena(self):
        return super().cena() * 2

naklad = [Zasilka(), Krehka(), Expres()]
print(sum(z.cena() for z in naklad))

k = Krehka()
print(isinstance(k, Krehka), isinstance(k, Zasilka), isinstance(k, object))
print(type(k) is Zasilka)
print(issubclass(Krehka, Zasilka), issubclass(Zasilka, Krehka))

print(isinstance(True, int), True + True)
print(issubclass(KeyError, LookupError))
Výstup
440
True True True
False
True False
True 2
True

Poslední dva řádky ukazují dědičnost přímo v Pythonu. bool je potomek int, proto jde True sčítat. A except LookupError chytí KeyError i IndexError, protože jsou to jeho potomci.

isinstance je obvykle lepší než type(x) is Y, protože počítá s potomky. Když ale v kódu vidíš dlouhou řadu if isinstance(...), nejspíš tam patří metoda, kterou si každá třída přepíše po svém.

Kvíz

stitek() je definovaný v Zasilka a volá self.cena(). Potomek Krehka přepsal jen cena. Která cena se použije u Krehka("Ota", 2).stitek()?

Více rodičů a MRO

Třída může mít rodičů několik. Zásilka může být křehká i expresní. Tady vzniká otázka: v jakém pořadí se hledá?

text
        Zasilka
        /     \
    Krehka   Expres
        \     /
     KrehkyExpres
class Zasilka:
    def cena(self):
        print("Zasilka")
        return 100

class Krehka(Zasilka):
    def cena(self):
        print("Krehka")
        return super().cena() + 40

class Expres(Zasilka):
    def cena(self):
        print("Expres")
        return super().cena() + 60

class KrehkyExpres(Krehka, Expres):
    pass

print(KrehkyExpres().cena())
print([t.__name__ for t in KrehkyExpres.__mro__])
Výstup
Krehka
Expres
Zasilka
200
['KrehkyExpres', 'Krehka', 'Expres', 'Zasilka', 'object']

Pořadí se jmenuje MRO (method resolution order, pořadí hledání metod) a je uložené v atributu __mro__. Platí dvě pravidla: potomek je vždy před svými rodiči a rodiče jdou v pořadí, v jakém jsou napsaní v závorce.

Teď to překvapivé: super() v Krehka zavolal Expres, přestože Expres není rodič Krehka a ta o něm nic neví. super() neznamená „můj rodič“, ale „další v MRO skutečného objektu“. Díky tomu proběhla každá třída právě jednou a Zasilka se nezapočítala dvakrát.

Nejbezpečnější použití více rodičů je mixin: malá třída bez vlastního __init__, která přidá jednu schopnost.

class SlovnikMixin:
    def jako_slovnik(self):
        return dict(vars(self))

class Zasilka:
    def __init__(self, adresat, vaha_kg):
        self.adresat = adresat
        self.vaha_kg = vaha_kg

class ExportovatelnaZasilka(SlovnikMixin, Zasilka):
    pass

print(ExportovatelnaZasilka("Eva", 2).jako_slovnik())
Výstup
{'adresat': 'Eva', 'vaha_kg': 2}
Úkol

Spolupráce přes super

Základní třída Text vrací slovo obsah. Napiš potomky:

  • Hvezdy: vezme výsledek z super().text() a obalí ho hvězdičkami, *...*
  • Hlasite: vezme výsledek z super().text(), převede ho na velká písmena a přidá !
  • HvezdyHlasite(Hvezdy, Hlasite) a HlasiteHvezdy(Hlasite, Hvezdy) bez vlastního obsahu

První má vracet *OBSAH!* a druhá *OBSAH*!.

class Text:
    def text(self):
        return "obsah"

# doplň čtyři třídy
Výstup
Kvíz

class C(A, B), přičemž A i B dědí ze Z. Na co ukáže super() uvnitř metody třídy A, když voláš přes instanci C?

Pod kapotou · C3, nulový super a kooperativní __init__

C3 linearizace. MRO třídy je třída sama, za ní sloučení MRO všech rodičů a seznamu rodičů. Ze slučovaných seznamů se bere první hlava, která není v ocasu žádného jiného seznamu. Výsledek zachovává lokální pořadí i monotonii, tedy pořadí z rodiče se v potomkovi nepřehází. Když takové pořadí neexistuje, třída vůbec nevznikne.

Nulový super(). Překladač u metody, která používá super nebo __class__, vytvoří buňku __class__. super() je pak super(__class__, prvni_argument). První argument se bere z rámce volající funkce, proto v generátorovém výrazu selže: jeho prvním argumentem je iterátor. V list comprehension to od 3.12 díky PEP 709 funguje, ve starších verzích ne.

class A: pass
class B: pass
class X(A, B): pass
class Y(B, A): pass

try:
    class Z(X, Y): pass
except TypeError as e:
    print(e)

class Rodic:
    def cena(self):
        return 1

class Dite(Rodic):
    def v_seznamu(self):
        return [super().cena() for _ in range(2)]

    def v_generatoru(self):
        return list(super().cena() for _ in range(2))

print(Dite().v_seznamu())
try:
    Dite().v_generatoru()
except TypeError as e:
    print(type(e).__name__)
Výstup
Cannot create a consistent method resolution
order (MRO) for bases A, B
[1, 1]
TypeError

Kooperativní __init__. Rodiče v diamantu neznají další článek, takže neznají ani jeho signaturu. Vzor: každá třída si vezme své pojmenované argumenty a zbytek pošle dál. object.__init__ nakonec odmítne cokoli, co nikdo nepřevzal, takže překlep v názvu argumentu se projeví.

class SAdresou:
    def __init__(self, adresat, **zbytek):
        super().__init__(**zbytek)
        self.adresat = adresat

class SVahou:
    def __init__(self, vaha_kg, **zbytek):
        super().__init__(**zbytek)
        self.vaha_kg = vaha_kg

class Balik(SAdresou, SVahou):
    pass

print(vars(Balik(adresat="Eva", vaha_kg=2)))

try:
    Balik(adresat="Eva", vaha_kg=2, barva="modrá")
except TypeError as e:
    print(e)
Výstup
{'vaha_kg': 2, 'adresat': 'Eva'}
object.__init__() takes exactly one argument (the instance to initialize)

Produkční pasti. Rodičovský __init__, který volá přepisovatelnou metodu, ji spustí dřív, než potomek nastavil své atributy, a výsledkem je AttributeError nebo výpočet z nehotového stavu. Vestavěné typy s vlastním rozložením v paměti nejde kombinovat: class X(int, str) skončí chybou multiple bases have instance lay-out conflict. Místo metatřídy často stačí __init_subclass__ (PEP 487), hodí se třeba pro registraci potomků. Na jemnější chování potomků vestavěných typů se podívá další lekce.

Vyzkoušej si: Pořadí hledání metod

Vyber ukázkovou hierarchii tříd a sleduj výpočet pořadí MRO krok za krokem, včetně případu, který Python odmítne.