0 dní v řadě · 0 bodů

Objekty · 40 min

Návrh: SOLID bez dogmat

Pět zásad SOLID na skutečných problémech: kdy kód rozdělit, kdy ho nechat být a jak poznat abstrakci, která stojí víc, než přináší.

Hloubka
Úkoly
Lidsky řečeno

Při rekonstrukci bytu řešíš, kam dát zásuvky. Když žádnou nedáš za gauč, budeš jednou sekat do zdi. Když jich dáš na každou stěnu dvacet, zaplatíš je a pokoj bude vypadat jako telefonní ústředna. Dobrý elektrikář se zeptá, co budeš nejspíš měnit, a zásuvky dá tam. Návrh programu je totéž: hledáš místa, kde se dá čekat změna, a jen tam si připravíš „zásuvku“.

Kód, na který se bojíš sáhnout

Špatný návrh se nepozná podle toho, že program nefunguje. Funguje. Pozná se ve chvíli, kdy ho máš změnit a nevíš, co všechno se tím rozbije.

Tady je půjčovna nářadí. Jedna metoda spočítá cenu, zapíše výpůjčku a pošle zákazníkovi zprávu. Web teď chce kalkulačku, která zákazníkovi jen ukáže cenu. Hotová metoda cenu umí, tak ji někdo prostě zavolá.

class Pujcovna:
    def __init__(self):
        self.vypujcky = []

    def vypujcit(self, jmeno, telefon, naradi, dny, tarif):
        if tarif == "bezny":
            cena = 250 * dny
        elif tarif == "vikend":
            cena = 200 * dny + 100
        elif tarif == "firma":
            cena = 250 * dny * 85 // 100
        else:
            raise ValueError(f"Neznámý tarif: {tarif}")

        self.vypujcky.append({"jmeno": jmeno, "naradi": naradi, "cena": cena})
        print(f"SMS pro {telefon}: {jmeno}, {naradi}, počet dní {dny}, cena {cena} Kč.")
        return cena


pujcovna = Pujcovna()

# Zákazník si na webu jen zkouší, kolik by to stálo.
cena = pujcovna.vypujcit("Eva", "000 000 111", "vrtačka", 3, "firma")
print("Kalkulačka ukáže:", cena)
print("Evidovaných výpůjček:", len(pujcovna.vypujcky))
Výstup
SMS pro 000 000 111: Eva, vrtačka, počet dní 3, cena 637 Kč.
Kalkulačka ukáže: 637
Evidovaných výpůjček: 1

Eva si jen zkoušela cenu. Dostala SMS a v evidenci má výpůjčku, o kterou nestála. Chyba není v jednom řádku. Chyba je v tom, že tři různé věci jsou slepené tak, že nejde použít jen jedna.

Na takové situace vznikla pětice zásad s názvem SOLID. Každé písmeno je jedna zásada:

PísmenoAnglickyLidsky
SSingle responsibilityČást kódu má jeden důvod ke změně.
OOpen/closedNový případ přidáš, aniž přepisuješ ten hotový.
LLiskov substitutionPotomek se chová tak, jak slibuje rodič.
IInterface segregationNikdo nezávisí na tom, co nepotřebuje.
DDependency inversionPravidla nezávisí na technických detailech.

Ber je jako otázky, které si položíš, když tě něco bolí. Nejsou to zákony. Na konci lekce uvidíš, kdy je správná odpověď „nech to být“.

S: jeden důvod ke změně

Tahle zásada se často špatně překládá jako „třída dělá jednu věc“. Užitečnější je se zeptat: kdo za mnou přijde a bude chtít tenhle kód změnit?

V půjčovně za tebou přijde účetní kvůli cenám, marketing kvůli textu zprávy a správce kvůli tomu, že SMS nahradí e-mail. Tři lidé, tři důvody, jedna metoda. Rozděl ji podle nich. Nemusí z toho být tři třídy. Cena i text jsou obyčejné funkce.

def cena_vypujcky(dny, tarif):
    if tarif == "bezny":
        return 250 * dny
    if tarif == "vikend":
        return 200 * dny + 100
    if tarif == "firma":
        return 250 * dny * 85 // 100
    raise ValueError(f"Neznámý tarif: {tarif}")


def text_potvrzeni(jmeno, naradi, dny, cena):
    return f"{jmeno}, {naradi}, počet dní {dny}, cena {cena} Kč."


class Evidence:
    def __init__(self):
        self.vypujcky = []

    def pridej(self, jmeno, naradi, cena):
        self.vypujcky.append({"jmeno": jmeno, "naradi": naradi, "cena": cena})


def vypujcit(evidence, jmeno, telefon, naradi, dny, tarif):
    """Jen skládá hotové části, žádné vlastní pravidlo tu není."""
    cena = cena_vypujcky(dny, tarif)
    evidence.pridej(jmeno, naradi, cena)
    print(f"SMS pro {telefon}: {text_potvrzeni(jmeno, naradi, dny, cena)}")
    return cena


evidence = Evidence()
print("Kalkulačka ukáže:", cena_vypujcky(3, "firma"))
print("Evidovaných výpůjček:", len(evidence.vypujcky))

vypujcit(evidence, "Eva", "000 000 111", "vrtačka", 3, "firma")
print("Evidovaných výpůjček:", len(evidence.vypujcky))
Výstup
Kalkulačka ukáže: 637
Evidovaných výpůjček: 0
SMS pro 000 000 111: Eva, vrtačka, počet dní 3, cena 637 Kč.
Evidovaných výpůjček: 1

Kód je o pár řádků delší, ale kalkulačka už nikomu nic neposílá. Cenu navíc vyzkoušíš jedním řádkem, bez telefonu a bez evidence.

Úkol

Rozděl vrácení nářadí

Funkce zpracuj_vraceni počítá poplatek a zároveň tiskne. Rozděl ji:

  • poplatek(dny_pozde) vrátí číslo: 50 Kč za den, nejvýš 500 Kč. Při vrácení včas nebo dřív (dny_pozde je 0 nebo záporné) vrátí 0.
  • zprava(jmeno, castka) vrátí text Eva: poplatek za pozdní vrácení 150 Kč., při nulové částce Eva: vráceno včas.
  • zpracuj_vraceni(jmeno, dny_pozde) obě použije a výsledek vytiskne.

Tisknout smí jen zpracuj_vraceni.

def zpracuj_vraceni(jmeno, dny_pozde):
    castka = min(max(dny_pozde, 0) * 50, 500)
    if castka == 0:
        print(f"{jmeno}: vráceno včas.")
    else:
        print(f"{jmeno}: poplatek za pozdní vrácení {castka} Kč.")


zpracuj_vraceni("Eva", 3)
Výstup
Kvíz

Třída Faktura má metody soucet(), dph() a do_pdf(). Co je nejsilnější důvod přesunout do_pdf jinam?

Pod kapotou · soudržnost a data z gitu

Robert C. Martin později zásadu přeformuloval: modul odpovídá jednomu aktérovi, tedy jedné skupině lidí, kteří chtějí změny. Prakticky jde o soudržnost (cohesion). Varovný signál je třída, jejíž metody se dělí na skupiny pracující s různými atributy. Metriky rodiny LCOM měří právě tohle.

Kandidáty na rozdělení nemusíš hádat. Soubory, které se mění nejčastěji, ukáže historie:

bash
git log --format= --name-only --since="1 year ago" | sort | uniq -c | sort -rn | head

Opačný extrém má také jméno: shotgun surgery. Jedna změna pak znamená úpravu deseti malých souborů. Věci, které se mění společně, mají zůstat u sebe, i když vypadají jako dvě odpovědnosti.

O: nový případ bez přepisování starého

Půjčovna chce tarif pro studenty. V cena_vypujcky přibude další if. Za měsíc další. Pokaždé sahneš do funkce, která už funguje, a pokaždé ji můžeš rozbít.

Zásada otevřeno/uzavřeno říká: kód má být otevřený pro rozšíření a uzavřený pro úpravy. V Pythonu k tomu často stačí slovník funkcí. Funkce je hodnota, takže ji jde uložit pod názvem tarifu.

def bezny(dny):
    return 250 * dny


def vikend(dny):
    return 200 * dny + 100


def firma(dny):
    return 250 * dny * 85 // 100


TARIFY = {"bezny": bezny, "vikend": vikend, "firma": firma}


def cena_vypujcky(dny, tarif):
    if tarif not in TARIFY:
        raise ValueError(f"Neznámý tarif: {tarif}")
    return TARIFY[tarif](dny)


print(cena_vypujcky(3, "firma"))


# Nový tarif. Funkce cena_vypujcky zůstala beze změny.
def student(dny):
    return 150 * dny


TARIFY["student"] = student
print(cena_vypujcky(3, "student"))
Výstup
637
450

Nová třída ani dědičnost potřeba nebyly. Pokud by tarif potřeboval vlastní data, může v tom slovníku stát objekt s metodou. Volající kód se nezmění.

Úkol

Přidej slevy zvenčí

Doplň do slovníku SLEVY dvě nové slevy, ale funkci po_sleve neměň:

  • student: cena po slevě 20 %, tedy cena * 80 // 100,
  • akce: o 100 Kč méně, ale nikdy pod nulu.
def zadna(cena):
    return cena


def vernost(cena):
    return cena * 90 // 100


SLEVY = {"zadna": zadna, "vernost": vernost}


def po_sleve(cena, druh):
    if druh not in SLEVY:
        raise ValueError(f"Neznámá sleva: {druh}")
    return SLEVY[druh](cena)


# Sem přidej nové slevy

print(po_sleve(1000, "vernost"))
Výstup
Pod kapotou · problém výrazu

Otevřenost nikdy není úplná. Registr nebo hierarchie tříd zjednoduší přidání nového případu, ale nová operace nad všemi případy znamená projít každý z nich. U match je to obráceně. Této dvojici se říká expression problem. Vol podle toho, co se v tvé doméně mění častěji.

Pevnou množinu případů hlídej u match přes typing.assert_never: po přidání člena do Enum nahlásí mypy každé místo, které ho neřeší. Registr plněný dekorátorem má opačnou past. Zaregistruje se jen modul, který někdo importoval. Pluginy z jiných balíků proto řeš přes importlib.metadata.entry_points, ne spoléháním na vedlejší efekty importu.

L: potomek nesmí překvapit

Dědičnost slibuje: kde funguje rodič, funguje i potomek. Barbara Liskov tuhle myšlenku formulovala v roce 1987 a nese po ní jméno. Sleduj, co se stane, když je potomek rodičem jen podle názvu.

class Naradi:
    def __init__(self, nazev, sazba):
        self.nazev = nazev
        self.sazba = sazba

    def cena(self, dny):
        return self.sazba * dny


class VystavniKus(Naradi):
    def cena(self, dny):
        raise RuntimeError("Výstavní kus se nepůjčuje.")


def nabidka(polozky, dny):
    for polozka in polozky:
        print(polozka.nazev, polozka.cena(dny))


nabidka([Naradi("vrtačka", 250), VystavniKus("stará pila", 0), Naradi("bruska", 180)], 2)
Výstup
vrtačka 500

Výstavní kus je nářadí, když se na něj díváš v regálu. Pro program ale „nářadí“ znamená „dá se spočítat cena půjčení“ a tenhle slib potomek porušil. Funkce nabidka za nic nemůže, a přesto by musela zjišťovat, co přesně dostala.

Oprava: společné je jen to, co společné doopravdy je. Tady je to název.

class Polozka:
    def __init__(self, nazev):
        self.nazev = nazev


class Naradi(Polozka):
    def __init__(self, nazev, sazba):
        super().__init__(nazev)
        self.sazba = sazba

    def cena(self, dny):
        return self.sazba * dny


class Exponat(Polozka):
    def __init__(self, nazev, rok):
        super().__init__(nazev)
        self.rok = rok


def nabidka(naradi, dny):
    for kus in naradi:
        print(kus.nazev, kus.cena(dny))


sbirka = [Naradi("vrtačka", 250), Exponat("stará pila", 1931), Naradi("bruska", 180)]
nabidka([p for p in sbirka if isinstance(p, Naradi)], 2)
Výstup
vrtačka 500
bruska 360

Pro potomka si polož čtyři otázky:

  • Přijme všechno, co přijímal rodič?
  • Vrací stejný druh výsledku?
  • Nevyhazuje chyby, se kterými u rodiče nikdo nepočítá?
  • Platí dál všechno, co o rodiči platilo?
Úkol

Potomek vrací něco jiného

VikendovyTarif vrací z metody cena text, takže trzba spadne. Oprav to:

  • VikendovyTarif.cena(dny) má vracet celé číslo, a to sazba * dny + 100,
  • přidej samostatnou funkci na_kc(castka), která z 1000 udělá text 1000 Kč.
class Tarif:
    def __init__(self, sazba):
        self.sazba = sazba

    def cena(self, dny):
        return self.sazba * dny


class VikendovyTarif(Tarif):
    def cena(self, dny):
        return f"{self.sazba * dny + 100} Kč"


def trzba(tarify, dny):
    return sum(tarif.cena(dny) for tarif in tarify)


print(trzba([Tarif(250), VikendovyTarif(200)], 2))
Výstup
Kvíz

Rodič má cena(dny) pro libovolný kladný počet dní. Potomek vyhodí chybu, když je dní víc než 7. Je to v pořádku?

Pod kapotou · porušení přímo ve standardní knihovně

Ani standardní knihovna není bez hříchu. Jsou to většinou staré kompromisy, které už nejde změnit bez rozbití kódu.

from collections import Counter, OrderedDict
from datetime import date, datetime

a = OrderedDict(x=1, y=2)
b = OrderedDict(y=2, x=1)
c = {"x": 1, "y": 2}
print("rovnost není tranzitivní:", a == c, c == b, a == b)

cas = datetime(2026, 1, 1)
den = date(2026, 1, 1)
print("datetime je date:", isinstance(cas, date))
print("přesto se nerovnají:", cas == den)
try:
    cas < den
except TypeError as chyba:
    print("a nejdou porovnat:", type(chyba).__name__)

try:
    Counter.fromkeys("ab")
except NotImplementedError as chyba:
    print(chyba)
Výstup
rovnost není tranzitivní: True True False
datetime je date: True
přesto se nerovnají: False
a nejdou porovnat: TypeError
Counter.fromkeys() is undefined.  Use Counter(iterable) instead.

Formálně platí: parametry přepsané metody smějí být obecnější (kontravariance), návratový typ konkrétnější (kovariance). Mypy porušení hlásí přímo s odkazem na Liskov substitution principle. Proto taky list[bool] není list[int]: do seznamu by šlo vložit 2. Pro čtení ale Sequence[bool] za Sequence[int] dosadit lze.

I a D: na čem tvůj kód závisí

Zbylé dvě zásady řeší totéž ze dvou stran. I říká: chtěj od ostatních co nejméně. D říká: důležitá pravidla ať nezávisí na technických detailech.

Funkce na štítek potřebuje jen název. Kdyby vyžadovala celou třídu Naradi, nešlo by jí předat exponát. Protocol z lekce ABC a Protocol popisuje jen to, co funkce skutečně použije, a dědit od něj nikdo nemusí.

from collections.abc import Iterable
from typing import Protocol


class MaNazev(Protocol):
    nazev: str


class MaCenu(Protocol):
    def cena(self, dny: int) -> int: ...


class Naradi:
    def __init__(self, nazev: str, sazba: int):
        self.nazev = nazev
        self.sazba = sazba

    def cena(self, dny: int) -> int:
        return self.sazba * dny


class Exponat:
    def __init__(self, nazev: str):
        self.nazev = nazev


class Balicek:
    def __init__(self, kusy: list[Naradi]):
        self.kusy = kusy

    def cena(self, dny: int) -> int:
        return sum(kus.cena(dny) for kus in self.kusy) * 90 // 100


def stitek(vec: MaNazev) -> str:
    return f"[ {vec.nazev.upper()} ]"


def celkem(polozky: Iterable[MaCenu], dny: int) -> int:
    return sum(polozka.cena(dny) for polozka in polozky)


vrtacka = Naradi("vrtačka", 250)
bruska = Naradi("bruska", 180)

print(stitek(vrtacka))
print(stitek(Exponat("stará pila")))
print(celkem([vrtacka, Balicek([vrtacka, bruska])], 2))
Výstup
[ VRTAČKA ]
[ STARÁ PILA ]
1274

Třídy o protokolech nevědí a nedědí od nich. Stačí, že mají správné atributy a metody. Anotace Python za běhu nekontroluje, hlídá je editor nebo mypy.

Teď D. Rozesílání upomínek si samo vyrábí SMS bránu a samo se ptá na dnešní datum:

python
class Upominky:
    def rozesli(self, vypujcky):
        brana = SmsBrana()                       # natvrdo konkrétní služba
        for v in vypujcky:
            if v["vratit_do"] < date.today():    # výsledek závisí na dnešku
                brana.posli(v["telefon"], "Vraťte nářadí.")

Vyzkoušet to znamená poslat skutečné zprávy a doufat, že dnešní datum vyjde. Pravidlo „po termínu upomeň“ je přitom úplně nezávislé na tom, jestli zpráva letí přes SMS. Otoč závislost: Upominky si řeknou jen o něco, co umí posli, a dostanou to zvenčí.

text
před:   Upominky ------------> SmsBrana

po:     Upominky ---> Odesilatel <--- SmsBrana
                      (dohoda)   <--- TestovaciOdesilatel
from datetime import date
from typing import Protocol


class Odesilatel(Protocol):
    def posli(self, komu: str, text: str) -> None: ...


class Upominky:
    def __init__(self, odesilatel: Odesilatel):
        self.odesilatel = odesilatel

    def rozesli(self, vypujcky: list[dict], dnes: date) -> int:
        pocet = 0
        for v in vypujcky:
            if v["vratit_do"] < dnes:
                self.odesilatel.posli(v["telefon"], f"Vraťte prosím: {v['naradi']}")
                pocet += 1
        return pocet


class TiskovyOdesilatel:
    def posli(self, komu: str, text: str) -> None:
        print(f"{komu} <- {text}")


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

    def posli(self, komu: str, text: str) -> None:
        self.zpravy.append((komu, text))


vypujcky = [
    {"telefon": "000 000 111", "naradi": "vrtačka", "vratit_do": date(2026, 3, 1)},
    {"telefon": "000 000 222", "naradi": "bruska", "vratit_do": date(2026, 3, 20)},
]
den = date(2026, 3, 10)

print(Upominky(TiskovyOdesilatel()).rozesli(vypujcky, den))

atrapa = TestovaciOdesilatel()
Upominky(atrapa).rozesli(vypujcky, den)
print(atrapa.zpravy)
Výstup
000 000 111 <- Vraťte prosím: vrtačka
1
[('000 000 111', 'Vraťte prosím: vrtačka')]

Žádný framework nebyl potřeba. Závislost je obyčejný parametr. Skutečnou bránu předáš na jediném místě, při startu programu.

Úkol

Vytáhni závislosti ven

HlidacVraceni si sám vytváří bránu a sám zjišťuje datum. Uprav ho tak, aby __init__(self, odesilatel, dnes) dostal:

  • odesilatel: objekt s metodou posli(komu, text),
  • dnes: funkci bez parametrů, která vrací aktuální datum. Volej ji až při každé kontrole.

zkontroluj(vypujcky) dál pošle Vraťte prosím: <naradi> každému po termínu (den termínu ještě není po termínu) a vrátí počet zpráv.

from datetime import date


class SmsBrana:
    def posli(self, komu, text):
        print(f"SMS pro {komu}: {text}")


class HlidacVraceni:
    def __init__(self):
        self.brana = SmsBrana()

    def zkontroluj(self, vypujcky):
        pocet = 0
        for telefon, naradi, vratit_do in vypujcky:
            if vratit_do < date.today():
                self.brana.posli(telefon, f"Vraťte prosím: {naradi}")
                pocet += 1
        return pocet
Výstup
Pod kapotou · runtime protokoly lžou víc, než čekáš

Dekorátor @runtime_checkable povolí isinstance, ale kontroluje jen existenci jmen. Od Pythonu 3.12 se hledají přes inspect.getattr_static, takže se nespustí property ani __getattr__. Signaturu nikdo neověřuje.

from typing import Protocol, runtime_checkable


@runtime_checkable
class MaCenu(Protocol):
    def cena(self, dny: int) -> int: ...


class Podvod:
    def cena(self):
        return "zdarma"


print(isinstance(Podvod(), MaCenu))
Výstup
True

U závislostí si dej pozor na výchozí hodnotu def __init__(self, brana=SmsBrana()). Výraz se vyhodnotí jednou při definici funkce, takže vznikne sdílená instance už při importu. Použij brana: Odesilatel | None = None.

Čas je závislost jako každá jiná. datetime.datetime je neměnný typ z C, takže mock.patch("datetime.datetime.now") skončí TypeError. Hodiny předané jako Callable[[], datetime] žádný patch nepotřebují. Ještě dál jde vzor functional core, imperative shell: rozhodování je v čistých funkcích a vstupy a výstupy v tenké vrstvě kolem. Víc v lekci Mocky a testovatelný návrh.

Kdy SOLID neposlouchat

Každá abstrakce něco stojí. Čtenář musí skočit o soubor dál, aby zjistil, co se vlastně děje, a každý nový případ se musí vejít do tvaru, který jsi vymyslel předem. Když se odhad nepovede, abstrakce překáží víc než opakovaný kód. Sandi Metz to shrnula známou větou: duplicita je mnohem levnější než špatná abstrakce.

Pár pravidel, která se v praxi osvědčila:

  • Pravidlo tří. Poprvé napiš, podruhé klidně zkopíruj, potřetí teprve hledej společný tvar. Až tři skutečné případy ukážou, co je opravdu společné.
  • Nejdřív bolest, potom lék. Rozhraní pro něco, co má jedinou implementaci a žádný test ho nenahrazuje, jen přidává čtení.
  • Hranice ano, vnitřek méně. Databáze, síť, čas a platby jsou dobré místo pro „zásuvku“. Výpočet z pár řádků nejspíš ne.
Co tě bolíZásadaCo zkusit
Změna textu rozbila výpočetSoddělit části podle toho, kdo je mění
Každý nový případ znamená další elif na několika místechOslovník funkcí nebo objekty se stejnou metodou
V kódu přibývá isinstance a potomci vyhazují NotImplementedErrorLpřehodnotit dědičnost, zvážit kompozici
Testovací atrapa má patnáct prázdných metodImenší protokol podle toho, co volající používá
Test posílá skutečné e-maily nebo závisí na dneškuDpředat závislost parametrem
Nic nebolížádnánech kód být
Úkol

Zruš zbytečnou abstrakci

Na převod haléřů na text tu stojí tři třídy, a přitom existuje jediný způsob převodu. Nahraď je jednou funkcí na_kc(halere), která z 12345 udělá 123,45 Kč a z 5 udělá 0,05 Kč. Třídy smaž.

from abc import ABC, abstractmethod


class AbstraktniPrevodnik(ABC):
    @abstractmethod
    def preved(self, halere): ...


class KorunovyPrevodnik(AbstraktniPrevodnik):
    def preved(self, halere):
        return f"{halere // 100},{halere % 100:02d} Kč"


class TovarnaNaPrevodniky:
    def vytvor(self):
        return KorunovyPrevodnik()


print(TovarnaNaPrevodniky().vytvor().preved(12345))
Výstup
Kvíz

Výpočet dopravy má tři větve v if. Za tři roky se nezměnil a je pokrytý testy. Kolega ho chce přepsat na hierarchii strategií. Co dává největší smysl?

Kvíz

Který kód nejvíc těží z předání závislosti parametrem?