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.
Upozorneni
├── EmailProste
├── EmailFormalni
├── SmsProste
└── SmsFormalniPř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á.
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("[email protected]"), FormalniFormat()).odesli("zrnka dorazila.")
Upozorneni(Sms("+420 000 000 000"), ProstyFormat()).odesli("Zrnka dorazila.")
Upozorneni(Sms("+420 000 000 000"), FormalniFormat()).odesli("zrnka dorazila.")
[e-mail [email protected]] 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)
['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.
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ň
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())
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á.
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ň
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"))
['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:
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í.
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ň
Který vztah je vhodný pro dědičnost?
Auto motor má a objednávka položky obsahuje. Nedostatek zboží opravdu je druh výjimky a jde použít všude, kde se výjimka čeká.
Proč jde Upozorneni snadno testovat bez posílání e-mailů?
Objekt si závislost nevyrábí sám. Test mu dá náhradu, která si zprávy jen zapíše.
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())
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.