0 dní v řadě · 0 bodů

Soubory, chyby a knihovny · 22 min

Výjimky: try, except, raise

Naučíš se zachytit chybu, aby program nespadl, ohlásit problém přes raise a poznat, kdy je lepší chybu nechat projít.

Hloubka
Úkoly
Lidsky řečeno

Kuchař sáhne do lednice pro vejce a lednice je prázdná. Nebude dál šlehat vzduch. Přeruší práci a zavolá: „Nejsou vejce!“ Když ví, co s tím, pošle někoho do obchodu. Když ne, volání putuje k šéfovi směny a pak k majiteli. A když si neporadí nikdo, restaurace pro dnešek zavře. Přesně takhle v Pythonu cestuje výjimka.

Jedna špatná hodnota a konec

Máš seznam cen vyexportovaný z e-shopu. Ceny jsou text a chceš je sečíst. Jenže někdo do jednoho políčka napsal vlastní poznámku.

ceny = ["120", "89", "kolem stovky", "45"]
soucet = 0
for cena in ceny:
    soucet += int(cena)
    print("Zatím:", soucet)
print("Celkem:", soucet)
Výstup
Zatím: 120
Zatím: 209

Dva průběžné součty se vypsaly, třetí cena program zastavila a na Celkem se vůbec nedostalo. Funkce int nedokáže z textu kolem stovky udělat číslo, a tak vytvoří výjimku: objekt, který nese druh problému (ValueError) a popis.

Python v tu chvíli přestane dělat to, co dělal, a hledá někoho, kdo se o výjimku postará. Když nikoho nenajde, vypíše hlášení, které znáš z lekce Jak číst chybové hlášky, a program skončí.

try a except: plán B

Riskantní kód dáš do bloku try. Do bloku except napíšeš, co se má stát, když se objeví určitý druh výjimky.

ceny = ["120", "89", "kolem stovky", "45"]
soucet = 0
for cena in ceny:
    try:
        soucet += int(cena)
    except ValueError:
        print("Přeskakuji:", cena)
print("Celkem:", soucet)
Výstup
Přeskakuji: kolem stovky
Celkem: 254

Jakmile v try nastane výjimka, zbytek bloku se přeskočí a Python skočí do odpovídajícího except. Potom pokračuje normálně za celou konstrukcí. Cyklus tedy běží dál a čtvrtá cena se započítá.

Jeden try může mít víc except, pro každý druh problému jiný. Zápis as e uloží výjimku do proměnné, takže se dostaneš k jejímu popisu.

def vypis_cenu_za_kus(objednavka):
    try:
        cena = int(objednavka["cena"]) / int(objednavka["kusy"])
        print("Za kus:", cena)
    except KeyError as e:
        print("V objednávce chybí údaj:", e)
    except ValueError as e:
        print("Špatné číslo:", e)
    except ZeroDivisionError:
        print("Objednávka má nula kusů.")

vypis_cenu_za_kus({"cena": "100", "kusy": "4"})
vypis_cenu_za_kus({"cena": "100"})
vypis_cenu_za_kus({"cena": "sto", "kusy": "4"})
vypis_cenu_za_kus({"cena": "100", "kusy": "0"})
Výstup
Za kus: 25.0
V objednávce chybí údaj: 'kusy'
Špatné číslo: invalid literal for int() with base 10: 'sto'
Objednávka má nula kusů.

Výjimky tvoří rodokmen. except zachytí zadaný druh i všechny jeho potomky. Tohle je jeho nejpoužívanější část:

text
BaseException
├── KeyboardInterrupt        Ctrl+C
├── SystemExit               sys.exit()
└── Exception                všechny běžné chyby
    ├── ArithmeticError
    │   └── ZeroDivisionError
    ├── LookupError
    │   ├── IndexError
    │   └── KeyError
    ├── OSError
    │   ├── FileNotFoundError
    │   └── PermissionError
    ├── TypeError
    └── ValueError

Takže except LookupError chytí KeyError i IndexError. Víc druhů najednou zapíšeš jako n-tici: except (KeyError, ValueError):. Python zkouší bloky except shora dolů a použije první, který sedí.

Kvíz

Kód má except Exception: a pod ním except ValueError:. V try nastane ValueError. Který blok se spustí?

Úkol

Převod bez pádu

Napiš funkci na_cislo(text). Když jde text převést na celé číslo, vrátí ho. Když ne, vrátí None. Zachyť jen ValueError, jiné chyby mají projít dál.

def na_cislo(text):
    return int(text)
Výstup

Tady se v názvu proměnné skrývá překlep. Program nespadne, jen tiše lže.

def prumer(cisla):
    try:
        return sum(cisla) / len(cizla)
    except Exception:
        return 0

print(prumer([10, 20, 30]))
Výstup
0

Průměr má být 20. Překlep cizla vyvolal NameError a except z něj udělal nenápadnou nulu. Se správným except ZeroDivisionError by program hned ukázal, kde je problém.

Pod kapotou · co se děje s proměnnou e

Na konci bloku except X as e Python jméno e smaže, jako by tam stálo e = None; del e. Výjimka totiž přes __traceback__ drží rámec funkce a rámec by přes e držel výjimku. Vznikl by cyklus a s ním by v paměti zůstaly všechny lokální proměnné, dokud nepřijde cyklický garbage collector. Kdo výjimku uloží do jiné proměnné pro pozdější použití, tenhle cyklus vyrobí znovu.

KeyboardInterrupt, SystemExit a GeneratorExit dědí přímo z BaseException, aby je except Exception nezachytil. Od Pythonu 3.8 tam patří i asyncio.CancelledError, takže široký except Exception nerozbije rušení úloh. except Exception má své místo na hranici systému, třeba v hlavní smyčce workeru, kde jedna vadná zpráva nesmí shodit celý proces. Tam ale výjimku vždy zaloguj i s tracebackem.

else a finally

Blok try může mít ještě dvě části:

  • else proběhne, jen když v try žádná výjimka nenastala,
  • finally proběhne vždy, ať se stalo cokoli. Patří do něj úklid.
def nacti(text):
    print("vstup:", text)
    try:
        cislo = int(text)
    except ValueError:
        print("  except: to není číslo")
    else:
        print("  else: dvojnásobek je", cislo * 2)
    finally:
        print("  finally: končím s tímhle vstupem")

nacti("21")
nacti("abc")
Výstup
vstup: 21
  else: dvojnásobek je 42
  finally: končím s tímhle vstupem
vstup: abc
  except: to není číslo
  finally: končím s tímhle vstupem

Proč nedat výpočet rovnou do try? Protože try má obsahovat jen to, od čeho chybu čekáš. Kdyby se ValueError objevil v dalším výpočtu, omylem bys ho vydával za špatný vstup. Blok finally proběhne i tehdy, když try skončí přes return nebo když výjimku nikdo nezachytí.

Kvíz

Co se vypíše, když v try proběhne print("A") bez chyby a následují bloky except s print("B"), else s print("C") a finally s print("D")?

Úkol

Účetní, který nepadá

Napiš funkci secti_platne(texty). Dostane seznam textů a vrátí dvojici (soucet, chybne): součet všech hodnot, které jdou převést na celé číslo, a seznam těch, které nejdou, v původním pořadí.

def secti_platne(texty):
    soucet = 0
    chybne = []
    # doplň cyklus
    return soucet, chybne
Výstup

Cesta výjimky přes funkce

Výjimka se nemusí řešit tam, kde vznikla. Když ji funkce nezachytí, okamžitě skončí a výjimka vyskočí k tomu, kdo funkci zavolal. A tak dál, dokud ji někdo nechytí.

def prevod(text):
    print("prevod: začínám")
    hodnota = int(text)
    print("prevod: hotovo")
    return hodnota

def zpracuj_radek(radek):
    print("zpracuj_radek: začínám")
    vysledek = prevod(radek) * 2
    print("zpracuj_radek: hotovo")
    return vysledek

def hlavni():
    try:
        print(zpracuj_radek("x"))
    except ValueError:
        print("hlavni: tenhle řádek přeskočím")

hlavni()
Výstup
zpracuj_radek: začínám
prevod: začínám
hlavni: tenhle řádek přeskočím

Ani jedno hotovo se nevypsalo. Obě funkce skončily uprostřed a výjimka doletěla až do hlavni.

To je výhoda. Funkce prevod neví, jestli se má špatný řádek přeskočit, nahlásit uživateli, nebo zastavit celý import. Ví to až kód nahoře. Chytej výjimku tam, kde s ní umíš něco rozumného udělat.

raise: ohlas problém sám

Výjimky nemusí vznikat jen v Pythonu. Když tvoje funkce dostane nesmysl, vyvolá výjimku příkazem raise.

def sleva(cena, procenta):
    if not 0 <= procenta <= 100:
        raise ValueError(f"Sleva musí být 0 až 100 %, přišlo {procenta}.")
    return cena * (100 - procenta) / 100

print(sleva(1000, 15))
try:
    print(sleva(1000, 150))
except ValueError as e:
    print("Odmítnuto:", e)
Výstup
850.0
Odmítnuto: Sleva musí být 0 až 100 %, přišlo 150.

Proč nevrátit třeba None nebo -1? Protože takovou hodnotu může volající přehlédnout a počítat s ní dál. Výjimku přehlédnout nejde. Druh vyber podle problému: ValueError pro správný typ se špatnou hodnotou, TypeError pro úplně špatný typ.

Někdy chceš o chybě jen vědět, ale vyřešit ji má někdo jiný. Samotné raise v bloku except pošle stejnou výjimku dál.

def nacti_vek(text):
    try:
        return int(text)
    except ValueError:
        print("Do deníku zapisuji špatný vstup:", repr(text))
        raise

print(nacti_vek("30"))
print(nacti_vek("třicet"))
Výstup
30
Do deníku zapisuji špatný vstup: 'třicet'

Funkce repr vypíše text i s uvozovkami, takže v deníku poznáš i prázdný vstup nebo mezeru navíc. Po zápisu výjimka letí dál a program skončí, protože ji nikdo další nezachytil.

Úkol

Bankomat

Napiš funkci vyber(zustatek, castka), která vrátí nový zůstatek. Když je castka nulová nebo záporná, nebo je větší než zustatek, vyvolej ValueError se srozumitelnou zprávou.

def vyber(zustatek, castka):
    return zustatek - castka
Výstup

Vlastní druh výjimky se hodí, když chceš volajícímu umožnit chytit právě tvůj problém. Třídy přijdou až v modulu Objekty, zatím ti stačí dva řádky níže jako hotový vzor. Zápis raise ... from e k nové výjimce připojí původní příčinu.

class ChybaObjednavky(Exception):
    pass

CENIK = {"káva": 65, "čaj": 50}

def cena(polozka):
    try:
        return CENIK[polozka]
    except KeyError as e:
        raise ChybaObjednavky(f"Položku {polozka!r} nemáme v ceníku.") from e

print(cena("káva"))
try:
    cena("pivo")
except ChybaObjednavky as e:
    print("Zpráva:", e)
    print("Příčina:", repr(e.__cause__))
Výstup
65
Zpráva: Položku 'pivo' nemáme v ceníku.
Příčina: KeyError('pivo')

Volající nemusí vědět, že ceník je zrovna slovník. Kdyby se později přesunul do databáze, KeyError by zmizel, ale ChybaObjednavky zůstane. Zápis !r ve f-stringu dělá totéž co repr.

Úkol

Vlastní výjimka

Doplň funkci email_uzivatele(adresar, jmeno). Vrátí e-mail ze slovníku adresar. Když tam jméno není, vyvolá NeznamyUzivatel a ve zprávě bude to jméno.

class NeznamyUzivatel(Exception):
    pass

def email_uzivatele(adresar, jmeno):
    return adresar[jmeno]
Výstup

Zeptat se, nebo to zkusit?

Stejný problém jde řešit třemi způsoby. Můžeš se předem zeptat, můžeš to zkusit a reagovat na chybu, nebo použít nástroj, který s chybějící hodnotou počítá.

sklad = {"káva": 3}

if "čaj" in sklad:
    print(sklad["čaj"])
else:
    print("čaj nemáme")

try:
    print(sklad["čaj"])
except KeyError:
    print("čaj nemáme")

print(sklad.get("čaj", "čaj nemáme"))
Výstup
čaj nemáme
čaj nemáme
čaj nemáme

Když existuje hotová cesta jako dict.get, použij ji. Jinak platí pár pravidel:

  • Chytej co nejkonkrétnější druh výjimky.
  • Drž try krátký, jen kolem kódu, od kterého chybu čekáš.
  • Chytej tam, kde víš, co dál. Jinak výjimku nech letět.
  • Nikdy nepiš prázdné except: pass, pokud nemáš dobrý důvod a komentář, který ho vysvětluje.
  • Chyba programátora, třeba NameError, se opravuje v kódu. Nechytá se.

Program, který nahlas spadne, opravíš za chvíli. Program, který potichu počítá špatně, můžeš hledat týdny.

Kvíz

Funkce nacti_radek narazí na špatná data a neví, jestli je má volající přeskočit, nebo zastavit celý import. Co je nejlepší?

Pod kapotou · cena výjimek, řetězení a skupiny

Cena. Od CPythonu 3.11 je vstup do try prakticky zdarma. Místo instrukce, která dřív ukládala blok na zásobník, kompilátor vytvoří tabulku výjimek (co_exceptiontable, ukáže ji python -m dis). Drahý je až samotný raise: vytvoření objektu, tracebacku a hledání obsluhy. Proto je try výhodný, když je chyba vzácná. Když klíč chybí často, vyhraje in nebo dict.get. U souborů a sdíleného stavu navíc dotaz předem nestačí, protože se situace může změnit mezi dotazem a akcí (TOCTOU).

Řetězení. raise X uvnitř except nastaví X.__context__ a traceback vypíše „During handling of the above exception...“. raise X from e nastaví __cause__ a text říká, že jedna chyba je přímou příčinou druhé. raise X from None nastaví __suppress_context__ a původní výjimku ve výpisu skryje, v __context__ ale zůstává.

Past ve finally. return ve finally zahodí právě letící výjimku. Python 3.14 na to podle PEP 765 upozorňuje SyntaxWarning.

Python 3.11+. e.add_note("...") (PEP 678) přidá k výjimce kontext bez změny typu. ExceptionGroup a except* (PEP 654) nesou několik nezávislých chyb najednou, typicky z asyncio.TaskGroup.

Chyba z produkce. Výjimka s vlastním __init__(self, a, b), který volá super().__init__(f"{a} {b}"), se špatně pickluje. Při obnově se volá třída s self.args, tedy s jedním argumentem, a v multiprocessing místo původní chyby dostaneš matoucí TypeError. Předej do super().__init__ stejné argumenty, nebo definuj __reduce__.