0 dní v řadě · 0 bodů

Funkce · 45 min

Mise: správce rozpočtu

Z malých funkcí postavíš správce rozpočtu: přečteš výpis z banky, spočítáš výdaje na haléř přesně a ohlídáš limity kategorií.

Hloubka
Úkoly
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í.

text
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 exportu

Jedna 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
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
obrazovka

Jedině 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)
Výstup
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"))
Výstup
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"))
Výstup
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())
Výstup
1249,50
('1249', ',', '50')
('1249', '', '')
50 00 50
True False False

V 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

Ú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ž koruny nejsou samé číslice, vrať None,
  • když doplněné halere nejsou samé číslice nebo nemají přesně dva znaky, vrať None (tím odmítneš třeba 12,345),
  • jinak vrať znamenko * (koruny * 100 + halere), obojí převedené na int.
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"))
Výstup
Roztřiď

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}")
Výstup
(1249, 50)
(-1250, 50)
124950
1,234,567
1 234 567
05
Úkol

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

Proč je v převodu znaménko řešené zvlášť a nestačí int("-0") * 100 + 50?

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")
Výstup
not castka: nula vypadá jako chyba
is None: nula je v pořádku
Úkol

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

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

Ú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")))
Výstup
Kvíz

Co vrátí vyber(pohyby), když nezadáš žádnou podmínku?

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

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

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?

Najdi chybu

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ýstup
v pořádku
pozor
pozor
překročeno
pozor
bez limitu
Úkol

Ú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 kategorie příjem,
  • vydaje: součet všech výdajů z vydaje_podle_kategorii,
  • zustatek: příjmy minus výdaje,
  • kategorie: seznam slovníků s klíči nazev, utraceno, limit a stav, ve stejném pořadí jako výdaje. Kategorie bez limitu má limit rovný 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}))
Výstup

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)
Výstup
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.2026 by 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.