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)
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)
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"})
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:
BaseException
├── KeyboardInterrupt Ctrl+C
├── SystemExit sys.exit()
└── Exception všechny běžné chyby
├── ArithmeticError
│ └── ZeroDivisionError
├── LookupError
│ ├── IndexError
│ └── KeyError
├── OSError
│ ├── FileNotFoundError
│ └── PermissionError
├── TypeError
└── ValueErrorTakž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í.
Kód má except Exception: a pod ním except ValueError:. V try nastane ValueError. Který blok se spustí?
ValueError je potomek Exception, takže sedí už první blok a druhý se nikdy nespustí. Konkrétnější druhy proto patří nahoru.
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)
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]))
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:
elseproběhne, jen když vtryžádná výjimka nenastala,finallyprobě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")
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í.
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")?
Bez výjimky se except přeskočí, else proběhne a finally proběhne vždy.
Úč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
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()
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)
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"))
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.
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
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__))
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.
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]
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"))
č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ž
trykrá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.
Funkce nacti_radek narazí na špatná data a neví, jestli je má volající přeskočit, nebo zastavit celý import. Co je nejlepší?
Kdo nemá dost informací, ten nerozhoduje. Výjimka předá problém výš, tam kde je známý kontext. Nula by se tiše promítla do výsledků.
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__.