0 dní v řadě · 0 bodů

Objekty · 24 min

ABC a Protocol

Jak popsat, co musí objekt umět. Abstraktní třídy hlídají smlouvu za běhu, Protocol ji nechá ověřit typové kontrole bez dědičnosti.

Hloubka
Úkoly
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.")
Výstup
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)
Výstup
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."))
Výstup
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.

Úkol

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ň
Výstup

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})
Výstup
65
True
není
[('dort', 120), ('káva', 65)]
True

Stejné 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))
Výstup
True
False True
True
True
True
Úkol

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__
Výstup
Kvíz

Co se stane při Holub(), když Holub dědí z abstraktní třídy a nenapsal její abstraktní metodu?

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")
Výstup
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:

text
error: Argument 1 to "upozorni" has incompatible type "Holub"; expected "Odesilatel"  [arg-type]
note: "Holub" is missing following "Odesilatel" protocol member:
note:     posli

Chybu 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í")))
Výstup
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))
Výstup
True
False
True
Úkol

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
Výstup

Kdy co použít

SituaceVolba
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ódemABC
Chyba musí vyskočit i bez typové kontrolyABC
Funkce potřebuje jednu dvě metody od kohokoliProtocol
Objekty z cizích knihoven, které nemůžeš změnitProtocol
Vlastní kontejnercollections.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.

Kvíz

Co udělá Python za běhu, když funkci s parametrem typu Protocol předáš objekt bez potřebné metody?

Kvíz

Máš třídu z cizí knihovny, kterou nemůžeš upravit, a její metoda read ti vyhovuje. Co je nejpřirozenější?

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říklad list) se k object.__new__ nedostane, takže kontrola neproběhne vůbec.
  • register udě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__))
Výstup
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 s komu, text nevyhoví, 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: str vyžaduje i zápis, takže @property nebo frozen dataclass mu nevyhoví. Když stačí čtení, napiš v protokolu @property def jmeno(self) -> str: ....
  • Podtřída protokolu zůstane protokolem, jen když má Protocol znovu 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)
Výstup
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.