*** Strona 109 *******************************************************************

>>> def razy(x, y):      # tworzy i przypisuje funkcj
...     return x * y     # ciao funkcji jest uruchamiane po wywoaniu
...
>>> razy(2, 4)           # argumenty w nawiasach
8
>>> razy('Ni', 4)        # funkcje s 'beztypowe'
'NiNiNiNi'


*** Strona 111-112 ***************************************************************

# funkcj naley umieci w pliku moduowym i pniej zaimportowa
# mona to te wpisa w trybie interakcyjnym

def intersect(seq1, seq2):
    res = []                  # pusty pocztek
    for x in seq1:            # skanowanie seq1
        if x in seq2:         # czy pozycja jest wsplna?
            res.append(x)     # dopisanie na kocu
    return res

>>> s1 = "MIELONKA"
>>> s2 = "WIELE"
>>> intersect(s1, s2)              # acuchy
['I', 'E', 'L']
>>> intersect([1, 2, 3], (1, 4))   # typy mieszane
[1]


*** Strona 113 *******************************************************************

# zakres globalny
X = 99               # X i func przypisane w module: zakres globalny

def func(Y):         # Y i Z przypisane w funkcji: zakres lokalny
    # zakres lokalny
    Z = X + Y        # X nie jest przypisane, a wic ma ono zakres globalny
    return Z

func(1)              # uycie func w module: wynik=100


*** Strona 114 *******************************************************************

y, z = 1, 2          # zmienne globalne w module

def all_global():
    global x         # deklaruje przypisanie globalne
    x = y + z        # nie ma potrzeby deklarowania y,z (regua trzech zakresw)


*** Strona 115 *******************************************************************

>>> def changer(x, y):
...    x = 2                 # zmienia tylko warto nazwy lokalnej
...    y[0] = 'mielonka'     # zmienia wspdzielone obiekty w miejscu
...
>>> X = 1
>>> L = [1, 2]
>>> changer(X, L)            # przekazuje obiekty niezmienne i zmienne
>>> X, L                     # X nie zmienione, L zmienione
(1, ['mielonka', 2])


*** Strona 116 *******************************************************************

>>> def multiple(x, y):
...     x = 2                # zmienia tylko nazwy lokalne
...     y = [3, 4]
...     return x, y          # zwraca nowe wartoci w krotce
...
>>> X = 1
>>> L = [1, 2]
>>> X, L = multiple(X, L)    # przypisuje wyniki do nazw z wywoania
>>> X, L
(2, [3, 4])


*** Strona 118-119 ***************************************************************

def func(mielonka, jajka, tost=0, szynka=0):    # dwa pierwsze s wymagane
   print (mielonka, jajka, tost, szynka)

func(1, 2)                                      # wynik: (1, 2, 0, 0)
func(1, szynka=1, jajka=0)                      # wynik: (1, 0, 0, 1)
func(mielonka=1, jajka=0)                       # wynik: (1, 0, 0, 0)
func(tost=1, jajka=2, mielonka=3)               # wynik: (3, 2, 1, 0)
func(1, 2, 3, 4)                                # wynik: (1, 2, 3, 4)


# naley umieci ten kod w pliku moduowym nazwanym
# "inter2.py", w katalogu podanym w PYTHONPATH

def intersect(*args):
    res = []
    for x in args[0]:                    # skanuje pierwsz sekwencj
        for other in args[1:]:           # dla pozostaych argumentw
            if x not in other: break     # czy pozycja wystpuje w kadej?
        else:                            # nie: wyjcie z ptli
            res.append(x)                # tak: dopisanie pozycji na kocu
    return res

def union(*args):
    res = []
    for seq in args:                     # dla wszystkich argumentw
        for x in seq:                    # dla wszystkich wzw
            if not x in res:
                res.append(x)            # dopisanie nowej pozycji do wyniku
    return res


% python
>>> from inter2 import intersect, union
>>> s1, s2, s3 = "MIELONKA", "WIELE", "SZLAM"
>>> intersect(s1, s2), union(s1, s2)                # dwa operandy
(['I', 'E', 'L'], ['M', 'I', 'E', 'L', 'O', 'N', 'K', 'A', 'W'])

>>> intersect([1,2,3], (1,4))                       # typy mieszane
[1]

>>> intersect(s1, s2, s3)                           # trzy operandy
['L']

>>> union(s1, s2, s3)
['M', 'I', 'E', 'L', 'O', 'N', 'K', 'A', 'W', 'S', 'Z']


*** Strona 121-124 ***************************************************************

>>> def func(x, y, z): return x + y + z
...
>>> func(2, 3, 4)
9

>>> f = lambda x, y, z: x + y + z
>>> f(2, 3, 4)
9

>>> x = (lambda a="fee", b="fie", c="foe": a + b + c)
>>> x("wee")
'weefiefoe'

>>> apply(func, (2, 3, 4))
9
>>> apply(f, (2, 3, 4))
9


L = [lambda x: x**2, lambda x: x**3, lambda x: x**4]

for f in L:
    print f(2)       # wypisuje 4, 8, 16

print L[0](3)        # wypisuje 9

 
>>> liczniki = [1, 2, 3, 4]
>>>
>>> poprawione = []
>>> for x in liczniki:
...    poprawione.append(x + 10)   # dodaje 10 do kadej pozycji
...
>>> poprawione
[11, 12, 13, 14]

>>> def przyrost(x): return x + 10      # funkcja, ktra ma by uruchomiona
...
>>> map(przyrost, liczniki)             # gromadzenie wynikw
[11, 12, 13, 14]

>>> map((lambda x: x + 3), liczniki)    # wyraenie funkcji
[4, 5, 6, 7]


>>> def proc(x):
...     print x                # brak return oznacza zwrot None
...
>>> x = proc('testing 123...')
testing 123...
>>> print x
None

>>> list = [1, 2, 3]
>>> list = list.append(4)      # append jest 'procedur'
>>> print list                 # append zmienia list w miejscu
None


*** Strona 125 *******************************************************************

>>> def echo(komunikat):       # echo przypisane do obiektu funkcji
...     print komunikat
...
>>> x = echo                   # teraz x odwouje si take do 'echo'
>>> x('Hello world!')          # wywoanie obiektu za pomoc nawiasw
Hello world!

>>> def indirect(func, arg):
...     func(arg)                   # wywoanie obiektu poprzez dodanie ()
...
>>> indirect(echo, 'Hello jello!')  # przekazywanie funkcji do funkcji
Hello jello!

>>> kolejka = [ (echo, 'Mielonka!'), (echo, 'Lonka!') ]
>>> for (func, arg) in kolejka:
...     apply(func, (arg,))
...
Mielonka!
Lonka!


*** Strona 126-127 ***************************************************************

>>> X = 99
>>> def selector():         # X uyte ale nie przypisane
...     print X             # X znalezione w globalnym zakresie
...
>>> selector()
99
>>> def selector():
...     print X         # nie istnieje!
...     X = 88          # X potraktowane jako nazwa lokalna (wszdzie)
...                     # to samo moe by po "import X", "def X",...
>>> selector()
Traceback (innermost last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 2, in selector
NameError: X


>>> def selector():
...     global X           # wymuszenie, aby X byo globalne (wszdzie)
...     print X
...     X = 88
...
>>> selector()
99


>>> X = 99
>>> def selector():
...     import __main__       # importuje otaczajcy modu
...     print __main__.X      # kwalifikacja dla globalnej wersji nazwy
...     X = 88                # niekwalifikowane X traktowane jako lokalne
...     print X               # uycie lokalnej wersji nazwy
...
>>> selector()
99
88


*** Strona 128-129 ***************************************************************

>>> def outer(x):
...     def inner(i):           # przypisanie lokalne w outer
...         print i,            # i pochodzi z lokalnego zakresu inner
...         if i: inner(i-1)    # ani lokalne, ani globalne!
...     inner(x)
...
>>> outer(3)
3
Traceback (innermost last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 5, in outer
  File "<stdin>", line 4, in inner
NameError: inner

>>> def outer(x):
...     global inner
...     def inner(i):           # przypisanie w otaczajcym module
...         print i,
...         if i: inner(i-1)    # tu znaleziona w danym zakresie globalnym
...     inner(x)
...
>>> outer(3)
3 2 1 0


*** Strona 129-130 **************************************************************

>>> def outer(x, y):
...     def inner(a=x, b=y):  # zachowuje powizania i obiekty x, y z outer
...         return a**b       # tutaj nie mona uy x i y bezporednio
...     return inner
...
>>> x = outer(2, 4)
>>> x()
16

>>> def outer(x, y):
...     return lambda a=x, b=y: a**b
...
>>> y = outer(2, 5)
>>> y()
32

>>> def outer(x):
...     def inner(i, self=inner):     # nazwa jeszcze nie jest zdefiniowana
...           print i,
...           if i: self(i-1)
...     inner(x)
...
>>> outer(3)
Traceback (innermost last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 2 in outer
NameError: inner

>>> def outer(x):
...     fillin = [None]
...     def inner(i, self=fillin):     # zachowanie zmiennego obiektu
...         print i,
...         if i: self[0](i-1)         # zakadamy, e jest ustawione
...     fillin[0] = inner              # teraz podczamy warto
...     inner(x)
...
>>> outer(3)
3 2 1 0

>>> def inner(i):           # definiowanie nazwy na poziomie moduu
...     print i,
...     if i: inner(i-1)    # bez obaw, jest to globalne
...
>>> def outer(x):
...     inner(x)
...
>>> outer(3)
3 2 1 0


*** Strona 131 *******************************************************************

>>> def saver(x=[]):       # zachowanie wartoci poza obiektem listy
...     x.append(1)        # zmienia ten sam obiekt za kadym razem!
...     print x
...
>>> saver([2])             # warto domylna nie jest uyta
[2, 1]
>>> saver()                # warto domylna jest uyta
[1]
>>> saver()                # powiksza si przy kadym wywoaniu
[1, 1]
>>> saver()
[1, 1, 1]

>>> def saver(x=None):
...     if x is None:          # nie przekazano adnego argumentu?
...         x = []             # uruchamiamy kod, aby utworzy now list
...     x.append(1)            # modyfikacja nowego obiektu listy
...     print x
...
>>> saver([2])
[2, 1]
>>> saver()                    # tutaj lista ju si nie rozrasta
[1]
>>> saver()
[1]


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