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))
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ísmeno | Anglicky | Lidsky |
|---|---|---|
| S | Single responsibility | Část kódu má jeden důvod ke změně. |
| O | Open/closed | Nový případ přidáš, aniž přepisuješ ten hotový. |
| L | Liskov substitution | Potomek se chová tak, jak slibuje rodič. |
| I | Interface segregation | Nikdo nezávisí na tom, co nepotřebuje. |
| D | Dependency inversion | Pravidla 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))
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.
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_pozdeje 0 nebo záporné) vrátí 0.zprava(jmeno, castka)vrátí textEva: poplatek za pozdní vrácení 150 Kč., při nulové částceEva: 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)
Třída Faktura má metody soucet(), dph() a do_pdf(). Co je nejsilnější důvod přesunout do_pdf jinam?
Počet metod nerozhoduje. Rozhoduje, že změna šablony by neměla ohrozit výpočet daně a naopak.
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:
git log --format= --name-only --since="1 year ago" | sort | uniq -c | sort -rn | headOpač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"))
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í.
Přidej slevy zvenčí
Doplň do slovníku SLEVY dvě nové slevy, ale funkci po_sleve neměň:
student: cena po slevě 20 %, tedycena * 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"))
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)
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)
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?
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 tosazba * dny + 100,- přidej samostatnou funkci
na_kc(castka), která z1000udělá text1000 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))
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?
Potomek smí vstupy rozšířit, ne zúžit. Kdo drží odkaz na rodiče, o limitu sedmi dnů neví.
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)
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))
[ 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:
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čí.
před: Upominky ------------> SmsBrana
po: Upominky ---> Odesilatel <--- SmsBrana
(dohoda) <--- TestovaciOdesilatelfrom 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)
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.
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 metodouposli(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
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))
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ásada | Co zkusit |
|---|---|---|
| Změna textu rozbila výpočet | S | oddělit části podle toho, kdo je mění |
Každý nový případ znamená další elif na několika místech | O | slovník funkcí nebo objekty se stejnou metodou |
V kódu přibývá isinstance a potomci vyhazují NotImplementedError | L | přehodnotit dědičnost, zvážit kompozici |
| Testovací atrapa má patnáct prázdných metod | I | menší protokol podle toho, co volající používá |
| Test posílá skutečné e-maily nebo závisí na dnešku | D | předat závislost parametrem |
| Nic nebolí | žádná | nech kód být |
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ý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?
Zásada O je odpověď na opakované změny. Tady žádné nejsou, takže přepis stojí práci a nic nepřinese.
Který kód nejvíc těží z předání závislosti parametrem?
Čas i platební brána jsou vnější svět. Bez možnosti je vyměnit se chování nedá spolehlivě vyzkoušet.