Lidsky řečeno
Znáš rozpočet v obálkách? Výplatu rozdělíš do obálek s nápisy nájem, jídlo a zábava. Když je obálka prázdná, víš, že je konec. Tvůj program dělá totéž, jen obálky nemusíš lepit a nikdo si z nich tajně nepůjčí na pizzu.
Plán: malé funkce místo jedné obří
Výpis z banky vypadá takhle. Každý řádek má datum, popis, kategorii a částku, oddělené středníkem. Výdaje jsou záporné. Dva řádky jsou schválně rozbité, protože reálná data bývají.
2026-02-27;Záloha na elektřinu;bydlení;-1 870,00
2026-03-01;Výplata;příjem;42 300,00
2026-03-02;Nájem;bydlení;-14 500,00
2026-03-03;Velký nákup;jídlo;-2 249,50
2026-03-05;Měsíční jízdenka;doprava;-550,00
2026-03-09;Bunda;oblečení;-2 490,00
2026-03-12;Bunda vrácena;oblečení;2 490,00
2026-03-14;Kino;zábava;dvě stovky
chyba exportuJedna funkce na tohle všechno by měla stovku řádků a nešla by otestovat po částech. Rozdělíš práci tak, aby každá funkce uměla jednu věc a výstup jedné byl vstupem další:
text výpisu
| nacti_vypis (uvnitř nacti_radek a na_halere)
v
seznam transakcí + seznam chybných řádků
| vyber (podmínky z_mesice, z_kategorie)
v
transakce za období
| prehled (uvnitř vydaje_podle_kategorii a stav_limitu)
v
slovník s výsledky
| vypis_prehled (uvnitř na_kc)
v
obrazovkaJedině poslední funkce něco tiskne. Všechny ostatní jen dostanou data a vrátí data. Takové funkci se říká čistá: se stejným vstupem vrátí vždy stejný výsledek a nic kolem sebe nemění. Dá se proto vyzkoušet jedním řádkem.
Krok 1: peníze v haléřích
První nápad je uložit částku jako desetinné číslo. Sleduj, co se stane, když desetkrát přičteš deset haléřů.
zustatek = 0.0
for _ in range(10):
zustatek += 0.10
print(zustatek)
print(zustatek == 1.0)
0.9999999999999999 False
Počítač ukládá desetinná čísla ve dvojkové soustavě a číslo 0.1 v ní nejde zapsat přesně, stejně jako třetina nejde přesně zapsat desetinně. U peněz je to nepřijatelné. Řešení je prosté: počítej v haléřích. Celá čísla jsou v Pythonu vždy přesná, takže 1 249,50 Kč uložíš jako 124950.
Převod z textu vypadá jednoduše: rozdělit podle čárky, koruny krát sto, přičíst haléře. Jenže pozor na znaménko. Než kód spustíš, tipni si všechny tři výsledky.
def naivni_prevod(text):
koruny, halere = text.split(",")
return int(koruny) * 100 + int(halere)
print(naivni_prevod("12,50"))
print(naivni_prevod("-12,50"))
print(naivni_prevod("-0,50"))
1250 -1150 50
Správně má vyjít -1250 a -50. U záporné částky se mají haléře odečíst, kód je ale přičetl. Výdaj padesát haléřů se dokonce změnil v příjem. Znaménko proto musíš odložit stranou, spočítat kladnou hodnotu a znaménko přidat až nakonec.
Další problém je text, který číslo vůbec není. int na něm skončí chybou a celý program spadne.
print("Převádím částku...")
print(int("dvě stovky"))
Převádím částku...
Výjimky přijdou na řadu až v dalším modulu. Tady si vystačíš s kontrolou předem: když text není platná částka, funkce vrátí None, tedy „žádná hodnota“. Pomohou ti tyhle čtyři nástroje:
# split() bez parametru rozseká text podle mezer, join ho slepí bez nich
print("".join("1 249,50".split()))
# partition vrátí vždy tři části: před, oddělovač, za
print("1249,50".partition(","))
print("1249".partition(","))
# ljust doplní text zprava na zadanou délku
print("5".ljust(2, "0"), "".ljust(2, "0"), "50".ljust(2, "0"))
# isdecimal říká, jestli je text neprázdný a tvoří ho jen číslice
print("12".isdecimal(), "12a".isdecimal(), "".isdecimal())
1249,50
('1249', ',', '50')
('1249', '', '')
50 00 50
True False FalseV zadání potkáš ještě tři drobnosti. Metoda startswith může dostat n-tici a pak jí stačí shoda s kterýmkoli prvkem. Podtržítko _ je obvyklé jméno pro hodnotu, kterou nepotřebuješ, tady pro oddělovač z partition. A haléře doplňuješ nulami zprava, protože 12,5 znamená 12 korun a 50 haléřů, ne 5 haléřů.
Úkol 1: z textu na haléře
Dokonči funkci na_halere. Vyčištění textu a odložení znaménka už máš hotové. Doplň zbytek:
- když
korunynejsou samé číslice, vraťNone, - když doplněné
halerenejsou samé číslice nebo nemají přesně dva znaky, vraťNone(tím odmítneš třeba12,345), - jinak vrať
znamenko * (koruny * 100 + halere), obojí převedené naint.
def na_halere(text: str) -> int | None:
"""Převede částku z výpisu na haléře, nesmysl vrátí jako None."""
cisty = "".join(text.split())
znamenko = -1 if cisty.startswith("-") else 1
if cisty.startswith(("-", "+")):
cisty = cisty[1:]
koruny, _, halere = cisty.partition(",")
halere = halere.ljust(2, "0")
# doplň kontroly a výpočet
print(na_halere("-1 249,50"))
Co funkce přijme?
Roztřiď texty podle toho, co z nich udělá hotová funkce na_halere.
Cesta zpátky je potřeba pro výpis. Funkce divmod vrátí podíl a zbytek najednou. U záporných čísel ale podíl zaokrouhluje dolů, takže z -124950 udělá -1250 a zbytek 50. Matematicky to sedí, do výpisu se to nehodí. Znaménko tedy zase řešíš zvlášť a dělíš absolutní hodnotu, tedy číslo bez znaménka, kterou vrací abs. Formát :, v f-stringu odděluje tisíce čárkou, replace ji vymění za mezeru a :02d doplní číslo zleva nulami na dvě číslice.
print(divmod(124950, 100))
print(divmod(-124950, 100))
print(abs(-124950))
print(f"{1234567:,}")
print(f"{1234567:,}".replace(",", " "))
print(f"{5:02d}")
(1249, 50) (-1250, 50) 124950 1,234,567 1 234 567 05
Úkol 2: z haléřů na text
Napiš funkci na_kc(halere), která vrátí text s tisíci oddělenými mezerou: z -124950 udělá -1 249,50 Kč, z 5 udělá 0,05 Kč.
def na_kc(halere: int) -> str:
"""Zformátuje haléře jako český zápis částky."""
# doplň
print(na_kc(-124950))
Proč je v převodu znaménko řešené zvlášť a nestačí int("-0") * 100 + 50?
Záporná nula u celých čísel neexistuje. Výdaj 50 haléřů by se bez odloženého znaménka tiše proměnil v příjem, a takové chyby žádná hláška neoznámí.
Pod kapotou · peníze v kódu
Binární float (IEEE 754 binary64) je pro částky špatná volba a Python 3.12 to umí zamaskovat: vestavěné sum() nově sčítá floaty s kompenzací chyby, takže sum([0.1] * 10) == 1.0, zatímco cyklus s += vrátí 0.9999999999999999. Test postavený na sum tak problém neodhalí. Stejná past je round(2.675, 2) == 2.67 (literál je ve skutečnosti o chlup menší) a zaokrouhlování na sudou u round(2.5) == 2.
Celé číslo v nejmenší jednotce je běžná praxe, jen počet desetinných míst není všude stejný: ISO 4217 dává jenu nula míst a kuvajtskému dináru tři, takže měna musí cestovat s částkou. Když potřebuješ sazby a procenta, sáhni po decimal.Decimal("0.10") s explicitním quantize a ROUND_HALF_UP. Nikdy Decimal(0.1), to věrně zkopíruje binární chybu. Int v CPythonu nepřeteče, ale při cestě ven ano: JSON čtený v JavaScriptu je bezpečný jen do 2**53 - 1. A divmod zaokrouhluje k mínus nekonečnu, proto -7 % 3 == 2, na rozdíl od C, kde vyjde -1.
Celá čísla mají vlastní past, dělení. Sto korun na tři díly dá divmod(10000, 3) == (3333, 1) a zbylý haléř musíš někomu přidělit, jinak součet dílů nesedí s celkem.
Krok 2: od textu k datům
Teď umíš převést částku, zbývá celý řádek. Rozdělíš ho podle středníku, ořízneš mezery a složíš slovník. Když řádek nemá čtyři části nebo je částka nesmyslná, vrátíš None. O zbytek se postará druhá funkce, která projde všechny řádky a rozdělí je na dobré a chybné.
Jednu past si ukaž předem. Částka 0,00 je platná a její hodnota je 0, jenže nula se v podmínce chová jako nepravda.
castka = 0
if not castka:
print("not castka: nula vypadá jako chyba")
if castka is None:
print("is None: chyba")
else:
print("is None: nula je v pořádku")
not castka: nula vypadá jako chyba is None: nula je v pořádku
Úkol 3: přečti řádek výpisu
Napiš nacti_radek(radek). Řádek rozděl podle ; a každou část ořízni o mezery. Vrať slovník s klíči datum, popis, kategorie (malými písmeny) a castka (v haléřích). Když částí není přesně čtyři nebo je částka neplatná, vrať None. Funkce na_halere a nacti_vypis už hotové jsou.
def na_halere(text: str) -> int | None:
cisty = "".join(text.split())
znamenko = -1 if cisty.startswith("-") else 1
if cisty.startswith(("-", "+")):
cisty = cisty[1:]
koruny, _, halere = cisty.partition(",")
halere = halere.ljust(2, "0")
if not koruny.isdecimal() or not halere.isdecimal() or len(halere) != 2:
return None
return znamenko * (int(koruny) * 100 + int(halere))
def nacti_radek(radek: str) -> dict | None:
"""Z řádku výpisu udělá slovník, vadný řádek vrátí jako None."""
# doplň
def nacti_vypis(text: str) -> tuple[list[dict], list[str]]:
"""Vrátí platné transakce a seznam řádků, které nešly přečíst."""
transakce = []
chybne = []
for radek in text.splitlines():
radek = radek.strip()
if not radek:
continue
zaznam = nacti_radek(radek)
if zaznam is None:
chybne.append(radek)
else:
transakce.append(zaznam)
return transakce, chybne
print(nacti_radek("2026-03-03;Velký nákup;Jídlo;-2 249,50"))
Všimni si, co nacti_vypis vrací: dvojici seznamů. Nezastaví se na první chybě a chybný řádek ani nezahodí. Po jednom spuštění tak vidíš všechny problémy najednou a nic se neztratí bez povšimnutí.
Pod kapotou · co všechno projde přes int a isdecimal
Kontrola přes isdecimal je přísnější než samotné int, které bez námitek bere "1_000", " 12 " i "+5". isdigit by byl horší: "²".isdigit() je True, ale int("²") spadne. isdecimal zase pustí nelatinkové číslice, int("٣") == 3. Pokud je nechceš, přidej isascii().
Díra zůstává u délky. Od bezpečnostní opravy CVE-2020-10735 má převod textu na int limit 4300 číslic, takže int("1" * 5000) vyhodí ValueError přesto, že isdecimal prošlo. U nedůvěryhodného vstupu proto omez délku řetězce předem.
Bez parametru str.split() dělí podle všech unicodových mezer včetně \xa0 a \u202f, které exporty z tabulek rády používají jako oddělovač tisíců. replace(" ", "") by je přehlédlo. Typografické minus − (U+2212) tady skončí mezi chybnými řádky, což je přesně důvod, proč se chyby sbírají a nezahazují.
Slabina téhle verze je datum, které nikdo nekontroluje. BOM na začátku souboru (\ufeff2026-02-27, strip ho neodstraní, řeší ho kódování utf-8-sig) nebo zápis 27.2.2026 projdou jako platná transakce a z_mesice je potom tiše vynechá. Pomůže date.fromisoformat(datum).isoformat(). Normalizace je nutná, protože fromisoformat od Pythonu 3.11 bere i 20260227. Při opakovaném importu ještě řeš duplicity: dvě stejné kávy v jeden den jsou legitimní, takže bez ID transakce z banky nepoznáš kopii od skutečného nákupu.
Krok 3: filtry na míru
Přehled chceš za jeden měsíc, jindy jen za jídlo, příště za obojí. Psát na každou kombinaci novou funkci by byl nesmysl. Využiješ dvě věci z předchozích lekcí: funkce je hodnota a closure si pamatuje proměnné z místa, kde vznikla.
z_mesice je továrna: dostane měsíc a vyrobí podmínku, která o jedné transakci řekne ano, nebo ne. Projdi si ukázku tlačítkem krokovat a sleduj, že tělo podminka běží až při volání brezen(...), a přitom pořád zná mesic.
def z_mesice(mesic: str):
def podminka(transakce: dict) -> bool:
return transakce["datum"].startswith(mesic)
return podminka
brezen = z_mesice("2026-03")
print(brezen({"datum": "2026-03-14"}))
print(brezen({"datum": "2026-02-27"}))
True False
Funkce vyber pak dostane libovolný počet takových podmínek přes *podminky a nechá jen transakce, které splní všechny. Vestavěná funkce all vrátí True, když jsou pravdivé všechny předané hodnoty.
Úkol 4: skládání filtrů
Napiš dvě funkce:
z_kategorie(*kategorie)vrátí podmínku, která platí pro transakci z kterékoli zadané kategorie,vyber(transakce, *podminky)vrátí nový seznam transakcí, které splňují všechny podmínky. Původní seznam nemění.
def z_mesice(mesic: str):
def podminka(transakce: dict) -> bool:
return transakce["datum"].startswith(mesic)
return podminka
def z_kategorie(*kategorie: str):
# doplň
pass
def vyber(transakce: list[dict], *podminky) -> list[dict]:
# doplň
pass
pohyby = [
{"datum": "2026-02-27", "popis": "Elektřina", "kategorie": "bydlení", "castka": -187000},
{"datum": "2026-03-03", "popis": "Nákup", "kategorie": "jídlo", "castka": -224950},
{"datum": "2026-03-05", "popis": "Jízdenka", "kategorie": "doprava", "castka": -55000},
]
print(vyber(pohyby, z_mesice("2026-03"), z_kategorie("jídlo")))
Co vrátí vyber(pohyby), když nezadáš žádnou podmínku?
Žádná podmínka neřekla ne, takže prošlo všechno. Díky tomu nepotřebuje vyber pro tenhle případ zvláštní větev.
Krok 4: souhrny a limity
Teď přijde to, kvůli čemu program píšeš. Výdaj kategorie je součet částek s opačným znaménkem, takže nákup za -2 490,00 přičte a vrácení za +2 490,00 zase odečte. Kategorii příjem vynecháš, peníze z výplaty nejsou záporný výdaj.
Úkol 5: kam to odešlo
Napiš vydaje_podle_kategorii(transakce). Vrať slovník kategorie -> utraceno v haléřích bez kategorie příjem, seřazený od největšího výdaje. Vrácené peníze výdaj kategorie snižují.
def vydaje_podle_kategorii(transakce: list[dict]) -> dict[str, int]:
"""Sečte výdaje po kategoriích, největší je první."""
soucty = {}
# doplň
return soucty
pohyby = [
{"datum": "2026-03-01", "popis": "Výplata", "kategorie": "příjem", "castka": 4230000},
{"datum": "2026-03-07", "popis": "Oběd", "kategorie": "jídlo", "castka": -28900},
{"datum": "2026-03-09", "popis": "Bunda", "kategorie": "oblečení", "castka": -249000},
{"datum": "2026-03-10", "popis": "Boty", "kategorie": "oblečení", "castka": -189000},
{"datum": "2026-03-12", "popis": "Bunda vrácena", "kategorie": "oblečení", "castka": 249000},
]
print(vydaje_podle_kategorii(pohyby))
V kategorii oblečení je bunda -2 490,00, boty -1 890,00 a vrácená bunda 2 490,00. Kolik je výdaj kategorie?
Bunda se vrátila, takže se její nákup i vrácení vyruší. Zůstanou jen boty.
Vrácená bunda zdražuje
Funkce má vrácené zboží od výdajů odečíst, ale výdaj kategorie po vrácení roste. Který řádek za to může?
Limit má tři možné stavy: v pořádku, pozor a překročeno. Kategorie bez limitu dostane čtvrtý, bez limitu. Varování chceš dostat dřív, než je pozdě, standardně od 80 %. Procenta porovnáš bez dělení: místo utraceno / limit >= 0.8 vynásobíš obě strany limitem a stem, takže vznikne utraceno * 100 >= limit * 80. Zůstaneš u přesných celých čísel a limit 0 nezpůsobí dělení nulou. Tipni si, co ukázka vypíše, hlavně u přesně vyčerpaného limitu.
def stav_limitu(utraceno: int, limit: int | None, varovat_od: int = 80) -> str:
if limit is None:
return "bez limitu"
if utraceno > limit:
return "překročeno"
if utraceno * 100 >= limit * varovat_od:
return "pozor"
return "v pořádku"
print(stav_limitu(50_000, 100_000))
print(stav_limitu(80_000, 100_000))
print(stav_limitu(100_000, 100_000))
print(stav_limitu(100_001, 100_000))
print(stav_limitu(60_000, 100_000, varovat_od=50))
print(stav_limitu(60_000, None))
v pořádku pozor pozor překročeno pozor bez limitu
Úkol 6: přehled jako data
Napiš prehled(transakce, limity, *, varovat_od=80). Hvězdička znamená, že varovat_od jde předat jen pojmenovaně. Funkce nic netiskne a vrátí slovník:
prijmy: součet částek kategoriepříjem,vydaje: součet všech výdajů zvydaje_podle_kategorii,zustatek: příjmy minus výdaje,kategorie: seznam slovníků s klíčinazev,utraceno,limitastav, ve stejném pořadí jako výdaje. Kategorie bez limitu málimitrovnýNone.
def vydaje_podle_kategorii(transakce: list[dict]) -> dict[str, int]:
soucty = {}
for t in transakce:
if t["kategorie"] == "příjem":
continue
soucty[t["kategorie"]] = soucty.get(t["kategorie"], 0) - t["castka"]
return dict(sorted(soucty.items(), key=lambda par: par[1], reverse=True))
def stav_limitu(utraceno: int, limit: int | None, varovat_od: int = 80) -> str:
if limit is None:
return "bez limitu"
if utraceno > limit:
return "překročeno"
if utraceno * 100 >= limit * varovat_od:
return "pozor"
return "v pořádku"
def prehled(transakce: list[dict], limity: dict[str, int], *, varovat_od: int = 80) -> dict:
"""Spočítá souhrn rozpočtu. Nic netiskne."""
# doplň
pohyby = [
{"datum": "2026-03-01", "popis": "Výplata", "kategorie": "příjem", "castka": 4230000},
{"datum": "2026-03-03", "popis": "Nákup", "kategorie": "jídlo", "castka": -224950},
]
print(prehled(pohyby, {"jídlo": 500000}))
Krok 5: celý program
Všechny díly jsou hotové. Přibyla jen vypis_prehled, jediná funkce, která něco tiskne, a pár řádků na konci, které všechno zapojí. Změň limity, přidej řádek do výpisu, přepni měsíc na 2026-02 nebo do volání vyber přidej z_kategorie("jídlo") a sleduj, co se stane.
VYPIS = """
2026-02-27;Záloha na elektřinu;bydlení;-1 870,00
2026-03-01;Výplata;příjem;42 300,00
2026-03-02;Nájem;bydlení;-14 500,00
2026-03-03;Velký nákup;jídlo;-2 249,50
2026-03-05;Měsíční jízdenka;doprava;-550,00
2026-03-07;Oběd s kolegy;jídlo;-289,00
2026-03-09;Bunda;oblečení;-2 490,00
2026-03-10;Boty;oblečení;-1 890,00
2026-03-12;Bunda vrácena;oblečení;2 490,00
2026-03-14;Kino;zábava;dvě stovky
2026-03-15;Týdenní nákup;jídlo;-3 120,40
chyba exportu
2026-03-20;Koncert;zábava;-1 150,00
2026-03-22;Prodej kola;příjem;3 500,00
"""
LIMITY = {
"bydlení": 1_500_000,
"jídlo": 500_000,
"doprava": 100_000,
"zábava": 150_000,
}
def na_halere(text: str) -> int | None:
cisty = "".join(text.split())
znamenko = -1 if cisty.startswith("-") else 1
if cisty.startswith(("-", "+")):
cisty = cisty[1:]
koruny, _, halere = cisty.partition(",")
halere = halere.ljust(2, "0")
if not koruny.isdecimal() or not halere.isdecimal() or len(halere) != 2:
return None
return znamenko * (int(koruny) * 100 + int(halere))
def na_kc(halere: int) -> str:
znamenko = "-" if halere < 0 else ""
koruny, zbytek = divmod(abs(halere), 100)
cele = f"{koruny:,}".replace(",", " ")
return f"{znamenko}{cele},{zbytek:02d} Kč"
def nacti_radek(radek: str) -> dict | None:
casti = [cast.strip() for cast in radek.split(";")]
if len(casti) != 4:
return None
datum, popis, kategorie, text_castky = casti
castka = na_halere(text_castky)
if castka is None:
return None
return {"datum": datum, "popis": popis, "kategorie": kategorie.lower(), "castka": castka}
def nacti_vypis(text: str) -> tuple[list[dict], list[str]]:
transakce = []
chybne = []
for radek in text.splitlines():
radek = radek.strip()
if not radek:
continue
zaznam = nacti_radek(radek)
if zaznam is None:
chybne.append(radek)
else:
transakce.append(zaznam)
return transakce, chybne
def z_mesice(mesic: str):
def podminka(transakce: dict) -> bool:
return transakce["datum"].startswith(mesic)
return podminka
def z_kategorie(*kategorie: str):
def podminka(transakce: dict) -> bool:
return transakce["kategorie"] in kategorie
return podminka
def vyber(transakce: list[dict], *podminky) -> list[dict]:
return [t for t in transakce if all(p(t) for p in podminky)]
def vydaje_podle_kategorii(transakce: list[dict]) -> dict[str, int]:
soucty = {}
for t in transakce:
if t["kategorie"] == "příjem":
continue
soucty[t["kategorie"]] = soucty.get(t["kategorie"], 0) - t["castka"]
return dict(sorted(soucty.items(), key=lambda par: par[1], reverse=True))
def stav_limitu(utraceno: int, limit: int | None, varovat_od: int = 80) -> str:
if limit is None:
return "bez limitu"
if utraceno > limit:
return "překročeno"
if utraceno * 100 >= limit * varovat_od:
return "pozor"
return "v pořádku"
def prehled(transakce: list[dict], limity: dict[str, int], *, varovat_od: int = 80) -> dict:
prijmy = sum(t["castka"] for t in transakce if t["kategorie"] == "příjem")
vydaje = vydaje_podle_kategorii(transakce)
kategorie = []
for nazev, utraceno in vydaje.items():
limit = limity.get(nazev)
kategorie.append({
"nazev": nazev,
"utraceno": utraceno,
"limit": limit,
"stav": stav_limitu(utraceno, limit, varovat_od),
})
celkem = sum(vydaje.values())
return {"prijmy": prijmy, "vydaje": celkem, "zustatek": prijmy - celkem, "kategorie": kategorie}
def vypis_prehled(nadpis: str, data: dict, chybne: list[str]) -> None:
print(nadpis)
print(f" příjmy {na_kc(data['prijmy']):>14}")
print(f" výdaje {na_kc(data['vydaje']):>14}")
print(f" zůstatek {na_kc(data['zustatek']):>14}")
print()
for k in data["kategorie"]:
limit = "-" if k["limit"] is None else na_kc(k["limit"])
print(f" {k['nazev']:<10}{na_kc(k['utraceno']):>14} z {limit:>14} {k['stav']}")
if chybne:
print()
print("Nepřečtené řádky:")
for radek in chybne:
print(f" {radek}")
transakce, chybne = nacti_vypis(VYPIS)
mesic = "2026-03"
vybrane = vyber(transakce, z_mesice(mesic))
vypis_prehled(f"Rozpočet {mesic}", prehled(vybrane, LIMITY), chybne)
Rozpočet 2026-03 příjmy 45 800,00 Kč výdaje 23 748,90 Kč zůstatek 22 051,10 Kč bydlení 14 500,00 Kč z 15 000,00 Kč pozor jídlo 5 658,90 Kč z 5 000,00 Kč překročeno oblečení 1 890,00 Kč z - bez limitu zábava 1 150,00 Kč z 1 500,00 Kč v pořádku doprava 550,00 Kč z 1 000,00 Kč v pořádku Nepřečtené řádky: 2026-03-14;Kino;zábava;dvě stovky chyba exportu
Jídlo přeteklo, bydlení je v pásmu varování a oblečení limit nemá. Kino a řádek chyba exportu nezmizely, program je vypsal na konec, takže je můžeš opravit ručně.
Program je hotový, ale ještě nekončí. Až projdeš další moduly, můžeš ho rozšířit:
- číst výpis ze souboru a chybné řádky hlásit přes výjimky,
- kontrolovat i datum, protože teď projde cokoli a řádek s datem
14.3.2026by filtr měsíce tiše vynechal, - ukládat limity do JSONu,
- přidat automatické testy, u čistých funkcí to půjde skoro samo.
Pod kapotou · funkcionální jádro, tenká slupka
Výsledná architektura má jméno: functional core, imperative shell. Rozhodování je v čistých funkcích, vstup a výstup v tenké vrstvě kolem. Testy pak nepotřebují mocky ani dočasné soubory, stačí assert prehled(data, limity) == .... Celý průchod je O(n + k log k) pro n transakcí a k kategorií, vyber je v nejhorším O(n * p) pro p podmínek. all s generátorem končí na první nepravdě, takže levné a hodně vylučující podmínky patří dopředu.
Closure ukládá proměnnou, ne její hodnotu (buňky najdeš v f.__closure__). Proto [lambda t: t["kategorie"] == k for k in nazvy] vyrobí funkce, které všechny porovnávají s posledním k. Tovární funkce z_kategorie tomu předchází, protože každé volání má vlastní rámec. Stejnou službu udělá functools.partial, která je navíc introspektovatelná přes .func a .args.
Slovník jako záznam je na téhle velikosti v pohodě, ale překlep v klíči se projeví až za běhu a dict typovému checkeru nic neřekne. Další krok je TypedDict nebo dataclass a pro podmínky alias podle PEP 695: type Podminka = Callable[[Transakce], bool] s Callable z collections.abc. None tu zastupuje výjimku, kterou kurz ještě neprobral. V produkci bys z parseru spíš vracel chybu s důvodem, aby hlášení říkalo, proč řádek neprošel, a ne jen který.
Dvě okrajové věci z domény: vrácení v jiném měsíci než nákup udělá z výdaje kategorie záporné číslo, což stav_limitu vyhodnotí jako v pořádku, ale v grafu to překvapí. A z_mesice("2026-1") díky startswith chytí říjen až prosinec, takže veřejné API by mělo brát rok a měsíc zvlášť nebo formát ověřit.