0 dní v řadě · 0 bodů

Objekty · 24 min

Kompozice místo dědičnosti

Proč dědění někdy vede do slepé uličky a jak skládat objekty z menších dílů, které jde vyměnit, otestovat a znovu použít.

Hloubka
Úkoly
Lidsky řečeno

Můžeš si koupit zvlášť vrtačku na každý průměr vrtáku. Nebo jednu vrtačku s výměnnými nástavci. Druhá varianta je levnější, vejde se do šuplíku a nový nástavec funguje bez úprav vrtačky. Dědičnost často vede k první variantě, kompozice ke druhé: objekt nic nedědí, jen má díl, který umí potřebnou práci.

Když třídy začnou bujet

Kavárna posílá zákazníkům upozornění. Zprávy chodí e-mailem nebo přes SMS a bývají buď prosté, nebo formální. S dědičností vznikne pro každou kombinaci jedna třída.

text
Upozorneni
├── EmailProste
├── EmailFormalni
├── SmsProste
└── SmsFormalni

Přidej kanál push a formát „urgentní“ a máš 3 × 3 = 9 tříd. S každou další volbou se počet násobí, přitom logika e-mailu je kopírovaná napříč. Problém je v tom, že se tu míchají dvě nezávislé věci: kudy zpráva jde a jak vypadá.

text
dědičnost:   kanály × formáty   3 × 3 = 9 tříd
kompozice:   kanály + formáty   3 + 3 = 6 malých tříd a 1, která je spojí

Objekt, který má jiné objekty

Každou nezávislou věc dej do vlastní malé třídy. Hlavní objekt si díly jen uloží do atributů a práci jim předá. Předávání práce se říká delegování.

class Email:
    def __init__(self, adresa):
        self.adresa = adresa

    def posli(self, text):
        print(f"[e-mail {self.adresa}] {text}")

class Sms:
    def __init__(self, cislo):
        self.cislo = cislo

    def posli(self, text):
        print(f"[SMS {self.cislo}] {text[:30]}")

class ProstyFormat:
    def uprav(self, text):
        return text

class FormalniFormat:
    def uprav(self, text):
        return f"Vážený zákazníku, {text} S pozdravem, kavárna"

class Upozorneni:
    def __init__(self, kanal, formatovac):
        self.kanal = kanal
        self.formatovac = formatovac

    def odesli(self, text):
        self.kanal.posli(self.formatovac.uprav(text))

Upozorneni(Email("jana@example.com"), FormalniFormat()).odesli("zrnka dorazila.")
Upozorneni(Sms("+420 000 000 000"), ProstyFormat()).odesli("Zrnka dorazila.")
Upozorneni(Sms("+420 000 000 000"), FormalniFormat()).odesli("zrnka dorazila.")
Výstup
[e-mail jana@example.com] Vážený zákazníku, zrnka dorazila. S pozdravem, kavárna
[SMS +420 000 000 000] Zrnka dorazila.
[SMS +420 000 000 000] Vážený zákazníku, zrnka dorazi

SMS si text sama zkracuje na 30 znaků, proto je poslední zpráva useknutá. To je starost kanálu a nikdo jiný o tom vědět nemusí.

Upozorneni nezná e-mail ani SMS. Potřebuje jen, aby kanal uměl posli a formatovac uměl uprav. Žádný společný předek není nutný. Pythonu stačí, že metoda existuje, a tomu se říká duck typing: chodí to jako kachna, kváká to jako kachna, tak s tím zacházej jako s kachnou.

Díly jde měnit i předstírat

Protože díly přicházejí zvenčí, můžeš je vyměnit i za běhu. A hlavně můžeš podstrčit falešný díl, který nic neposílá a jen si zapisuje. Přesně tak se testuje kód, který by jinak rozesílal skutečné zprávy.

class Zapisnik:
    def __init__(self):
        self.zpravy = []

    def posli(self, text):
        self.zpravy.append(text)

class Krik:
    def uprav(self, text):
        return text.upper()

class Upozorneni:
    def __init__(self, kanal, formatovac):
        self.kanal = kanal
        self.formatovac = formatovac

    def odesli(self, text):
        self.kanal.posli(self.formatovac.uprav(text))

prvni, druhy = Zapisnik(), Zapisnik()
upozorneni = Upozorneni(prvni, Krik())

upozorneni.odesli("otevíráme")
upozorneni.kanal = druhy          # swap the part at runtime
upozorneni.odesli("zavíráme")

print(prvni.zpravy)
print(druhy.zpravy)
Výstup
['OTEVÍRÁME']
['ZAVÍRÁME']

Tomuhle postupu se říká předávání závislostí: objekt si své díly nevyrábí sám, dostane je. Víc o něm v lekci Mocky a testovatelný návrh.

Úkol

Kávovar s nádržkou

Napiš třídu Nadrz s atributem zbyva (počáteční objem v ml) a metodou odeber(ml). Když je vody dost, odečte ji a vrátí True, jinak nezmění nic a vrátí False.

Potom napiš Kavovar, který dostane nádrž v __init__. Metoda uvar() si z nádrže vezme 30 ml a vrátí "káva", nebo "dolij vodu", když voda nestačí. Kávovar nesmí dědit z Nadrz.

class Nadrz:
    pass  # doplň

class Kavovar:
    pass  # doplň
Výstup

Někdy stačí funkce

Když má díl jedinou metodu, můžeš místo třídy předat rovnou funkci. V Pythonu je funkce hodnota, jak ukázala lekce Funkce jako hodnoty. Vyměnitelnému pravidlu se říká strategie.

def bez_slevy(castka):
    return castka

def desetina_dolu(castka):
    return castka * 90 // 100

def padesat_nad_pet_set(castka):
    return castka - 50 if castka > 500 else castka

class Kosik:
    def __init__(self, sleva=bez_slevy):
        self.ceny = []
        self.sleva = sleva

    def pridej(self, cena):
        self.ceny.append(cena)

    def celkem(self):
        return self.sleva(sum(self.ceny))

for pravidlo in (bez_slevy, desetina_dolu, padesat_nad_pet_set):
    kosik = Kosik(pravidlo)
    kosik.pridej(400)
    kosik.pridej(200)
    print(pravidlo.__name__, kosik.celkem())
Výstup
bez_slevy 600
desetina_dolu 540
padesat_nad_pet_set 550

Nové pravidlo je jedna nová funkce. Kosik se kvůli němu nemění a žádná hierarchie slevových tříd nevzniká.

Úkol

Deník s filtrem

Napiš třídu Denik. V __init__ dostane nepovinnou funkci filtr. Metoda zapis(text) uloží text do seznamu zaznamy, jen když filtr(text) vrátí pravdu. Bez zadaného filtru se ukládá všechno. Každý deník má vlastní seznam.

class Denik:
    def __init__(self, filtr=None):
        pass  # doplň

    def zapis(self, text):
        pass  # doplň
Výstup

Je to druh, nebo to jen má?

Zásobník je struktura, kde se bere vždy naposledy vložená věc. Seznam to umí, takže láká dědit. Jenže potomek zdědí všechno.

class DedenyZasobnik(list):
    def vloz(self, vec):
        self.append(vec)

    def vyjmi(self):
        return self.pop()

class Zasobnik:
    def __init__(self):
        self._polozky = []

    def vloz(self, vec):
        self._polozky.append(vec)

    def vyjmi(self):
        return self._polozky.pop()

    def velikost(self):
        return len(self._polozky)

d = DedenyZasobnik()
d.vloz("spodní")
d.vloz("horní")
d.insert(0, "propašovaný")  # breaks the idea of a stack
d.sort()
print(d)

z = Zasobnik()
z.vloz("spodní")
z.vloz("horní")
print(z.vyjmi(), z.velikost())
print(hasattr(z, "insert"))
Výstup
['horní', 'propašovaný', 'spodní']
horní 1
False

Podtržítko v _polozky je dohoda: „tohle je vnitřní věc, zvenčí nesahej“. Víc v lekci property a zapouzdření. Zasobnik nabízí jen to, co zásobník má umět, a seznam uvnitř můžeš později vyměnit, aniž by si toho kdokoli všiml.

Než napíšeš class A(B), projdi si čtyři otázky:

text
1. Platí věta „A je druh B“ vždy, a ne jen proto, že sdílejí kus kódu?
2. Půjde A použít všude, kde se čeká B, a nic se nerozbije?
3. Chceš opravdu všechny metody B, i ty, které přibudou?
4. Je B pod tvou kontrolou, nebo aspoň stabilní, takže se nezmění pod rukama?

Čtyřikrát ano znamená, že dědičnost je v pořádku. Nejde o zákaz: vlastní výjimky, malé rodiny tříd se společným základem a třídy, které k dědění přímo vybízí framework, jsou správné případy. Jinak začni kompozicí. Z ní se na dědičnost přechází snadno, opačně to bolí.

Úkol

Fronta u pokladny

Napiš třídu Fronta, která uvnitř používá collections.deque nebo seznam a navenek nabízí jen zarad(jmeno), dalsi() a velikost(). dalsi() vrátí a odebere toho, kdo čeká nejdéle. Když je fronta prázdná, vrátí None. Neděď z deque ani z list.

from collections import deque

class Fronta:
    pass  # doplň
Výstup
Kvíz

Který vztah je vhodný pro dědičnost?

Kvíz

Proč jde Upozorneni snadno testovat bez posílání e-mailů?

Pod kapotou · křehký základ, __getattr__ a kompozice ve standardní knihovně

Křehký rodič. Potomek závisí na vnitřnostech rodiče, tedy na tom, které metody volají které. U vestavěných typů je to vidět nejlíp: C implementace dict při update ani v konstruktoru tvůj __setitem__ nevolá. collections.UserDict je napsaný v Pythonu a přes MutableMapping vede zápisy právě přes __setitem__.

from collections import UserDict

class MalaPismenaDict(dict):
    def __setitem__(self, klic, hodnota):
        super().__setitem__(klic.lower(), hodnota)

class MalaPismenaUser(UserDict):
    def __setitem__(self, klic, hodnota):
        super().__setitem__(klic.lower(), hodnota)

for trida in (MalaPismenaDict, MalaPismenaUser):
    d = trida({"A": 1})
    d.update({"B": 2})
    d["C"] = 3
    print(trida.__name__, sorted(d))

class Obal:
    def __init__(self, vnitrni):
        self._vnitrni = vnitrni

    def __getattr__(self, jmeno):
        return getattr(self._vnitrni, jmeno)

o = Obal([3, 1])
o.append(2)
print(o.count(1))
try:
    len(o)
except TypeError:
    print("len(o): TypeError")

class Pravidla:
    ve_tride = lambda *a: len(a)

p = Pravidla()
p.na_objektu = lambda *a: len(a)
print(p.ve_tride(), p.na_objektu())
Výstup
MalaPismenaDict ['A', 'B', 'c']
MalaPismenaUser ['a', 'b', 'c']
1
len(o): TypeError
1 0

Delegování přes __getattr__ ušetří přeposílací metody, ale má limity. Volá se až po neúspěšném běžném hledání a implicitní speciální metody se hledají na typu, takže len(o) nefunguje. Past: když __getattr__ čte self._vnitrni na objektu bez inicializace, což se děje třeba při copy.copy nebo pickle, vznikne nekonečná rekurze. Veřejné rozhraní navíc přestane být vidět v IDE i pro mypy. Explicitní přeposílání je delší, ale čitelnější.

Funkce uložená na instanci vs. na třídě. Poslední řádek výstupu ukazuje rozdíl. Funkce je nedatový deskriptor, takže ze třídy se naváže a dostane self, z __dict__ instance se vrátí tak, jak je. Proto self.sleva(castka) v košíku self nepředává. Přesuneš-li strategii do atributu třídy, chová se jinak: obal ji staticmethod.

Kompozice ve standardní knihovně. logging je učebnicová ukázka: Logger má Handlery (kanál) a každý Handler má Formatter (formát), tedy přesně dvě nezávislé osy z úvodu lekce. open() v textovém režimu skládá TextIOWrapper nad BufferedReader nad FileIO.

Cena kompozice. Přeposílací kód, víc malých objektů a delší cesta při čtení kódu. Vztahy rodič a dítě v obou směrech vytvářejí referenční cykly, které uklízí až cyklický garbage collector, a když si dítě nemá rodiče držet naživu, patří tam weakref. Kontrakt mezi díly je zatím jen v dokumentaci a v hlavě. Formálně ho popíše typing.Protocol v lekci ABC a Protocol.