1. Podstawy. ******************************************************************

% python
>>> def func(x): print x
...
>>> func("mielonka")
mielonka
>>> func(42)
42
>>> func([1, 2, 3])
[1, 2, 3]
>>> func({'jedzenie': 'mielonka'})
{'jedzenie': 'mielonka'}


2. Argumenty. *****************************************************************

% cat mod.py
def adder(x, y):
    return x + y

print adder(2, 3)
print adder('mielonka', 'jajka')
print adder(['a', 'b'], ['c', 'd'])

% python mod.py
5
mielonkajajka
['a', 'b', 'c', 'd']


3. varargs. *******************************************************************

% cat adders.py

def adder1(*args):
    print 'adder1',
    if type(args[0]) == type(0):    # integer ?
        sum = 0                     # init na 0
    else:                           # sekwencja else:
        sum = args[0][:0]           # uywa pustego segmentu z arg1
    for arg in args:
        sum = sum + arg
    return sum

def adder2(*args):
    print 'adder2',
    sum = args[0]                   # init na arg1
    for next in args[1:]:
        sum = sum + next            # dodaje pozycje 2..N
    return sum

for func in (adder1, adder2):
    print func(2, 3, 4)
    print func('mielonka', 'jajka', 'tost')
    print func(['a', 'b'], ['c', 'd'], ['e', 'f'])

% python adders.py
adder1 9
adder1 mielonkajajkatost
adder1 ['a', 'b', 'c', 'd', 'e', 'f']
adder2 9
adder2 mielonkajajkatost
adder2 ['a', 'b', 'c', 'd', 'e', 'f']


4. Sowa kluczowe. ************************************************************

% cat mod.py
def adder(dobry=1, zly=2, brzydki=3):
    return dobry + zly + brzydki

print adder()
print adder(5)
print adder(5, 6)
print adder(5, 6, 7)
print adder(brzydki=7, dobry=6, zly=5)

% python mod.py
6
10
14
18
18


5. i 6. ***********************************************************************

% cat dict.py
def copyDict(old):
    new = {}
    for key in old.keys():
        new[key] = old[key]
    return new

def addDict(d1, d2):
    new = {}
    for key in d1.keys():
        new[key] = d1[key]
    for key in d2.keys():
        new[key] = d2[key]
    return new

% python
>>> from dict import *
>>> d = {1:1, 2:2}
>>> e = copyDict(d)
>>> d[2] = '?'
>>> d
{1: 1, 2: '?'}
>>> e
{1: 1, 2: 2}

>>> x = {1:1}
>>> y = {2:2}
>>> z = addDict(x, y)
>>> z
{1: 1, 2: 2}


7. Wicej przykadw na dopasowanie argumentw. *******************************

# naley wstawi te definicje do pliku moduowego i pobra za pomoc "from mod import *"

def f1(a, b): print a, b              # normalne args
def f2(a, *b): print a, b             # pozycyjne varargs
def f3(a, **b): print a, b            # varargs dla sw kluczowych
def f4(a, *b, **c): print a, b, c     # tryby mieszane
def f5(a, b=2, c=3): print a, b, c    # domylne
def f6(a, b=2, *c): print a, b, c     # domylne + pozycyjne varargs

% python
>>> f1(1, 2)           # dopasowane wedug pozycji (porzdek ma znaczenie)
1 2
>>> f1(b=2, a=1)       # dopasowane wedug nazwy (porzdek nie ma znaczenia)
1 2

>>> f2(1, 2, 3)        # dodatkowe pozycyjne zebrane w krotk
1 (2, 3)

>>> f3(1, x=2, y=3)    # dodatkowe sowa kluczowe zebrane w sowniku
1 {'x': 2, 'y': 3}

>>> f4(1, 2, 3, x=2, y=3)      # dodatkowe obu rodzajw
1 (2, 3) {'x': 2, 'y': 3}

>>> f5(1)              # obydwie domylne wrzucone
1 2 3
>>> f5(1, 4)           # uyta tylko jedna domylna
1 4 3

>>> f6(1)              # jeden argument: pasuje "a"
1 2 ()
>>> f6(1, 3, 4)        # zebrana dodatkowa pozycyjna
1 3 (4,)
