C
Řešení ke cvičením

### 1 Začínáme

% python
vypíše informace o verzi atp.
>>> "Hello World!"
'Hello World!'
>>>                            # <konec: ctrl-D nebo ctrl-Z>

% cat modul1.py
print 'Hello module world!'

% python modul1.py
Hello module world!

% python
>>> import modul1
Hello module world!
>>>

% cat modul1.py
#!/usr/local/bin/python
# nebo /usr/bin/env python 
print 'Hello module world!'

% chmod +x modul1.py

% modul1.py
Hello module world!

% python
>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero
>>> x
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'x' is not defined

L = [1, 2]
L.append(L)
L

### 2 Typy a operátory

>>> 2 ** 16         # dvě na šestnáctou
65536
>>> 2 / 5, 2 / 5.0  # celá čísla osekávají des. část, reálná ne
(0, 0.4)

>>> "spam" + "eggs"                  # skládání řetězců
'spameggs'
>>> S = "ham"
>>> "eggs " + S
'eggs ham'
>>> S * 5                            # opakování řetězců
'hamhamhamhamham'
>>> S[:0]                            # prázdná část -- [0:0]
''
>>> "green %s and %s" % ("eggs", S)  # formátování a la printf
'green eggs and ham'

>>> ('x',)[0]      # přístup k prvku ntice o jedno prvku
'x'
>>> ('x', 'y')[1]  # přístup k prvku ntice o dvou prvcích
'y'

>>> L = [1,2,3] + [4,5,6]          # práce se seznamy
>>> L, L[:], L[:0], L[-2], L[-2:]
([1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6], [], 5, [5, 6])
>>> ([1,2,3]+[4,5,6])[2:4]
[3, 4]
>>> [L[2], L[3]]    # výběr prvků a jejich uložení do nového s.
[3, 4]
>>> L.reverse(); L  # obracení – metoda mění původní seznam
[6, 5, 4, 3, 2, 1]
>>> L.sort(); L     # třídění – metoda mění původní seznam
[1, 2, 3, 4, 5, 6]
>>> L.index(4)      # hledáme prvek o dané hodnotě, první výskyt
3

>>> {'a':1, 'b':2}['b']        # přístup přes klíč
2
>>> D = {'x':1, 'y':2, 'z':3}
>>> D['w'] = 0                 # nová položka (klíč a hodn.)
>>> D['x'] + D['w']
1
>>> D[(1,2,3)] = 4             # ntice (konst.) jako klíč
>>> D
{'w': 0, 'z': 3, 'y': 2, (1, 2, 3): 4, 'x': 1}
>>> D.keys(), D.values(), D.has_key((1,2,3)) 
(['w', 'z', 'y', (1, 2, 3), 'x'], [0, 3, 2, 4, 1], 1)

>>> [[]], ["",[],(),{},None]    # spoustakrát nic
([[]], ['', [], (), {}, None])

>>> L = [1, 2, 3, 4]
>>> L[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
IndexError: list index out of range

>>> L[-1000:100]
[1, 2, 3, 4]

>>> L[3:1]
[]
>>> L
[1, 2, 3, 4]
>>> L[3:1] = ['?']
>>> L
[1, 2, 3, '?', 4]

>>> L = [1,2,3,4]
>>> L[2] = []
>>> L
[1, 2, [], 4]

>>> L[2:3] = []
>>> L
[1, 2, 4]
>>> del L[0]
>>> L
[2, 4]
>>> del L[1:]
>>> L
[2]

>>> L[1:2] = 1
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: must assign list (not "int") to slice

>>> X = 'spam'
>>> Y = 'eggs'
>>> X, Y = Y, X
>>> X
'eggs'
>>> Y
'spam'

>>> D = {}
>>> D[1] = 'a'
>>> D[2] = 'b'
>>> D[(1, 2, 3)] = 'c'
>>> D
{1: 'a', 2: 'b', (1, 2, 3): 'c'}

>>> D = {'a':1, 'b':2, 'c':3}
>>> D['a']
1

>>> D['d']
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
KeyError: d
>>> D['d'] = 4
>>> D
{'b': 2, 'd': 4, 'a': 1, 'c': 3}

>>> L = [0, 1]
>>> L[2]
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
IndexError: list index out of range
>>> L[2] = 3
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
IndexError: list assignment index out of range

>>> "x" + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: cannot add type "int" to string

>>> {} + {}
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: unsupported operand types for +

>>> [].append(9)
>>> "".append('s')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AttributeError: 'str' object has no attribute 'append'

>>> {}.keys()
[]
>>> [].keys()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AttributeError: 'list' object has no attribute 'keys'

>>> [][:]
[]
>>> ""[:]
''

>>> S = "spam"
>>> S[0][0][0][0][0]
's'

>>> L = ['s', 'p']
>>> L[0][0][0]
's'

>>> S = "spam"
>>> S = S[0] + 'l' + S[2:]
>>> S
'slam'

>>> S = S[0] + 'l' + S[2] + S[3]
>>> S
'slam'

>>> ja = {'jmeno' : ['mark', 'e', 'lutz'], 'vek' : '?',
... 'povolani' : 'inzenyr'}
>>> ja['povolani']
'inzenyr'
>>> ja['jmeno'][2]
'lutz'

% cat tvurce.py
soub = open('soubor.txt', 'w')
soub.write('Hello file world!\n')
soub.close()                       # není potřeba úplně vždycky

% cat ctecka.py
soub = open('soubor.txt', 'r')
print soub.read()

% python tvurce.py

% python ctecka.py
Hello file world!

% ls -l soubor.txt
-rwxrwxrwa 1 0 0 19 Apr 13 16:33 soubor.txt

>>> dir([])
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__eq__', '__ge__', '__getattr__', 
'__getitem__',
'__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',
'__init__', '__le__', '__len__', '__lt__', '__mul__', 
'__ne__', '__new__', '__repr__', '__rmul__', '__setattr__',
'__setitem__', '__setslice__', '__str__', 'append', 'count',
'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

### 3 Základní příkazy

>>> S = 'spam'
>>> for c in S: print ord(c),
...
115 112 97 109

>>> x = 0
>>> for c in S: x = x + ord(c)
...
>>> x
433

>>> x = []
>>> for c in S: x.append(ord(c))
...
>>> x
[115, 112, 97, 109]

>>> map(ord, S)
[115, 112, 97, 109]

>>> D = {'a':1, 'b':2, 'c':3, 'd':4}
>>> D
{'c': 3, 'a': 1, 'd': 4, 'b': 2}

>>> klice = D.keys()
>>> klice.sort()
>>> for klic in klice:
...     print klic, '=>', D[klic]
...
a => 1
b => 2
c => 3
d => 4

seznam = [1, 2, 4, 8, 16, 32, 64]
hledana = 5
citac = 0

while citac < len(seznam):
    if 2 ** hledana == seznam[citac]:
        print 'na pozici', citac
        break
    citac += 1
else:
    print hledana, 'nenalezena'

seznam = [1, 2, 4, 8, 16, 32, 64]
hledana = 5

for p in seznam:
    if (2 ** hledana) == p:
        print (2 ** hledana), 'na pozici', seznam.index(p)
        break
else:
    print hledana, 'nenalezena'

seznam = [1, 2, 4, 8, 16, 32, 64]
hledana = 5

if (2 ** hledana) in seznam:
    print (2 ** hledana), 'na pozici', \
           seznam.index(2 ** hledana)
else:
    print hledana, 'nenalezena'

hledana = 5
seznam = []
for i in range(7): seznam.append(2 ** i)
print seznam

if (2 ** hledana) in seznam:
    print (2 ** hledana), 'na pozici', \
           seznam.index(2 ** hledana)
else:
    print hledana, 'nenalezena'

hledana = 5
seznam = map(lambda x: 2**x, range(7))
print seznam

if (2 ** hledana) in seznam:
    print (2 ** hledana), 'na pozici', \
           seznam.index(2 ** hledana)
else:
   print hledana, 'nenalezena'

### 4 Funkce

% python
>>> def fce(x): print x
...
>>> func("houby")
houby
>>> func(42)
42
>>> func([1, 2, 3])
[1, 2, 3]
>>> func({'kdesi': 'cosi'})
{'kdesi': 'cosi'}

% cat modul2.py
def plus(x, y):
    return x + y

print plus(2, 3)
print plus('raz', 'dva')
print plus(['a', 'b'], ['c', 'd'])

% python modul2.py
5
razdva
['a', 'b', 'c', 'd']

% cat plusy.py

def plus1(*args):
    print 'plus1',
    if type(args[0]) == type(0):  # celé číslo?
        vysl = 0                  #  začneme s nulou
    else:                         # jinak posloupnost
        vysl = args[0][:0]        #  z. s prázdnou částí args[0]
    for arg in args:
        vysl += arg
    return vysl

def plus2(*args):
    print 'plus2',
    vysl = args[0]                # init to arg1
    for dalsi in args[1:]:
        vysl += dalsi         # add items 2..N
    return vysl

for func in (plus1, plus2):
    print func(2, 3, 4)
    print func('raz', 'Dva', 'Tri')
    print func(['a', 'b'], ['c', 'd'], ['e', 'f'])

% python plusy.py
plus1 9
plus1 razDvaTri
plus1 ['a', 'b', 'c', 'd', 'e', 'f']
plus2 9
plus2 razDvaTri
plus2 ['a', 'b', 'c', 'd', 'e', 'f']

% cat modul3.py

def plus(prvni=1, druhej=2, treti=3):
    return prvni + druhej + treti

print plus(),
print plus(5),
print plus(5, 6),
print plus(5, 6, 7),
print plus(treti=5, prvni=7, druhej=6),

% python modul3.py
6 10 14 18 18

% cat slovniky.py

def kopirujSlovnik(stary):
    novy = {}
    for klic in stary.keys():
        novy[klic] = stary[klic]
    return novy

def slozSlovniky(d1, d2):
    vysl = {}
    for x in d1.keys(): vysl[x] = d1[x]
    for x in d2.keys(): vysl[x] = d2[x]
    return vysl

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

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

% cat modul4.py
def f1(a, b): print a, b            # obyčejné
def f2(a, *b): print a, b           # zachycuje zbylé dle pozice
def f3(a, **b): print a, b          #  ... dle jména
def f4(a, *b, **c): print a, b, c   #  ... dle pozice i jména
def f5(a, b=2, c=3): print a, b, c  # implicitní hodnoty
def f6(a, b=2, *c): print a, b, c   #  ... a dle pozice

% python
>>> from modul4 import *
>>> f1(1, 2)               # dle pozice -– záleží na pořadí
1 2
>>> f1(b=2, a=1)           # dle jména -– na pořadí nezáleží
1 2
>>> f2(1, 2, 3)            # zachycené dle pozice do ntice
1 (2, 3)
>>> f3(1, x=2, y=3)        # zachycené dle jména do slovníku
1 {'x': 2, 'y': 3}
>>> f4(1, 2, 3, x=2, y=3)  # jen kombinuje to, co už známe
1 (2, 3) {'x': 2, 'y': 3}

>>> f5(1)                  # použijeme obě implicitní hodnoty
1 2 3
>>> f5(1, 4)               #  nebo jen jednu z nich
1 4 3
>>> f6(1)                  # jeden argument spárován s "a"
1 2 ()
>>> f6(1, 3, 4)            # zachycujeme dle pozice do ntice
1 3 (4,)

### 5 Moduly 

% cat mujmod.py

def spocitejRadky(jmeno):
    return len(open(jmeno, 'r').readlines())

def spocitejZnaky(jmeno):
    return len(open(jmeno, 'r').read())

def test(jmeno):
    return spocitejRadky(jmeno), spocitejZnaky(jmeno)

% python
>>> import mujmod
>>> mujmod.test("mujmod.py")
(6, 207)

% cat mujmod2.py

def spocitejRadky(soub):
    soub.seek(0)
    return len(soub.readlines())

def spocitejZnaky(soub):
    soub.seek(0)
    return len(soub.read())

def test(jmeno):
    soub = open(jmeno, 'r')
    return spocitejRadky(soub), spocitejZnaky(soub)

% python
>>> import mujmod2
>>> mujmod2.test("mujmod2.py")
(9, 241)

% python
>>> from mujmod import spocitejZnaky
>>> spocitejZnaky("mujmod.py")
207
>>> from mujmod import *
>>> spocitejRadky("mujmod.py")
6

% cat mujmod3.py

def spocitejRadky(jmeno):
    return len(open(jmeno, 'r').readlines())
def spocitejZnaky(jmeno):
    return len(open(jmeno, 'r').read())
def test(jmeno):
    return spocitejRadky(jmeno), spocitejZnaky(jmeno)

if __name__ == "__main__":
    print test("mujmod.py")

% python mujmod3.py
(6, 207)

% cat klient.py
from mujmod import spocitejRadky, spocitejZnaky 
print spocitejRadky('mujmod.py'), spocitejZnaky('mujmod.py')

% python klient.py
6 207

% cat nejaky.py
nejakeJmeno = 42

% cat collector.py
from nejaky import *
from odnekud import *  # kopírujeme spoustu jmen do lokálního
from odkudsi import *  #  jmenného prostoru

% python
>>> from collector import nejakeJmeno

### 6 Třídy

% cat skladajici.py

class Skladajici:
    def sloz(self, x, y):
        print 'není implementováno!'        # nebo lépe výjimku
    def __init__(self, pocatecni=[]):
        self.data = pocatecni
    def __add__(self, other):
        return self.sloz(self.data, other)  

class SkladajiciSeznamy(Skladajici):
    def sloz(self, x, y):
        return x + y

class SkladajiciSlovniky(Skladajici):
    def sloz(self, x, y):
        vysl = {}
        for k in x.keys(): vysl[k] = x[k]
        for k in y.keys(): vysl[k] = y[k]
        return vysl

% python
>>> from skladajici import *
>>> x = Skladajici()
>>> x.sloz(1, 2)
není implementováno!
>>> x = SkladajiciSeznamy()
>>> x.sloz([1], [2])
[1, 2]
>>> x = SkladajiciSlovniky()
>>> x.sloz({1:1}, {2:2})
{1: 1, 2: 2}

>>> x = Skladajici([1])
>>> x + [2]
není implementováno!
>>> x = SkladajiciSeznamy([1])
>>> x + [2]
[1, 2]
>>> [2] + x
Traceback (most recent call last):
  File "<interactive input>", line 1, in ?
TypeError: can only concatenate list (not "instance") to list

% cat mujseznam.py

class MujSeznam:
    def __init__(self, start):
        self.zabaleny = []                       # buď ...
        for x in start: self.zabaleny.append(x)
        # self.zabaleny = start[:]               #  ... anebo
    def __add__(self, other):
        return MujSeznam(self.zabaleny + other)
    def __mul__(self, time):
        return MujSeznam(self.zabaleny * time)
    def __getitem__(self, offset):
        return self.zabaleny[offset]
    def __len__(self):
        return len(self.zabaleny)
    def __getslice__(self, low, high):
        return MujSeznam(self.zabaleny[low:high])
    def append(self, node):
        self.zabaleny.append(node)
    def __getattr__(self, name):                 # “zbytek sem”
        return getattr(self.zabaleny, name)
    def __repr__(self):
        return `self.zabaleny`

if __name__ == '__main__':
    x = MujSeznam('cosi')
    print x
    print x[2]
    print x[1:]
    print x + ['kdesi']
    print x * 3
    x.append('a')
    x.sort()
    for c in x: print c,

% python mujseznam.py
['c', 'o', 's', 'i']
s
['o', 's', 'i']
['c', 'o', 's', 'i', 'kdesi']
['c', 'o', 's', 'i', 'c', 'o', 's', 'i', 'c', 'o', 's', 'i']
a c i o s

% cat mujseznaminfo.py

from mujseznam import MujSeznam

class MujSeznamInfo(MujSeznam):
    volani = 0                      # v rámci třídy
    def __init__(self, pocatecni):
        self.skladani = 0
        MujSeznam.__init__(self, pocatecni)
    def __add__(self, y):
        MujSeznamInfo.volani += 1
        self.skladani += 1          # v rámci instance
        return MujSeznam.__add__(self, y)
    def info(self):
        return self.volani, self.skladani

if __name__ == '__main__':
    x = MujSeznamInfo('neco')
    y = MujSeznamInfo('raz')
    print x[2]
    print x[1:]
    print x + ['cosi']
    print x + ['kdesi']
    print y + ['dva']
    print x.info()

% python mujseznaminfo.py
c
['e', 'c', 'o']
['n', 'e', 'c', 'o', 'cosi']
['n', 'e', 'c', 'o', 'kdesi']
['r', 'a', 'z', 'dva']
(3, 2)

>>> class Meta:
... 	def __getattr__(self, atribut): print 'get', atribut
... 	def __setattr__(self, atribut, hodnota): print 'set', \
...      atribut, hodnota
... 	

>>> x = Meta()
>>> x.append
get append
>>> x.kdesi = "cosi"
set kdesi cosi

>>> x + 2
get __coerce__
Traceback (most recent call last):
  File "<interactive input>", line 1, in ?
TypeError: object is not callable: None

>>> x[1]
get __getitem__
Traceback (most recent call last):
  File "<interactive input>", line 1, in ?
TypeError: object is not callable: None

>>> x[1:5]
get __getslice__
Traceback (most recent call last):
  File "<interactive input>", line 1, in ?
TypeError: object is not callable: None

>>> from mnozina import Mnozina
>>> x = Mnozina([1, 2, 3, 4])     # __init__
>>> y = Mnozina([3, 4, 5])
>>> x & y                         # __and__, prunik, __repr__
<Mnozina: [3, 4]>
>>> x | y                         # __or__, sjednoceni, __repr__
<Mnozina: [1, 2, 3, 4, 5]>

>>> z = Mnozina("Ahoo!")          # __init__ ruší duplikáty
>>> z[0], z[-1]                   # __getitem__
('A', 'j')
>>> for x in z: print x,          # __getitem__
... 
A h o j
>>> len(z)                        # __len__
4
>>> z                             # __repr__
<Mnozina: ['A', 'h', 'o', 'j']>

>>> z & "Ahoy"
<Mnozina: ['A', 'h', 'o']>
>>> z | "Ahoy"
<Mnozina: ['A', 'h', 'o', 'j', 'y']>

% cat mnozina2.py

from mnozina import Mnozina

class Mnozina2(Mnozina):
""" Dědíme všechna jména třídy Množina, přitom přetěžujeme 
metody prunik a sjednoceni. Všimněte si, že i sjednoceni je
možné předávat jako první argument self a že práce s operátory
& a | se nijak nemění (stále jsou binární, volají naše metody 
se dvěma argumenty). """

    def prunik(self, *ostatni):
        vysl = []
        for x in self:
            for dalsi in ostatni:
                if x not in dalsi: break
            else: vysl.append(x)
        return Mnozina2(vysl)

    def sjednoceni(*argumenty):
        vysl = []
        for posl in argumenty:
            for x in posl:
                if not x in vysl: vysl.append(x)
        return Mnozina2(vysl)

% python
>>> from mnozina2 import Mnozina2
>>> x = Mnozina2([1, 2, 3, 4])
>>> y = Mnozina2([3, 4, 5])
>>> z = Mnozina2([0, 1, 2])
>>> x & y, x | y                                 # 2 operandy
(<Mnozina: [3, 4]>, <Mnozina: [1, 2, 3, 4, 5]>)
>>> x.prunik(y, z)                               # 3 operandy
<Mnozina: []>
>>> x.sjednoceni(y, z)
<Mnozina: [1, 2, 3, 4, 5, 0]>
>>> x.prunik([1, 2, 3], [2, 3, 4], [1, 2, 3])    # 4 operandy
<Mnozina: [2, 3]>
>>> x.sjednoceni(range(10))                      # jen rozhranní
<Mnozina: [1, 2, 3, 4, 0, 5, 6, 7, 8, 9]>

% cat vypisovac2.py

from vypisovac import Vypisovac

class Vypisovac2(Vypisovac):
    def __repr__(self):
        return ("<Instance třídy %s(%s), na adrese %s:\n%s>" % \
                (self.__class__.__name__, self.predkove(),
                 id(self), self.atributy()))
                # jméno, předkové, adresa objektu a atributy

    def predkove(self):
        vysl = ""; prvni = 1
        for predek in self.__class__.__bases__:  # jen o úroveň
            if not prvni: vysl += ", "
            prvni = 0
            vysl += predek.__name__
        return vysl

% python vypisovac2test.py
<Instance třídy Potomek(Predek, Vypisovac2), na adrese 18745388:
	data1 = něco
	data3 = 42
	data2 = kdesicosi
>

% cat simulace.py

class Simulator:
    def __init__(self)
     # vytváří instance tříd Zakaznik a Zamestnanec
     self.zakaznik = Zakaznik()
     self.zamestnanec = Zamestnanec()
    def spustSimulaci(self, jmenoJidla)
     # spustí simulaci objednávky daného jídla
     self.zakaznik.objednejJidlo(jmenoJidla, self.zamestnanec)
    def vypisVysledek(self)
     # vypíše, co si zákazník objednal
     self.zakaznik.vypisJidlo()

class Zakaznik:
    def __init__(self)
     # na začátku má objednáno None
     self.objednano = None
    def objednejJidlo(self, jmenoJidla, zamestnanec)
     # objedná u zamestnance jídlo “jmenoJidla”
     self.objednano = zamestnanec.prijmiObjednavku(jmenoJidla)
    def vypisJidlo(self)
     # vypisuje jméno jídla, které si zákazník objednal
     print self.objednano.jmeno

class Zamestnanec:
    def prijmiObjednavku(self, jmenoJidla)
     # vrací Jidlo daného jména
     return Jidlo(jmenoJidla)

class Jidlo:
 # jen uchovává jméno předané konstruktoru
    def __init__(self, jmeno)

if __name__ == '__main__':
    x = Simulator()
    x.spustSimulaci('buráky')
    x.vypisVysledek()
    x.spustSimulaci('pizza')
    x.vypisVysledek()

% python simulace.py
buráky
pizza

### 7 Výjimky

% cat oops.py

def oops(): raise IndexError

def prokleta():
    try: oops()
    except IndexError: print 'Zachycen IndexError!'
    else: print 'Nic jsme nechytli.'

if __name__ == '__main__': prokleta()

% python oops.py
Zachycen IndexError!

% cat oops2.py

MojeChyba = 'MojeChyba'

def oops(): raise MojeChyba, 'protože proto'

def prokleta():
    try: oops()
    except IndexError: print 'Zachycen IndexError!'
    except MojeChyba, info: print 'Zachycena', MojeChyba, info
    else: print 'Nic jsme nechytli.'

if __name__ == '__main__': prokleta()

% python oops.py
Zachycena MojeChyba protože proto

% cat bezpecna.py

import sys, traceback

def bezpecna(fce, *argumenty):
    try:
        apply(fce, argumenty)
    except:
        traceback.print_exc()
        print 'Zachycena', sys.exc_type, sys.exc_value

if __name__ == '__main__':
    import oops2
    bezpecna(oops2.oops)

% python bezpecna.py

Traceback (most recent call last):
  File "C:\Python22\bezpecna.py", line 5, in bezpecna
    apply(fce, argumenty)
  File "oops2.py", line 4, in oops
    raise MojeChyba, 'protože proto'
MojeChyba: protože proto
Zachycena MojeChyba protože proto

### 8 Standardní knihovna

% cat popisAdresar.py

import os, sys, stat

def popisAdresar(odkud):
    def pomocna(arg, adresar, obsah):
        """ Pomocná funkce (popis jednoho adresáře) """
        print "Obsah adresáře %s:" % adresar
        for x in obsah:
            cesta = os.path.join(adresar, x)  # sestav cestu
            if os.path.isdir(cesta):          # adr? bez vel.
                print ' '+ x + ' [ADR]'
            else:                
                velikost = os.stat(cesta)[stat.ST_SIZE]
                print ' ' + x + ' [' + `velikost` + ']'
    os.path.walk(odkud, pomocna, None)        # procházení

% python
>>> import popisAdresar
>>> popisAdresar.popisAdresar("C:\\Test")

Obsah adresáře D:\Test:
 OgreBspSceneManager.dll [327680]
 OgreD3DEngine.dll [458752]
 OgreMain.dll [704512]
 OgrePlatform.dll [421888]
 Lib [ADR]

Obsah adresáře D:\Test\Lib:
 OgrePythonTest.py [1874]
 OgrePythonTest.pyc [1863]

import string, sys, os

class MujPrompt:
    def __init__(self, kousek='>>>'):
        self.radka = 0
        self.kousek = kousek
    def __repr__(self):
        self.radka += 1
        return '(%s) %s %s ' % (string.rjust(str(self.radka),4),
                                os.getcwd(), self.kousek)

if __name__ == '__main__':
    sys.ps1 = MujPrompt()
    sys.ps2 = MujPrompt('...')

C:\Python> python -i mujprompt.py
(   1) C:\Python >>> x = 3
(   2) C:\Python >>> y = 3
(   3) C:\Python >>> def foo():
(   3) C:\Python ...     return 2
(   3) C:\Python ...
(   4) C:\Python >>> import os
(   5) C:\Python >>> os.chdir("..")  # změní prompt!
(   6) C:\ >>>

% cat pepper2.py

import string
soub = open('pepper.txt')
text = soub.read()
odstavce = string.split(text, '\n\n')

def najdiMozneVyskyty(delsi, kratsi):
    vyskyty = []
    posun = 0
    while 1:
        kde = string.find(delsi, kratsi)
        if kde == -1: return vyskyty
        vyskyty.append(kde+posun)
        delsi = delsi[kde+len(kratsi):]
        posun += kde + len(kratsi)

def nahradVOdstavcich(odstavce, slovo):
    delka = len(slovo)
    for cislo in range(len(odstavce)):
        o = odstavce[cislo]  # o jako odstavec
        vyskyty = najdiMozneVyskyty(o, slovo)
        if vyskyty == []: return
        for zacatek in vyskyty:
            zacatekPepper = string.find(o, 'pepper')
            if zacatekPepper == -1: return -1  # není 'pepper'
            if string.strip(o[zacatek:zacatekPepper]) != '':
                continue  # něco krom prázdného místa "mezi"
            where = zacatekPepper+len('pepper')
            if o[where:where+len('corn')] == 'corn':
                continue  # přímo následuje 'corn'
            if string.find(o, 'salad') < where:
                continue  # nenásleduje 'salad'

            # ok. můžeme nahrazovat
            o = o[:zacatek] + 'bell' + o[zacatek+delka:]
            odstavce[cislo] = o  # měníme nekonst. arg.!

nahradVOdstavcich(odstavce, 'red')
nahradVOdstavcich(odstavce, 'green')

for o in odstavce:  print o + '\n'

% cat mujtext.py

import string

class MujText:
    def __init__(self, jmeno=None, obsah=None):
        if obsah != None: self.obsah = obsah
        else: self.obsah = open(jmeno).read()
        self.odstavce = string.split(self.obsah, '\n\n')
        self.radky = string.split(self.obsah, '\n')
        self.slova = string.split(self.obsah)
    def __repr__(self):
        return self.obsah
    def odstavec(self, ktery):
        return MujText(obsah=self.odstavce[ktery])
    def radka(self, ktera):
        return MujText(obsah=self.radky[ktera])
    def slovo(self, ktere):
        return self.slova[ktere]

% python
>>> from mujtext import MujText
>>> cely = MujText("pepper.txt")
>>> print cely.odstavec(0) 
This is a paragraph that mentions bell peppers multiple times. For one, here is a red pepper and dried tomato 
salad recipe. I don't like to use green peppers in my salads as much because they have a harsher flavor.
>>> print cely.radka(0)  #  
This is a paragraph that mentions bell peppers multiple times. For
>>> print cely.radka(-4)
This third paragraph mentions red peppercorns and green peppercorns,
>>> print cely.slovo(-4)
botanist

>>> print cely.odstavec(2).radka(2).slovo(-1)
'cook'

### 9 Běžné úlohy

import fileinput, sys, string           # nic nového
sys.stdout = open(sys.argv[-1], 'w')    # otevřeme soubor-výstup
del sys.argv[-1]                        # “po použití...do koše”
...

import cmd, os, string, sys, shutil

class MujShell(cmd.Cmd):
    def do_EOF(self, radka):
        """ Metoda do_EOF je volána, když uživatel stiskne
        Ctrl-D (unix) nebo Ctrl-Z (PC). """
        sys.exit()

    def help_ls(self):
        print "ls [adresar]: vypíše obsah daného adresáře"
        print "              (implicitně aktuálního)"

    def do_ls(self, radka):
        if radka == '': adresare = [os.curdir]
        else: adresare = string.split(radka)
        for adr in adresare:
            print '[%s]:' % adr
            print string.join(os.listdir(adr), '\n')

    def do_cd(self, adr):
        # 'cd' by itself means 'go home'
        if adr == '': adr = os.environ['HOME']
        os.chdir(adr)

    def do_mkdir(self, adr):
        os.mkdir(adr)

    def do_cp(self, radka):
        slova = string.split(radka)
        odkud, kam = slova[:-1], slova[-1]  # cíl – adresář
        for jeden in odkud: shutil.copy(odkud, kam)

    def do_mv(self, radka):
        odkud, kam = string.split(radka)
        os.rename(odkud, kam)

    def do_rm(self, radka):
        map(os.remove, string.split(radka))

class MujPrompt:
    def __repr__(self):
        return os.getcwd()+'> '

cmd.Cmd.prompt = MujPrompt()
shell = MujShell()
shell.cmdloop()

D:\Test>python -i mujshell.py
D:\Test> ls
[.]:
OgreBspSceneManager.dll
OgreD3DEngine.dll
OgreMain.dll
OgrePlatform.dll
Lib
D:\Test> cd Lib
D:\Test\Lib> ls
[.]:
OgrePythonTest.py
OgrePythonTest.pyc
D:\Test\Lib> rm OgrePythonTest.py
D:\Test\Lib> rm OgrePythonTest.pyc
D:\Test\Lib> ls
[.]:
D:\Test\Lib> cd ..
D:\Test>

def map2(fce, posloupnost):
    if fce is None: return list(posloupnost)
    vysl = []
    for prvek in posloupnost:
        vysl.append(fce(prvek))
    return vysl

def reduce2(fce, posloupnost):
    arg1 = fce(posloupnost[0])
    for arg2 in posloupnost[1:]:
        arg1 = fce(arg1, arg2)
    return arg1

def filter2(fce, posloupnost):
    vysl = []
    for prvek in posloupnost:
        if (fce is None and prvek) or fce(prvek):
            vysl.append(prvek)
    return vysl

### 10 Velké věci

% cat nahrazka.py

class Formular:
    def __init__(self, slovn):
        for k, hodn in slovn.items():
            setattr(self, k, hodn)

class Komentar(Formular):
    pole = ('jmeno', 'adresa', 'email', 'typ', 'text')

nahrazky = [
     {'jmeno': "Jan Novák",
      'adresa': 'Hlavní 1, Díra 123 45',
      'email': 'jan@novak.cz',
      'typ': 'komentar',
      'text': 'Fantasticka pasta!'},

     {'jmeno': "Zuzana Nováková",
      'adresa': 'Hlavní 1, Díra 123 45',
      'email': 'zuzana@novak.cz',
      'typ': 'stiznost',
      'text': "S Vaší pastou to není ono, když líbám Honzu!"},
     ]

ADRESAR = r'C:\komentare'
if __name__ == '__main__':
    import tempfile, pickle, time
    tempfile.tempdir = ADRESAR
    for jedna in nahrazky:
        data = Komentar(jedna)
        jmeno = tempfile.mktemp()
        data.cas = time.asctime(time.localtime(time.time()))
        pickle.dump(data, open(jmeno, 'w'))

if __name__ == '__main__':
    import os, pickle
    from komentar import ADRESAR, Komentar
    PROJITE = r"c:\projite"
    if os.path.exists(PROJITE): 
        projite = pickle.load(open(PROJITE))
    else:
        projite = []
    word = Word()
    for soub in os.listdir(ADRESAR):
        if soub in projite: continue
        projite.append(soub)
        data = pickle.load(open(os.path.join(ADRESAR, soub)))
        if data.typ == 'stiznost':
            print "Tiskneme dopis pro '%(jmeno)s'." % vars(data)
            tiskDopisu(data)
        else:
            print "%(name)s posílá jen komentář." % vars(data)
    pickle.dump(projite, open(PROJITE, 'w'))