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.
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 changeAž 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)
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:
objekt -> Tezka -> Zasilka -> objectPython 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())
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())
Iva 5000 130
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ň
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))
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.
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()?
Hledání začíná vždy od skutečné třídy objektu, ne od třídy, ve které je řádek napsaný.
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á?
Zasilka
/ \
Krehka Expres
\ /
KrehkyExpresclass 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__])
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())
{'adresat': 'Eva', 'vaha_kg': 2}Spolupráce přes super
Základní třída Text vrací slovo obsah. Napiš potomky:
Hvezdy: vezme výsledek zsuper().text()a obalí ho hvězdičkami,*...*Hlasite: vezme výsledek zsuper().text(), převede ho na velká písmena a přidá!HvezdyHlasite(Hvezdy, Hlasite)aHlasiteHvezdy(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
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?
MRO je C, A, B, Z, object. super() jde na další položku v MRO objektu, a to je B.
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__)
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)
{'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.