Lidsky řečeno
Jsou dva způsoby, jak shánět řidiče. Dopravní firma má stanovy: kdo chce být její řidič, musí do firmy vstoupit a splnit všechno, co stanovy říkají. To je abstraktní třída. Soused dá na plot inzerát: „Hledám někoho, kdo umí řídit dodávku.“ Nezajímá ho, kde pracuješ. Stačí, že to umíš. To je Protocol.
Kachní typování a kde bolí
Python se u volání metody neptá, jakého typu objekt je. Zkusí metodu zavolat a uvidí. Říká se tomu kachní typování: co chodí jako kachna a kváká jako kachna, to se bere jako kachna.
Je to pohodlné, dokud někdo nepřinese kachnu, která kvákat neumí. Tady upozornění odejde dvěma kanály a na třetím program spadne.
class Email:
def posli(self, komu, text):
return f"e-mail pro {komu}: {text}"
class Sms:
def posli(self, komu, text):
return f"SMS pro {komu}: {text}"
class Holub:
def odnes(self, komu, text):
return f"holub letí za {komu}: {text}"
def upozorni(kanaly, komu, text):
for kanal in kanaly:
print(kanal.posli(komu, text))
upozorni([Email(), Sms(), Holub()], "Eva", "Balík dorazil.")
e-mail pro Eva: Balík dorazil. SMS pro Eva: Balík dorazil.
Chyba se objeví až při prvním použití. Může to být ve tři ráno, uprostřed rozeslané dávky, kdy půlka lidí zprávu dostala a půlka ne. Chtěl bys ji zjistit dřív. K tomu jsou tu dva nástroje.
ABC: smlouva hlídaná za běhu
Abstraktní třída (abstract base class, ABC) popisuje, co musí potomci umět. Metoda označená @abstractmethod je povinná. Dokud ji potomek nenapíše, nejde z něj vytvořit objekt. Chyba tak přijde už při vzniku objektu, ne až při použití.
from abc import ABC, abstractmethod
class Kanal(ABC):
@abstractmethod
def posli(self, komu, text):
"""Odešle zprávu a vrátí potvrzení."""
class Email(Kanal):
def posli(self, komu, text):
return f"e-mail pro {komu}: {text}"
class Holub(Kanal):
def odnes(self, komu, text):
return f"holub letí za {komu}: {text}"
print(Email().posli("Eva", "Ahoj"))
for trida in (Kanal, Holub):
try:
trida()
except TypeError as e:
print(e)
e-mail pro Eva: Ahoj Can't instantiate abstract class Kanal without an implementation for abstract method 'posli' Can't instantiate abstract class Holub without an implementation for abstract method 'posli'
Abstraktní třída může obsahovat i hotový kód. Společný postup napíšeš jednou a potomci doplní jen to, čím se liší. Metoda oznam níže neví, jak se zpráva posílá, ví jen, že to každý potomek umět musí.
from abc import ABC, abstractmethod
class Kanal(ABC):
@property
@abstractmethod
def nazev(self):
"""Krátký název kanálu."""
@abstractmethod
def posli(self, komu, text):
"""Odešle zprávu."""
def oznam(self, lide, text):
for komu in lide:
self.posli(komu, text)
return f"{self.nazev}: odesláno {len(lide)}"
class Sms(Kanal):
nazev = "SMS"
def posli(self, komu, text):
print(f"SMS pro {komu}: {text[:10]}")
print(Sms().oznam(["Eva", "Jan"], "Balík dorazil."))
SMS pro Eva: Balík dora SMS pro Jan: Balík dora SMS: odesláno 2
Tenhle vzor má jméno šablonová metoda. Povinný může být i atribut: stačí zapsat @property nad @abstractmethod, v tomto pořadí. Potomkovi pak stačí obyčejný atribut třídy.
Abstraktní tvar
Vytvoř abstraktní třídu Tvar s abstraktní metodou obsah() a hotovou metodou popis(), která vrátí text obsah: X, kde X je výsledek obsah(). Potom napiš potomky Ctverec(strana) a Obdelnik(sirka, vyska).
from abc import ABC, abstractmethod
class Tvar:
def obsah(self):
pass
# doplň
Hotové ABC ve standardní knihovně
Modul collections.abc obsahuje abstraktní třídy pro kontejnery. Navazují na speciální metody z lekce Speciální metody a datový model. Napíšeš pár povinných metod a zbytek dostaneš hotový. Mapping chce tři, a přidá get, keys, items, values, in i ==.
from collections.abc import Mapping
class Cenik(Mapping):
"""Slovník jen pro čtení, u kterého nezáleží na velikosti písmen."""
def __init__(self, ceny):
self._ceny = {nazev.lower(): cena for nazev, cena in ceny.items()}
def __getitem__(self, nazev):
return self._ceny[nazev.lower()]
def __iter__(self):
return iter(self._ceny)
def __len__(self):
return len(self._ceny)
c = Cenik({"Káva": 65, "Dort": 120})
print(c["KÁVA"])
print("dort" in c)
print(c.get("čaj", "není"))
print(sorted(c.items()))
print(c == {"káva": 65, "dort": 120})
65
True
není
[('dort', 120), ('káva', 65)]
TrueStejné třídy poslouží i k dotazu, co objekt umí. Tady se projeví zvláštnost: třída Sized pozná každý objekt s metodou __len__, i když z ní nedědí.
from collections.abc import Iterable, Mapping, Sequence, Sized
class Krabice:
def __len__(self):
return 3
print(isinstance([1, 2], Sequence))
print(isinstance({}, Sequence), isinstance({}, Mapping))
print(isinstance("text", Iterable))
print(isinstance(Krabice(), Sized))
print(issubclass(Krabice, Sized))
True False True True True True
Sudá čísla jako posloupnost
Napiš třídu SudaCisla(Sequence). SudaCisla(4) se má chovat jako posloupnost 0, 2, 4, 6, ale nesmí si čísla ukládat. Napiš jen __init__, __len__ a __getitem__. Metoda __getitem__ zvládne záporný index a mimo rozsah vyhodí IndexError. Cyklus, in, index a reversed dostaneš od Sequence.
from collections.abc import Sequence
class SudaCisla(Sequence):
def __init__(self, pocet):
self.pocet = pocet
# doplň __len__ a __getitem__
Co se stane při Holub(), když Holub dědí z abstraktní třídy a nenapsal její abstraktní metodu?
Kontrola proběhne při vzniku instance. Samotná definice třídy Holub ještě chybu nevyvolá.
Protocol: stačí to umět
ABC má jednu podmínku: třída z ní musí dědit. To nejde u kódu, který ti nepatří, třeba u třídy z cizí knihovny. A taky to svazuje: kvůli jedné metodě musí každý znát tvůj modul.
typing.Protocol jde jinudy. Popíšeš, jaké metody potřebuješ, a každá třída, která je má, vyhovuje automaticky. Bez dědění, bez registrace. Tři tečky ... v těle znamenají „tady žádný kód není“.
from typing import Protocol
class Odesilatel(Protocol):
def posli(self, komu: str, text: str) -> str: ...
class Email:
def posli(self, komu: str, text: str) -> str:
return f"e-mail pro {komu}: {text}"
class Sms:
def posli(self, komu: str, text: str) -> str:
return f"SMS pro {komu}: {text}"
def upozorni(kanal: Odesilatel, komu: str, text: str) -> None:
print(kanal.posli(komu, text))
upozorni(Email(), "Eva", "Ahoj")
upozorni(Sms(), "Jan", "Čau")
e-mail pro Eva: Ahoj SMS pro Jan: Čau
Háček: za běhu Python protokol nekontroluje. Anotace ignoruje stejně jako jinde. Holub by program shodil úplně stejně jako na začátku lekce. Protokol ožije až s nástrojem pro typovou kontrolu, například mypy, který projde kód ještě před spuštěním. Na upozorni(Holub(), "Eva", "Ahoj") odpoví zhruba takto:
error: Argument 1 to "upozorni" has incompatible type "Holub"; expected "Odesilatel" [arg-type]
note: "Holub" is missing following "Odesilatel" protocol member:
note: posliChybu tak vidíš v editoru nebo v CI, dřív, než kód vůbec poběží. Nastavení popisuje lekce Ruff, mypy a pre-commit.
Protokol vynikne u věcí, které ti nepatří. Tahle funkce chce jen něco s metodou read. Vyhoví jí otevřený soubor i io.StringIO ze standardní knihovny, a ani jeden o tvém protokolu nikdy neslyšel.
import io
from typing import Protocol
class Citelne(Protocol):
def read(self) -> str: ...
def pocet_radku(zdroj: Citelne) -> int:
return len(zdroj.read().splitlines())
print(pocet_radku(io.StringIO("první\ndruhý\ntřetí")))
3
Když chceš protokol použít i v isinstance, přidej dekorátor @runtime_checkable. Kontrola je ale hrubá: ověří jen, že atribut toho jména existuje. Parametry ani to, jestli jde vůbec o metodu, nezkoumá.
from typing import Protocol, runtime_checkable
@runtime_checkable
class Odesilatel(Protocol):
def posli(self, komu: str, text: str) -> str: ...
class Email:
def posli(self, komu, text):
return "ok"
class Holub:
def odnes(self, komu, text):
return "letím"
class Podvodnik:
posli = "nejsem metoda"
print(isinstance(Email(), Odesilatel))
print(isinstance(Holub(), Odesilatel))
print(isinstance(Podvodnik(), Odesilatel))
True False True
Cokoli s cenou
Vytvoř protokol SCenou s metodou cena() vracející celé číslo a označ ho @runtime_checkable. Napiš třídy Produkt(cena_kc) a Sluzba(hodiny, sazba), které z protokolu nedědí, ale metodu cena() mají. Funkce celkem(polozky) sečte ceny.
from typing import Protocol, runtime_checkable
class SCenou:
pass
# doplň Produkt, Sluzba a celkem
Kdy co použít
| Situace | Volba |
|---|---|
| Jedna implementace a žádný výhled na další | žádná abstrakce, obyčejná třída nebo funkce |
| Tvoje rodina tříd se společným kódem | ABC |
| Chyba musí vyskočit i bez typové kontroly | ABC |
| Funkce potřebuje jednu dvě metody od kohokoli | Protocol |
| Objekty z cizích knihoven, které nemůžeš změnit | Protocol |
| Vlastní kontejner | collections.abc |
Protokol navíc patří tam, kde se používá. Funkce si řekne, co od argumentu potřebuje, a nepožaduje nic navíc. ABC naopak patří k tomu, kdo implementace poskytuje. Obě cesty jde spojit, ale většinou stačí jedna. A abstrakci nepřidávej předem: u jediné implementace je to jen další soubor ke čtení. Víc o tom v lekci Návrh: SOLID bez dogmat.
Co udělá Python za běhu, když funkci s parametrem typu Protocol předáš objekt bez potřebné metody?
Anotace se za běhu nekontrolují. Upozorní tě až typová kontrola před spuštěním, nebo AttributeError při použití.
Máš třídu z cizí knihovny, kterou nemůžeš upravit, a její metoda read ti vyhovuje. Co je nejpřirozenější?
Protokol je strukturální. Cizí třída vyhovuje jen tím, že metodu má.
Pod kapotou · co ABC opravdu kontroluje
ABCMeta při vzniku třídy spočítá __abstractmethods__ a nastaví příznak typu. Kontrolu pak dělá object.__new__. Z toho plynou mezery, které je dobré znát:
- Hlídá se jen jméno. Podpis ne, a stačí libovolný atribut, třeba
posli = None. - Vestavěný typ s vlastním
__new__(napříkladlist) se kobject.__new__nedostane, takže kontrola neproběhne vůbec. registerudělá z třídy virtuálního potomka bez jakékoli kontroly.
from abc import ABC, abstractmethod
class Kanal(ABC):
@abstractmethod
def posli(self, komu, text): ...
class Lenoch(Kanal):
posli = None
print(Lenoch().posli)
class SeznamKanal(list, Kanal):
pass
print(SeznamKanal())
class Holub:
pass
Kanal.register(Holub)
print(isinstance(Holub(), Kanal), hasattr(Holub(), "posli"))
print(sorted(Kanal.__abstractmethods__))
None [] True False ['posli']
Tělo abstraktní metody není mrtvé, potomek ho může zavolat přes super(). Dekorátory se skládají s @abstractmethod vždy jako nejvnitřnějším. Přidáš-li abstraktní metodu třídě dodatečně, je potřeba abc.update_abstractmethods. isinstance(x, Sized) funguje bez dědění díky háku __subclasshook__ a výsledky se kešují ve slabých množinách na třídě. Protože ABC používá metatřídu, kombinace s jinou metatřídou (některé ORM a Qt) skončí konfliktem, který se řeší společnou podtřídou metatříd. Návrh popisuje PEP 3119.
Pod kapotou · Protocol v praxi: co typová kontrola opravdu vyžaduje
Podle PEP 544 je shoda strukturální, ale přísnější, než čekáš:
- Jména parametrů se počítají.
def posli(self, prijemce, zprava)protokolu skomu, textnevyhoví, protože volající smí použít pojmenované argumenty. Řešení je v protokolu poziční parametry:def posli(self, komu: str, text: str, /) -> str: .... - Měnitelný atribut je invariantní. Protokol s
jmeno: strvyžaduje i zápis, takže@propertynebofrozendataclass mu nevyhoví. Když stačí čtení, napiš v protokolu@property def jmeno(self) -> str: .... - Podtřída protokolu zůstane protokolem, jen když má
Protocolznovu mezi předky. Jinak je to běžná třída. - Explicitní dědění z protokolu je povolené a přinese případné výchozí implementace.
Runtime část je slabší. isinstance s protokolem prochází členy a je znatelně pomalejší než běžné isinstance, takže do horké smyčky nepatří. Od verze 3.12 používá inspect.getattr_static, takže nespouští property ani __getattr__. Dynamické atributy proto nevidí. Protokol s datovými členy nepodporuje issubclass.
from typing import Protocol, runtime_checkable
@runtime_checkable
class MaJmeno(Protocol):
jmeno: str
class Draha:
@property
def jmeno(self):
print("spouštím drahý dotaz")
return "Eva"
class Dynamicka:
def __getattr__(self, nazev):
return "cokoli"
print(isinstance(Draha(), MaJmeno))
print(isinstance(Dynamicka(), MaJmeno))
print(Dynamicka().jmeno)
try:
issubclass(Draha, MaJmeno)
except TypeError as e:
print(e)
True False cokoli Protocols with non-method members don't support issubclass()
Protokol s jedinou metodou __call__ je čitelnější náhrada za Callable, když záleží na jménech parametrů. Generické protokoly přijdou v lekci Pokročilé typy.