Python Jiří Znamenáček Výjimky, aserce 2011-03-24|2013-03-26

Python patří k jazykům, kde je na reportování (a obsluhu) chyb, ke kterým může v kódu na nejrůznějších místech dojít, vyhrazena mašinérie výjimek. Pár typických příkladů (přímo podle dokumentace):

>>> 10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: int division or modulo by zero >>> 4 + spam*3 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'spam' is not defined >>> '2' + 2 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: Can't convert 'int' object to str implicitly

Výjimky standardně „probublávají“ postupně po hierarchii programu, ale každopádně na konci trasovacího výpisu (stack traceback) bude, kdo a jakou výjimku vyvolal.

Výjimky je možné ošetřovat několika různými způsoby. Ukažme si základní z nich:

Základní použití – odchyť jednotlivé typy výjimek, ke kterým může dojít v BLOKu-1:

try: BLOK-1 except VÝJIMKA-1: BLOK-2 except VÝJIMKA-2: BLOK-3

Odchycení výjimky a předání jejího objektu pod vybraným jménem:

try: BLOK-1 except VÝJIMKA as ex: BLOK-2 # zde je nyní možné použít objekt odchycené výjimky pod jménem 'ex'

Nevyvolá-li kód v BLOKu-1 žádnou výjimku, provede se kód v BLOKu-3:

try: BLOK-1 except: BLOK-2 else: BLOK-3

Kód v BLOKu-3 bude vykonán vždy při opouštění větve try, ať už vyvolala výjimku nebo ne:

try: BLOK-1 except: BLOK-2 finally: BLOK-3 Větve finally se tak používají často pro „vyčišťovací“ kód, typicky pro uzavření otevřených zdrojů apod.

Následující příklad ukazuje základní použití výjimek:

Upraveno podle http://www.swaroopch.com/notes/Python_en:Exceptions
  • Zadáme-li nějaký text a poté odentrujeme, obdržíme následující výsledek:
Enter something --> ahoj You entered "ahoj". Completed.
  • Přerušíme-li zadávání textu pomocí ^C, výstup se změní:
Enter something --> ahoj^C You cancelled the operation. Completed.
  • Konečně zadáme-li místo vstupního textu rovnou EOF, uplatní se ještě jiná větev:
Enter something --> Why did you do an EOF on me? Completed. Na Win10 už nejde zreplikovat. Ani v Ubuntu pod WSX. Ještě zkusit čistý Linux.

Souhrnně tedy platí, že větev finally se provede vždy při opouštění větve try, zatímco větev else se provede pouze tehdy, nedojde-li ve větvi try k vyvolání výjimky.

Je též možné odchytit více výjimek najednou v podobě n-tice:

try: BLOK-1 except (VÝJIMKA-1, VÝJIMKA-2, ...): BLOK-2 Tohle je v ostrém kontrastu s chováním v Python'u 2.x, kde uvedená konstrukce sloužila k zachycení výjimky pod jistým jménem (čili k tomu, co teď mnohem průhledněji a srozumitelněji dělá operátor as).

Samozřejmě zachycení více různých výjimek jedním společným „řešícím“ (problémy) kódem je už speciální aplikace, častěji bude každý typ výjimky obsluhovat tomu určený kód.

Ve skutečnosti nemusíte typ zachycené výjimky ani předepisovat:

try: BLOK-1 except: BLOK-2

Uvedený kód má ale dvě (navzájem spřažené) nevýhody:

Samozřejmě pokud píšete rychlý skript sami pro sebe a potřebujete pouze chybu rozpoznat, je tohle použití zachytávání výjimek nejrychlejší i relativně rozumné. Pokud však budete psát kód produkční, tak do něj nic takového nepatří!

Ač to může na první pohled vypadat nečekaně, poměrně často nebudete chtít ponechat vyvolávání výjimek pouze na vlastním virtuálním počítači, ale budete chtít na základě nějakých událostí vyvolávat výjimky sami (často dokonce i výjimky vlastní a ne pouze předdefinované). K tomu slouží příkaz raise, jehož použití je celkem standardní (přímo podle dokumentace):

Konkrétní výjimku můžete uměle vyvolat:

>>> raise NameError('HiThere') Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: HiThere

Výjimku můžete po jejím odchycení a částečném zpracování předat po hierarchii dále:

>>> try: ... raise NameError('HiThere') ... except NameError: ... print('An exception flew by!') ... raise An exception flew by! Traceback (most recent call last): File "<pyshell#23>", line 2, in <module> raise NameError('HiThere') NameError: HiThere PS: V praxi se ukázalo, že odchytávání výjimek v metodách vlastních objektů a předávání jich dále se bohužel nechová vždy zcela očekávaným způsobem…

Jelikož odchycená výjimka je objekt, má jistou vnitřní strukturu (ať už výchozí nebo uživatelem předefinovanou). Ukažme si několik příkladů:

Standardní výjimky mají nadefinované chování při pokusu o jejich výpis:

>>> try: ... raise NameError('HiThere') ... except NameError as ex: ... print(ex) HiThere To zajišťuje přítomnost „magické“ metody __str__().

Struktura objektu výjimek je ale mnohem složitější:

>>> try: ... raise NameError('HiThere') ... except NameError as ex: ... print( dir(ex) ) ['__cause__', '__class__', '__context__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__', '__traceback__', 'args', 'with_traceback']

Především vidíme, že (standardní) výjimky mohou dostávat argumenty:

>>> try: ... raise Exception('spam', 'eggs') ... except Exception as inst: ... print(type(inst)) # instance výjimky ... print(inst.args) # argumenty výjimky jsou uloženy v parametru '.args' ... print(inst) # díky '__str__' můžeme argumenty vytisknout přímo ... x, y = inst.args # n-ticové rozbalení argumentů ... print('x =', x) ... print('y =', y) <class 'Exception'> ('spam', 'eggs') ('spam', 'eggs') x = spam y = eggs Viz http://docs.python.org/py3k/library/exceptions.html

PS: Struktura standardních výjimek se čas od času mění (výše uvedená je pro verzi 3.10). Například Python 3.2 postrádal celou větev OSError a měl místo ní k dispozici naopak následující větev EnvironmentError: 

      +-- EnvironmentError
           +-- IOError
           +-- OSError
                +-- WindowsError (Windows)
                +-- VMSError (VMS)

Spousta výjimek je zjevně vyrobena jako potomci jiných výjimek, například:

>>> issubclass(ZeroDivisionError, ArithmeticError) True >>> issubclass(ArithmeticError, ZeroDivisionError) False

Vypadá to zdánlivě nevinně, ale jen do té chvíle, než budete v rámci jednoho try-bloku zachytávat výjimky, které jsou na sobě závislé – rodičovská totiž zvítězí, pokud bude uvedena dříve:

V čem je problém? Kdyby náhodou každá z výjimek definovala jinou sadu atributů – pak se vám totiž může stát, že budete chtít pracovat s něčím, co vůbec nedostanete. Standardní výjimky se takhle naštěstí nechovají – potomci funkčnost rodičů jen rozšiřují*:

>>> from urllib.error import HTTPError, URLError >>> issubclass(HTTPError, URLError) True >>> issubclass(URLError, HTTPError) False >>> hs, us = set(dir(HTTPError)), set(dir(URLError)) >>> hs - us {'headers', '__enter__', 'close', '__iter__', '__getattr__', '__exit__', 'getcode', 'reason', 'geturl', '_HTTPError__super_init', 'info'} >>> us - hs set() >>> sorted(hs - us) ['_HTTPError__super_init', '__enter__', '__exit__', '__getattr__', '__iter__', 'close', 'getcode', 'geturl', 'headers', 'info', 'reason'] * Aspoň doufám ^_^'

Kromě výjimek ve standardní hierarchii je další hromada výjimek poschovávaná u svých knihovních modulů, které musíte nejdříve naimportovat, abyste je mohli používat. Jedním příkladem za všechny budižtež právě výjimky modulu urllib z předchozího slajdu:

>>> import urllib.error >>> dir(urllib.error) ['ContentTooShortError', 'HTTPError', 'URLError', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'urllib']

PS: Jich se upozornění na hierarchii týkalo v historii také – zde je rodičem (a tedy obecnější výjimkou) URLError a potomkem (specifičtější výjimkou) s jinými atributy HTTPError.

Samozřejmě kromě výše uvedených předdefinovaných výjimek si můžete nadefinovat výjimky vlastní. Typicky to budou potomci třídy Exception a není-li třeba, postačí velmi jednoduché, např.:

class MyError(Exception): pass

Ve složitějších případech můžete nadefinovat vlastní hierarchii výjimek a i předefinovat jejich výchozí chování. Konstruktor základní výjimky Exception má totiž zcela generický tvar __init__(self, /, *args, **kwargs), přičemž výchozí chování metody __str__() je přepsat na výstup vstupní parametry instance výjimky (jako n-tici).

Ukázka přímo z dokumentace: class Error(Exception): """Base class for exceptions in this module.""" pass class InputError(Error): """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """ def __init__(self, expression, message): self.expression = expression self.message = message class TransitionError(Error): """Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """ def __init__(self, previous, next, message): self.previous = previous self.next = next self.message = message

Kromě výjimek, které slouží především k odchytávání chyb v běžících a již nasazených programech, máme v Python'u k dispozici i standardní ladicí prostředek – příkaz assert. Kromě plného použití v rámci testování nachází uplatnění i při rychlém odchytávání chyb při ladění programu.

Při spuštění interpretru s parametrem -O jsou příkazy assert „odstraněny“.

Struktura příkazu assert je..

assert VÝRAZ [, ARGUMENT]

..a v podstatě odpovídá následujícímu kódu:

if not VÝRAZ: raise AssertionError(ARGUMENT) Ve skutečnosti jeho vykonání řídí ještě obsah proměnné __debug__ – při spuštění interpretru s parametrem -O je do ní uloženo False a uvedené asertovací části kódu jsou pak vynechány.

Použití ilustruje následující příklad:

>>> xs = [1, 2, 3] # A) Tohle je pravda, není co řešit: >>> assert len(xs) == 3 # B1) Tohle pravda ale není: >>> assert len(xs) == 2 Traceback (most recent call last): File "<pyshell#31>", line 2, in <module> assert len(xs) == 2 AssertionError # B2) Tohle také není pravda. Navíc přidáme komentář: >>> assert len(xs) == 2, 'Špatný počet argumentů!' Traceback (most recent call last): File "<pyshell#32>", line 2, in <module> assert len(xs) == 2, 'Špatný počet argumentů!' AssertionError: Špatný počet argumentů! # B2) Nebo ještě víc údajů: >>> assert len(xs) == 2, ('Špatný počet argumentů!', len(xs) ) Traceback (most recent call last): File "<pyshell#33>", line 2, in <module> assert len(xs) == 2, ('Špatný počet argumentů!', len(xs) ) AssertionError: ('Špatný počet argumentů!', 3)

Příklad – kontrola vstupních parametrů:

Obecně jsou funkce v Python'u psány tak, aby příslušný kód vykonaly pro jakýkoliv vstup, pro který dává smysl (aka „duck-typing“). Ale někdy můžete potřebovat vstupní typy omezit na úzkou podmnožinu. Ve staticky typovaném jazyce by tato kontrola byla automatická, ale v Python'u ji musíme nějak dopsat. S výhodou k tomu můžeme využít právě příkaz assert.

Samozřejmě před pádem programu ve chvíli, kdy interpretr při vykonávání programu narazí na špatný vstup, nás to nezachrání. Ale usnadní nám to ladění nebo alespoň dá uživateli srozumitelnější formou najevo, kde a proč došlo k chybě.

Pár příkladů:

# vracet druhou mocninu má smysl pouze číselné typy def druhá_mocnina(x): assert type(x) == int or type(x) == float or type(x) == complex return x*x
# 'fn' musí být volatelný typ (typicky funkce) # 'xs' musí být iterovatelný typ (typicky seznam) def mymap(fn, xs): assert callable(fn) == True # isinstance(fn, collections.Callable) assert isinstance(xs, collections.Iterable) return [fn(x) for x in xs]
# vektor ve 3D-prostoru musí mít právě tři souřadnice def délka_3D_vektoru(vektor): assert len(vektor) == 3 x, y, z = vektor return math.sqrt( x**2 + y**2 + z**2 )

Kromě výjimek obsahuje Python i jejich „vyměkčenou“ verzi v podobě varování. Ta v základním nastavení nezpůsobí havárii programu, pouze na výstup (typicky chybový) nahlásí příslušnou informaci.

Protože jejich obsluha je dosti obsáhlá a z principu z větší části jiná než u výjimek, je jim věnována samostatná kapitola.