>>> def fetcher(obj, index):
...    return obj[index]
...


>>> x = 'mielonka'
>>> fetcher(x, 3)                            # Jak x[3]
'l'


>>> fetcher(x, 8)
Traceback (most recent call last):
   File "<stdin>", line 1, in ?
   File "<stdin>", line 2, in fetcher
IndexError: string index out of range


>>> try:
...   fetcher(x, 4)
... except IndexError:
...   print 'mam wyjątek'
...
mam wyjątek
>>>


>>> def catcher( ):
...    try:
...       fetcher(x, 4)
...    except IndexError:
...       print 'mam wyjątek'
...    print 'kontynuuję'
...
>>> catcher( )
mam wyjątek
kontynuuję
>>>


>>> bad = 'źle'
>>> try:
...    raise bad
... except bad:
...    print 'przechwycenie bad'
...
przechwycenie bad


>>> raise bad
Traceback (most recent call last):
   File "<pyshell#18>", line 1, in ?
      raise bad
źle


>>> class Bad(Exception): pass
...
>>> def doomed( ): raise Bad( )
...
>>> try:
...    doomed( )
... except Bad:
...    print 'przechwycenie Bad'
...
przechwycenie Bad
>>>


>>> try:
...    fetcher(x, 3)
... finally:
...    print 'po pobraniu'
...
'l'
po pobraniu


fetcher(x, 3)
print 'po pobraniu'


>>> def after( ):
...    try:
...       fetcher(x, 8)
...    finally:
...       print 'po pobraniu'
...    print 'po try?'
...
>>> after( )
po pobraniu
Traceback (most recent call last):
   File "<stdin>", line 1, in ?
   File "<stdin>", line 3, in after
   File "<stdin>", line 2, in fetcher
IndexError: string index out of range


>>> def after( ):
...    try:
...       fetcher(x, 3)
...    finally:
...       print 'po pobraniu'
...    print 'po try?'
...
>>> after( )
po pobraniu
po try?
>>>


try:
   <instrukcje>                              # Wykonanie najpierw tego działania
except <name1>:
   <statements>                              # Wykonane, jeśli name1 zostanie zgłoszony w bloku try
except <name2>, <dane>:
   <instrukcje>                              # Wykonane, jeśli name2 zostaje zgłoszony, i otrzymuje dodatkowe dane
except (name3, name4):
   <instrukcje>                              # Wykonane, kiedy wystąpi jeden z tych wyjątków
except:
   <instrukcje>                              # Wykonane dla wszystkich pozostałych zgłoszonych wyjątków
else:
   <instrukcje>                              # Wykonane, jeśli żaden wyjątek nie został zgłoszony w bloku try


try:
   action( )
except NameError:
   ...
except IndexError
   ...
except KeyError:
   ...
except (AttributeError, TypeError, SyntaxError):
   ...
else:
   ...


try:
   action( )
except NameError:
   ...                                       # Obsługa NameError
except IndexError:
   ...                                       # Obsługa IndexError
except:
   ...                                       # Obsługa wszystkich pozostałych wyjątków
else:
   ...


try:
   action( )
except:
   ...                                       # Przechwytuje wszystkie możliwe wyjątki


try:
   ...wykonanie kodu...
except IndexError:
   ...obsłużenie wyjątku...
# Czy trafiliśmy tutaj dlatego, że instrukcja try się nie powiodła, czy wręcz przeciwnie?


try:
   ...wykonanie kodu...
except IndexError:
   ...obsłużenie wyjątku...
else:
   ...wyjątek nie wystąpił...


try:
   ...wykonanie kodu...
   ...wyjątek nie wystąpił...
except IndexError:
   ...obsłużenie wyjątku...


# Plik bad.py

def gobad(x, y):
   return x / y

def gosouth(x):
   print gobad(x, 0)

gosouth(1)   
   
   
% python bad.py
Traceback (most recent call last):
   File "bad.py", line 7, in <module>
      gosouth(1)
   File "bad.py", line 5, in gosouth
      print gobad(x, 0)
   File "bad.py", line 2, in gobad
      return x / y
ZeroDivisionError: integer division or modulo by zero
   
   
def kaboom(x, y):
   print x + y                               # Wywołanie TypeError

try:
   kaboom([0,1,2], "mielonka")
except TypeError:                            # Przechwycenie błędu i poradzenie sobie z nim
   print 'Witaj, świecie!'
print 'wznowienie tutaj'                     # Kontynuacja bez względu na wystąpienie wyjątku   
   
   
try:
   <instrukcje>                              # Wykonanie najpierw tego działania
finally:
   <instrukcje>                              # Zawsze wykonuje ten kod na wyjściu  
   

class MyError(Exception): pass

def stuff(file):
   raise MyError( )

file = open('data', 'w')                     # Otwarcie pliku wyjścia
try:
   stuff(file)                               # Zgłoszenie wyjątku
finally:
   file.close( )                             # Zawsze zamykanie pliku w celu wyczyszczenia bufora wyjścia
...                                          # Kontynuacja tutaj tylko jesli nie ma wyjątku


try:
   podstawowe_działanie
except Exception1:
   program_obsługi_1
except Exception2:
   program_obsługi_2
...
else:
   blok_else
finally:
   blok_finally


try:
   try:
      podstawowe_działanie
   except Exception1:
      program_obsługi_1
   except Exception2:
      program_obsługi_2
   ...
   else:
      bez_błędu
finally:
   czyszczenie


# Plik mergedexc.py

# -*- coding: utf-8 -*-
print '-' * 50, '\nWYJĄTEK ZGŁOSZONY I PRZECHWYCONY'
try:
   x = 'spam'[99]
except IndexError:
   print 'wykonano except'
finally:
   print 'wykonano finally'
print 'po wykonaniu'

print '-' * 50, '\nWYJĄTEK NIE ZOSTAŁ ZGŁOSZONY'
try:
   x = 'spam'[3]
except IndexError:
   print 'wykonano except'
finally:
   print 'wykonano finally'
print 'po wykonaniu'

print '-' * 50, '\nWYJĄTEK NIE ZOSTAŁ ZGŁOSZONY, WYKONANO ELSE'
try:
   x = 'spam'[3]
except IndexError:
   print 'wykonano except'
else:
   print 'wykonano else'
finally:
   print 'wykonano finally'
print 'po wykonaniu'

print '-' * 50, '\nWYJĄTEK ZGŁOSZONY, ALE NIEPRZECHWYCONY'
try:
   x = 1 / 0
except IndexError:
   print 'wykonano except'
finally:
   print 'wykonano finally'
print 'po wykonaniu'


--------------------------------------------------
WYJĄTEK ZGŁOSZONY I PRZECHWYCONY
wykonano except
wykonano finally
po wykonaniu
--------------------------------------------------
WYJĄTEK NIE ZOSTAŁ ZGŁOSZONY
wykonano finally
po wykonaniu
--------------------------------------------------
WYJĄTEK NIE ZOSTAŁ ZGŁOSZONY, WYKONANO ELSE
wykonano else
wykonano finally
po wykonaniu
--------------------------------------------------
WYJĄTEK ZGŁOSZONY, ALE NIEPRZECHWYCONY
wykonano finally
Traceback (most recent call last):
   File "mergedexc.py", line 33, in <module>
      x = 1 / 0
ZeroDivisionError: integer division or modulo by zero


raise <nazwa>                                # Ręczne wywołanie wyjątku
raise <nazwa>, <dane>                        # Przekazanie dodatkowych danych do programu obsługi
raise                                        # Ponowne zgłoszenie ostatniego wyjątku


class MyBad: pass

def stuff( ):
   raise MyBad( )                            # Ręczne wywołanie wyjątku

try:
   stuff( )                                  # Zgłasza wyjątek
except MyBad:
   print 'mam go'                            # Tutaj obsługa wyjątku
...                                          # Tutaj wznowienie wykonywania


# Plik raisedata.py

# -*- coding: utf-8 -*-
myException = 'Błąd'                         # Obiekt łańcucha znaków

def raiser1( ):
   raise myException, "witam"                # Zgłoszenie, przekazanie danych

def raiser2( ):
   raise myException                         # Zgłoszenie wyjątku, domniemane None

def tryer(func):
   try:
      func( )
   except myException, extraInfo:            # Wykonanie func; przechwycenie wyjątku i danych
      print 'mam to:', extraInfo

% python
>>> from raisedata import *
>>> tryer(raiser1)                           # Jawnie przekazane dane dodatkowe
mam to: witam
>>> tryer(raiser2)                           # Dane dodatkowe to domyślnie None
mam to: None


>>> try:
...    raise IndexError, 'mielonka'
... except IndexError:
...    print 'przekazywanie'
...    raise
...
przekazywanie
Traceback (most recent call last):
   File "<stdin>", line 2, in ?
IndexError: mielonka


assert <test>, <dane>                        # Część <dane> jest opcjonalna


if __debug__:
   if not <test>:
      raise AssertionError, <dane>


# Plik asserter.py

# -*- coding: utf-8 -*-
def f(x):
   assert x < 0, 'x musi być ujemne'
   return x ** 2

% python
>>> import asserter
>>> asserter.f(1)
Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   File "asserter.py", line 3, in f
      assert x < 0, 'x musi być ujemne'
AssertionError: x musi być ujemne


def reciprocal(x):
   assert x != 0                             # Bezużyteczna instrukcja assert!
   return 1 / x                              # Python automatycznie sprawdza dzielenie przez zero


from __future__ import with_statement


with wyrażenie [as zmienna]:
   blok_with


with open(r'C:\python\scripts') as myfile:
   for line in myfile:
      print line
      line = line.replace('mielonka', 'MIELONKA')
      ...tutaj więcej kodu...


lock = threading.Lock( )
with lock:
   # kluczowy fragment kodu
   ...dostęp do współdzielonych zasobów...


# Plik withas.py

# -*- coding: utf-8 -*-
from __future__ import with_statement        # Wymagane w Pythonie 2.5

class TraceBlock:
   def message(self, arg):
      print 'wykonywanie', arg
   def __enter__(self):
      print 'rozpoczęcie bloku with'
      return self
   def __exit__(self, exc_type, exc_value, exc_tb):
      if exc_type is None:
         print 'normalne wyjście\n'
      else:
         print 'zgłoszenie wyjątku!', exc_type
         return False                        # Przekazanie

with TraceBlock( ) as action:
   action.message('test 1')
   print 'osiągnięty'

with TraceBlock( ) as action:
   action.message('test 2')
   raise TypeError
   print 'nie został osiągnięty'


% python withas.py
rozpoczęcie bloku with
wykonywanie test 1
osiągnięty
normalne wyjście

rozpoczęcie bloku with
wykonywanie test 2
zgłoszenie wyjątku! <type 'exceptions.TypeError'>
Traceback (most recent call last):
   File "withas.py", line 23, in <module>
      raise TypeError
TypeError


# Ramka "Znaczenie sprawdzania błędów"

doStuff( )
{                                            # Program w języku C
   if (doFirstThing( ) == ERROR)             # Wykrywa błędy wszędzie
      return ERROR;                          # nawet jeśli nie są tu obsłużone
   if (doNextThing( ) == ERROR)
      return ERROR;
   ...
   return doLastThing( );
}

main( )
{
   if (doStuff( ) == ERROR)
      badEnding( );
   else
      goodEnding( );
}


def doStuff( ):                              # Kod w Pythonie
   doFirstThing( )                           # Nie przejmujemy się wyjątkami
   doNextThing( )                            # więc nie musimy ich wykrywać
   ...
   doLastThing( )

if __name__ == '__main__':
   try:
      doStuff( )                             # Tu martwimy się o wyniki
   except:                                   # więc jest to jedyne miejsce, które musimy sprawdzić
      badEnding( )
   else:
      goodEnding( )
