*** Strona 205 *******************************************************************

% cat bad.py
def gobad(x, y):
    return x / y

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

gosouth(1)

% python bad.py
Traceback (innermost last):
  File "bad.py", line 7, in ?
    gosouth(1)
  File "bad.py", line 2, in global
    return x / y
ZeroDivisionError: integer or modulo


*** Strona 206 *******************************************************************

def kaboom(list, n):
    print list[n]           # wyzwala IndexError

try:
    kaboom([0, 1, 2], 3)
except IndexError:          # w tym miejscu wychwycenie wyjtku
    print 'Hello world!'


MyError = "my error"

def stuff(file):
    raise MyError

file = open('data', 'r')         # otwiera istniejcy plik
try:
    stuff(file)                  # tu powstaje wyjtek
finally:
    file.close()                 # zawsze zamyka plik


*** Strona 207 *******************************************************************

while 1:
    try:
        wiersz = raw_input()     # odczyt wiersza z stdin
    except EOFError:
        break                    # wyjcie z ptli na kocu pliku
    else:
        ... W tym miejscu przetwarzany jest 'wiersz'


Found = "Pozycja znaleziona"

def searcher():
    generacja wyjtku Found lub return

try:
    searcher()
except Found:           # wyjtek, jeeli pozycja zostaa znaleziona
    Powodzenie
else:                   # zwrcone else: nie znaleziona
    Niepowodzenie


try:
    Uruchomienie programu
except:                   # tutaj przychodz wszystkie nie wyapane wyjtki
    import sys
    print 'nie wychwycony!', sys.exc_type, sys.exc_value


*** Strona 209 *******************************************************************

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


*** Strona 209-210 ***************************************************************

# plik nestexc.py

def action2():
    print 1 + []            # generuje wyjtek TypeError

def action1():
    try:
        action2()
    except TypeError:       # najnowsze dopasowanie try
        print 'inner try'

try:
    action1()
except TypeError:           # tutaj, jeeli action1 wystpio ponownie 
    print 'outer try'

% python nestexc.py
inner try


# plik finally.py

def divide(x, y):
    return x / y                   # bd w dzieleniu przez zero?

def tester(y):
    try:
        print divide(8, y)
    finally:
        print 'na koniec...'

print '\nTest 1:'; tester(2)
print '\nTest 2:'; tester(0)       # wyzwalanie bdu

% python finally.py

Test 1:
4
na koniec...
Test 2:
na koniec...
Traceback (innermost last):
  File "finally.py", line 11, in?
    print 'Test 2:'; tester(0)
  File "finally.py", line 6, in tester
    print divide(8, y)
  File "finally.py", line 2, in divide
    return x / y                   # bd dzielenia przez zero?
ZeroDivisionError: integer division or modulo


*** Strona 211 *******************************************************************

# plik helloexc.py

myException = 'Error'                 # obiekt acuchowy

def raiser1():
    raise myException, "hello"        # powstaje wyjtek, przekazuje dane

def raiser2():
    raise myException                 # powstaje wyjtek, przekazuje None 

def tryer(func):
    try:
        func()
    except myException, extraInfo:    # start func, wyapuje wyjtek + dane
        print 'mam to:', extraInfo

% python
>>> from helloexc import *
>>> tryer(raiser1)                    # uzyskuje przekazane dane dodatkowe
mam to: hello
>>> tryer(raiser2)                    # domylnie uzyskujemy None 
mam to: None


*** Strona 212 *******************************************************************

def doStuff():
     robicPierwszaRzecz()   # w tym miejscu nie dbamy o wyjtki
     robicNastepnaRzecz()   # a wic nie musimy ich tutaj wykrywa
     ...
     robicOstatniaRzecz()

if __name__ == '__main__':
     try:
          doStuff()         # oto gdzie dbamy o wynik
     except:                # jest to jedyne miejsce, gdzie musimy 
                               sprawdza
           zleZakonczenie()
     else:
          dobreZakonczenie()


*** Strona 214 *******************************************************************

# plik classexc.py

class General:           pass
class Specific(General): pass

def raiser1():
    X = General()         # powstaje egzemplarz wpisanej klasy
    raise X

def raiser2():
    X = Specific()        # powstaje egzemplarz klasy podrzdnej
    raise X

for func in (raiser1, raiser2):
    try:
        func()
    except General:       # dopasowuje General lub jej inn klas podrzdn
         import sys
         print 'wychwycono:', sys.exc_type

% python classexc.py
wychwycono: <class General at 881ee0>
wychwycono: <class Specific at 881100>


*** Strona 215-217 ***************************************************************

>>> ex1 = "mielonka"
>>> ex2 = "mielonka"
>>>
>>> ex1 == ex2, ex1 is ex2
(1, 0)

>>> try:
...     raise ex1
... except ex1:
...     print 'mam to'
...
mam to

>>> try:
...     raise ex1
... except ex2:
...     print 'Got it'
...
Traceback (innermost last):
  File "<stdin>", line 2, in ?
mielonka



try:
    ...
except:
    ...    # wszystko dociera tutaj!

try:
    x= mojlsownik[mielonka]   # aha, bdnie wpisane
except:
    x = None                  # zakadamy, e mamy KeyError albo IndexError


try:
  ...
except (myerror1, myerror2):     # co si stanie, jeli dodamy myerror3?
    ...                          # brak bdw
else:
    ...                          # zakadamy, e to bd



***kod do wicze znajduje si w katalogu "rozwiazania"***