784/3218

Velký tahák do Pythonu

Dokumentace je moc. Aby se v tom člověk vyznal a nic nezapomněl je občas potřeba uspořádat si vlastní poznámky...

Obsah:

  1. Číselné datové typy
  2. Řetězce -- str()
  3. Posloupnosti
  4. Množiny -- set()
  5. Slovníky -- dict()
  6. Práce s daty
  7. Podmínky
  8. Cykly
  9. Funkce
  10. Soubory, výjimky, moduly, balíčky, objekty
  11. Funkcionální přístup
  12. Tipy a triky

Číselné datové typy

celé číslo -- int()

>>> i=176
>>> i
176 
>>> 20 / 6
3
>>> 20 % 6
2
>>> 2**5
32

`--> stáhnout

Odporované operace:
klasicky +, -, *
/ je celočíselné dělení
% je zbytek po dělení (modulo)
** je mocnina

Celá čísla lze zadávat i pomocí prefixu v různých číselných soustavách

prefix     základ soustavy
0b, 0B 2
0 8
0x, 0X 16
>>> 012
10
>>> 0b1001
9
>>> 0xff
255

`--> stáhnout

Poznámka: převod z desítkové do jiné soustavy lze uskutečnit pomocí funkcí bin(), oct() a hex().

Bitové operace s celými čísly

| disjunkce -- OR
& konjunkce -- AND
^ nonekvivalence -- XOR
~ negace -- NOT
>>   bitový posun doleva
<< bitový posun doprava
>>> print '{0:06b} {0:6d}\n{1:06b} {1:6d}'.format(26,6)
011010     26
000110      6

>>> print '{0:06b} {0:6d}'.format( 26 | 6 ) 
011110     30

>>> print '{0:06b} {0:6d}'.format( 26 & 6 )
000010      2

>>> print '{0:06b} {0:6d}'.format( 26 ^ 6 )
011100     28

>>> print '{0:06b} {0:6d}'.format( 6 << 2 )
011000     24

>>> print '{0:06b} {0:6d}'.format( 26 >> 2 )
000110      6

>>> print '{0:06b} {0:6d}'.format( ~ 6  )

`--> stáhnout

desetinné číslo -- float()

>>> f=3.0
>>> a=.7
>>> f=2.2367
>>> 20. / 6
3.3333333333333335

`--> stáhnout

Aby bylo dělení reálné je nutné aby jeden z operandů byl typu float.

komplexní číslo -- complex()

>>> x=complex(1)
>>> x
(1+0j)
>>> y=3+4j
>>> z=8+j
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-28-0f617859faa4> in <module>()
----> 1 z=8+j

NameError: name 'j' is not defined
>>> z=8+1j
>>> z
(8+1j)
>>> z.real
8.0
>>> z.imag
1.0
>>> z.conjugate()
(8-1j)

`--> stáhnout

pravda, nepravda -- bool()

Proměnná True, False jsou jen synonymem pro 1 a 0. Dále platí, že False je jen prázdný řetězec, None nebo číslo 0. Vše ostatní je True.

>>> bool('-1234')
True
>>> bool('0')
True
>>> bool(0)
False
>>> bool(1)
True
>>> bool(7654)
True
>>> bool(776.4)
True
>>> True+True+True+True
4
>>> True+2
3
>>> 87534 * False
0

`--> stáhnout

Pravdivostní výrazy mohou používat
==, != -- rovno/ nerovno
> , >=, < ,<= -- větší/menší/nebo rovno
in -- test příslušnosti do seznamu.
>>> 22 == 22
True
>>> 22 != 22
False
>>> 22 != 15.23
True
>>> 'a' in 'ahoj'
True
>>> 'a' in 'Hele'
False
>>> 'ab' in 'ahoj'
False
>>> 8 in (1,2,8,16,32)
True
>>> 

`--> stáhnout

V pravdivostních výrazech lze používat logické operace and, or a not.

| navigace |

Řetězce -- str()

Datový typ str -- řetězec se zapisuje do uvozovek " nebo apostrofů '. Trojité uvozovky/apostrofy začínají/končí více-řádkové řetězce. Speciální znaky jsou uvozeny zpětným lomítkem.

>>> s='Ahoj Karle'
>>> s
'Ahoj Karle'
>>> s="Ahoj Karle"
>>> s
'Ahoj Karle'
>>> s="znak apostrof: ' "
>>> s
"znak apostrof: ' "
>>> s="znak uvozovka: \" "
>>> s
'znak uvozovka: " '
>>> s="ahoj\nnazdar\n\tcau"
>>> print s
ahoj
nazdar
    cau

`--> stáhnout

Speciální znaky
\n konec řádku
\r návrat vozíku
\t tabulátor
\\ a zpětné lomítko
\", \' uvozovka, apostrof
\xhh znak se zadanou hexadecimální hodnotou: např. \x64 je @
\uhhhh 16-bitový znak Unicode
\Uhhhhhhhh 32-bitový znak Unicode

Spojování řetězců lze provádět pomocí operací + a *.

>>> 'ahoj'+' nazdar '+'cau'
'ahoj nazdar cau'
>>> s='ahoj'
>>> s=s+' nazdar '
>>> s+='cau'
>>> s
'ahoj nazdar cau'
>>> '@'*20
'@@@@@@@@@@@@@@@@@@@@'

`--> stáhnout

Řetězce jsou neměnitelné. To znamená, že proměnou lze vytvořit, nebo přepsat, ale nejde změnit například jeden znak.

>>> s='ahoj Karle'
>>> s[0]='A'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-3-5a84bfa0286c> in <module>()
----> 1 s[0]='A'

TypeError: 'str' object does not support item assignment

`--> stáhnout

S řetězci lze pracovat pomocí metod datového typu str. Všechny metody vždy vrací nový objekt a původní řetěze zůstává nezměněn:

Některé zajímavé metody

.lower(), .upper(), .swapcase
převede všechna písmena na malá respektive velká respektive prohodí velké za malé
>>> s='Toto je retezec'
>>> s.lower()
'toto je retezec'
>>> s.upper()
'TOTO JE RETEZEC'
>>> abc=s.upper()
>>> s
'Toto je retezec'
>>> abc
'TOTO JE RETEZEC'

`--> stáhnout

.split(znak)
rozdělí řetězec podle zadaného znaku; není-li znak zadán, rozdělí ho podle bílých znaků (mezera, tabulátor, nový řádek)
>>> s='ahoj nazdar      cau'
>>> s.split()
['ahoj', 'nazdar', 'cau']
>>> '1 2 8    12   94  16'.split()  
['1', '2', '8', '12', '94', '16']
>>> 'ahoj:nazdar   :    cau'.split(':') 
['ahoj', 'nazdar   ', '    cau']

`--> stáhnout

.join(seznam)
spojí všechny položky seznamu pomocí původního řetězce
>>> s='RETEZEC'
>>> s.join(['ahoj','nazdar','cau'])
'ahojRETEZECnazdarRETEZECcau'
>>> s.join('abcd')
'aRETEZECbRETEZECcRETEZECd'
>>> ':'.join(['ahoj','nazdar','cau'])
'ahoj:nazdar:cau'
>>> 

`--> stáhnout

.strip([chars])
ořeže řetězec o bílé znaky na začátku a na konci; je-li zadán dobrovolný parametr chars budou se odstraňovat právě tyto znaky
>>> s='    ahoj Karle  '
>>> s.strip()
'ahoj Karle'

>>> s='..:_.._...:ahoj Karle..:::.:__..:'
>>> s.strip('.:_')
'ahoj Karle'

`--> stáhnout

.find(sub,[ start, [ end ] ])
vrátí index -- pozice podřetězce sub v řetězci; je možné nepovinně zadat start a end jako pozice začátku a konce hledání
>>> s='ahoj nazdar      cau'
>>> s.find('na')
5
>>> s[5]
'n'

`--> stáhnout

.index(sub,[ start, [ end ] ])
stejné jako .find(), ale při nepřítomnosti podřetězce sub vyvolá běhovou chybu
>>> s='ahoj nazdar      cau'
>>> s.find('Q')
-1
>>> s.index('Q')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-21-2fa835f808f1> in <module>()
----> 1 s.index('Q')

ValueError: substring not found
>>>

`--> stáhnout

.count(sub,[ start, [ end ] ])
spočítá kolikrát se v řetězci nachází podřetězec sub; je možné nepovinně zadat start a end jako pozice začátku a konce hledání
>>> s='ahoj nazdar'
>>> s.index('z')
7
>>> s.index('d') 
8
>>> s.index('blbost')  
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-97-a7ff75aee7be> in <module>()
----> 1 s.index('blbost')

ValueError: substring not found

`--> stáhnout

.replace(old,new)
nahradí řetězec old řetězcem new
>>> s='ahoj nazdar      cau'
>>> s.replace('naz','NE')
'ahoj NEdar      cau'

`--> stáhnout

.decode(codepage)
převede datový typ str v zadaném kódování codepage na unicode;

Unicode řetězec lze získat rovnou tak, že před otvírací apostrof (uvozovku) zadáme písmeno u. Pokud je použito více-bytové kódování jak je např. UTF-8 často je převod na datový typ unicode nutnost, protože jinak dělat korektní výřezy a korektně se na jednotlivé znaky odkazovat pomocí indexů.

>>> s='Loď v úžině'
>>> u=s.decode('UTF-8')
>>> u=s.decode('UTF8')
>>> type(s)
str
>>> type(u)
unicode
>>> s
'Lo\xc4\x8f v \xc3\xba\xc5\xbein\xc4\x9b'
>>> u
u'Lo\u010f v \xfa\u017ein\u011b'
>>> print s[2]>>> print s[3]>>> print s[2:4]
ď
>>> print u[2]
ď
>>> len(s)
15
>>> len(u)
11
>>> abc=u'Loď v úžině'
>>> abc
u'Lo\u010f v \xfa\u017ein\u011b'
>>> u
u'Lo\u010f v \xfa\u017ein\u011b'

`--> stáhnout

.encode(codepage)
je opakem .decode() -- převede unicode řetězec do zadané znakové sady codepage
>>> u'Loď v úžině'
u'Lo\u010f v \xfa\u017ein\u011b'
>>> u'Loď v úžině'.encode('UTF8')
'Lo\xc4\x8f v \xc3\xba\xc5\xbein\xc4\x9b'
>>> u'Loď v úžině'.encode('cp1250')
'Lo\xef v \xfa\x9ein\xec'
>>> u'Loď v úžině'.encode('iso8859-2')
'Lo\xef v \xfa\xbein\xec'

`--> stáhnout

.format(seznam)
vrátí řetězec v němž jsou speciální konstrukce ve složených závorkách {...} nahrazeny hodnotami se seznamu

Jedná se vlastně o formátovací mikrojazyk. Jeho plný popis najdete v dokumentaci jako Format String Syntax. Zde uvádím jen to nejdůležitější:

Do složených závorek lze zapsat volitelně pořadí hodnoty v seznamu. Pro vložení znaku { nebo } je třeba jej zdvojit.

>>> 'jedna: {}, dva: {}, tri: {}'.format('ahoj',77, 3.1415)  
'jedna: ahoj, dva: 77, tri: 3.1415'
>>> 'jedna: {2}, dva: {0}, tri: {1}'.format('ahoj',77, 3.1415)
'jedna: 3.1415, dva: ahoj, tri: 77'
>>> 'jedna: {2}, dva: {0}, tri: {1}; znak {{'.format('ahoj',77, 3.1415)
'jedna: 3.1415, dva: ahoj, tri: 77; znak {'

`--> stáhnout

Dále lze přidat formátovací řetězec ve tvaru <šířka><,>.<přesnost><typ> <šířka> a <přesnost. jsou celá čísla. <,> říká že se má čárka jako oddělovač řádů.

<typ> význam
s řetězec
d číslo v desítkové soustavě
b číslo ve dvojkové soustavě
o číslo v osmičkové soustavě
x, X číslo v šestnáctkové soustavě
e, E reálné číslo v pevné řádové čárce
f, F reálné číslo v plovoucí řádové čárce
g, G zvolí e nebo f tak, aby se to dobře četlo
n jako g, ale podle locale rozhodne zda bude použita desetinná tečka nebo čárka
c znak -- převede celé číslo na znak
NIC (<typ> není zadán)    stejné jako s nebo d nebo g
>>> 'cele cislo {0:d}'.format(25) 
'cele cislo 25'

>>> 'cele cislo {0:20d}'.format(25)
'cele cislo                   25'

>>> 'cele cislo {0:10d}'.format(25)
'cele cislo         25'

>>> 'realne cislo {0:f}'.format(31415926.535897)
'realne cislo 31415926.535897'

>>> 'realne cislo {0:e}'.format(31415926.535897)
'realne cislo 3.141593e+07'

>>> 'realne cislo {0:5}'.format(31415926.535897)
'realne cislo 31415926.5359'

>>> 'realne cislo {0:20g}'.format(31415926.535897)  
'realne cislo          3.14159e+07'

>>> 'realne cislo {0:10.3g}'.format(31415926.535897)   
'realne cislo   3.14e+07'

>>> 'realne cislo {0:10.3f}'.format(31415926.535897)   
'realne cislo 31415926.536'

>>> 'realne cislo {0:20.3f}'.format(31415926.535897)   
'realne cislo         31415926.536'

>>> 'realne cislo {0:20,.3f}'.format(31415926.535897)
'realne cislo       31,415,926.536'

>>> 'retezec {0:s} KONEC'.format('Je tu hola veta.')
'retezec Je tu hola veta. KONEC'

>>> 'retezec {0:30s} KONEC'.format('Je tu hola veta.')
'retezec Je tu hola veta.               KONEC'

`--> stáhnout

Nula před <šířka> indikuje, že prázdná místa se mají vyplnit nulami.

>>> 'realne cislo {0:020.3f}'.format(31415926.535897) 
'realne cislo 0000000031415926.536'

>>> 'cele cislo {0:020b}'.format(165)
'cele cislo 00000000000010100101'

>>> 'cele cislo {0:20b}'.format(165)
'cele cislo             10100101'

`--> stáhnout

# tiskne s prefixem indikujícím číselnou soustavu

>>> 'cele cislo {0:#8b}'.format(92)
'cele cislo 0b1011100'

>>> 'cele cislo {0:#8x}'.format(92)
'cele cislo     0x5c'

`--> stáhnout

Výpis znaménka lze vynutit pomocí znaku +. Znak - nastaví výpis znaménka jen u záporných čísel a mezera vypisuje místo plus mezeru.

>>> 'cele cislo {0:f}'.format(pi) 
'cele cislo 3.141593'

>>> 'cele cislo {0:+f}'.format(pi)
'cele cislo +3.141593'

>>> 'cele cislo {0:+f}'.format(-pi)
'cele cislo -3.141593'

>>> 'cele cislo {0: f}'.format(-pi)
'cele cislo -3.141593'

>>> 'cele cislo {0: f}'.format(pi)
'cele cislo  3.141593'

`--> stáhnout

Zarovnání se děje pomocí znaků >, < , ^ a =, který slouží pro zarovnávání čísel.

>>> 'cele cislo {0:20.3f}'.format(pi)
'cele cislo                3.142'

>>> 'cele cislo {0:>20.3f}'.format(pi)
'cele cislo                3.142'

>>> 'cele cislo {0:<20.3f}'.format(pi)
'cele cislo 3.142               '

>>> 'cele cislo {0:^20.3f}'.format(pi) 
'cele cislo        3.142        '

>>> print '{:=20f}\n{:=20f}\n{:=20f}'.format(3.1415, 1.5, 125.8)
            3.141500
            1.500000
          125.800000

`--> stáhnout

Zarovnáme na střed 15 znaků 4 desetinná místa i se znaménkem

>>> print ':{0:^+020.4f}:'.format(pi) 
:000000+3.14160000000:
>>> print ':{0:^+20.4f}:'.format(pi)
:      +3.1416       :

`--> stáhnout

| navigace |

Posloupnosti

Mezi posloupnosti patří str (o něm bla řeč výše), dále tuple a list. Každý z těchto datových typů má své specifické vlastnosti, ale něco mají společné:

  1. Můžeme zjistit jejich délku pomocí funkce len():

    >>> s='ahoj Karliku'
    >>> len(s)
    --> 12

    `--> stáhnout

  2. Pomocí operátoru příslušnosti in můžeme zjišťovat přítomnost prvku v posloupnosti.

    >>> s='ahoj Karle'
    >>> 'Q' in s
    --> False
    >>> 'a' in s
    --> True
    >>> 'Ka' in s
    --> True

    `--> stáhnout

  3. Je možné je procházet, protože prvky jsou seřazené:

    s="Ahoj Karle."
    for pismeno in s:
        print pismeno

    `--> stáhnout

    A
    h
    o
    j
    
    
    K
    a
    r
    l
    e
    .
    
  4. Je možné dělat výřezy. Výřez je nový objekt. Výřez se děje pomocí hranatých závorek za názvem proměnné. Obecně může zápis vypadat takto: s[zacatek:konec:krok] -- ale zacatek, konec i krok lze vynechat.

>>> s="Ahoj Karle."
>>> len(s)
11
>>> s[0]
'A'
>>> s[2]
'o'
>>> s[-1]
'.'
>>> s[-2]
'e'
>>> s[-3]
'l'
>>> s[1:3]
'ho'
>>> s[-4:-1]
'rle'
>>> novy=s[2:-2]
>>> novy
'oj Karl'
>>> abc=s[:]
>>> abc
'Ahoj Karle.'

`--> stáhnout

>>> data=range(20)

>>> data
--> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

>>> data[0]
--> 0

>>> data[0:3]
--> [0, 1, 2]

>>> data[5:]
--> [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

>>> data[1:15]
--> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

>>> data[1:15:3]
--> [1, 4, 7, 10, 13]

>>> data[::2]
--> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

>>> data[::-2]
--> [19, 17, 15, 13, 11, 9, 7, 5, 3, 1]

>>> data[5::-2]
--> [5, 3, 1]

>>> data[-1]
--> 19
>>> data[-2]
--> 18

>>> data[-10:]
--> [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

>>> data[-8:14]
--> [12, 13]

>>> data[-8:16]
--> [12, 13, 14, 15]

`--> stáhnout

n-tice -- tuple()

tuple je také neměnitelný datový typ. Pokud proměnná vznikne není již možné její obsah měnit. Pomocí tuple můžeme uchovat vedle sebe -- v seznamu, několik proměnných libovolného datového typu. tuple se zapisuje do kulatých závorek a položky se oddělují čárkou.

>>> t=(1,2,3.1415,'ahoj')
>>> t
(1, 2, 3.1415, 'ahoj')
>>> t[0]
1
>>> t[3]
'ahoj'
>>> t[2:]
(3.1415, 'ahoj')
>>> t[0:2]
(1, 2)
>>> t
(1, 2, 3.1415, 'ahoj')

>>> t[0]=999
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-31-cbaa8d6267ce> in <module>()
----> 1 t[0]=999

TypeError: 'tuple' object does not support item assignment
>>> 

`--> stáhnout

S n-tice lze spojovat pomocí operátoru + nebo *

>>> t
(1, 2, 3.1415, 'ahoj')
>>> t+(7,8,9)
(1, 2, 3.1415, 'ahoj', 7, 8, 9)
>>> novy=t+(7,8,9)

>>> t
(1, 2, 3.1415, 'ahoj')
>>> t*3
(1, 2, 3.1415, 'ahoj', 1, 2, 3.1415, 'ahoj', 1, 2, 3.1415, 'ahoj')
>>> trikrat=t*3

`--> stáhnout

Protože je tuple neměnitelný děje se přidání položky do n-tice pomocí přepsání původní proměnné. Jedno-položkovou n-tici nestačí uzavřít do závorek ('polozka') ale musí následovat i čárka, aby Python dobře rozpoznal datový typ: ('polozka',)

>>> w=()
>>> w=w+(3.1415,)
>>> w=w+(5 ,)
>>> w=w+('abc' ,)
>>> w += (14 ,15)
>>> w += ('konec',)
>>> w
(3.1415, 5, 'abc', 14, 15, 'konec')
>>> w=()

`--> stáhnout

tuple má pouze dvě metody: .count() a .index(), které pracují podobě jako u řetězců.

>>> w
(3.1415, 5, 'abc', 14, 15, 'konec', 5, 14)
>>> w.count(5)
2
>>> w.count('QQ')
0
>>> w.index(5)
1
>>> w.index(14)
3
>>> w.index('QQ')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-71-acc7292a5218> in <module>()
----> 1 w.index('QQ')

ValueError: tuple.index(x): x not in tuple
>>>

`--> stáhnout

seznam -- list()

list je měnitelný datový typ -- i po jeho vytvoření lze data uvnitř přepsat. list se v mnohém podobá tuple, ale tím, že je měnitelný se k němu přistupuje jinak. Zápis seznamu se provádí do hranatých závorek.

>>> l=[1,2,18,3.1415,'Karel', 'Lenka', 77]
>>> l[5]
'Lenka'
>>> l[5]='Petr'
>>> l[5]
'Petr'
>>> l
[1, 2, 18, 3.1415, 'Karel', 'Petr', 77]
>>> 

`--> stáhnout

Metody .count() a .index() se chovají stejně jako u typů str a tuple.

Metody .append(), .extend(), .insert(), pop(), .remove(), reverse(), .sort() provádí změny přímo v seznamu.

Operátory + a * se chovají stejně jako u tuple nebo str. Přidání do seznamu lze provádět podobně jako u tuple -- přepsáním původního seznamu.

>>> l=[]
>>> l=l+[12]
>>> l=l+[3.1415]
>>> l += ['ahoj']
>>> l
[12, 3.1415, 'ahoj']
>>> l += [ 1,2,3]
>>> l
[12, 3.1415, 'ahoj', 1, 2, 3]
>>> l = l + [2.718]*5
>>> l
[12, 3.1415, 'ahoj', 1, 2, 3, 2.718, 2.718, 2.718, 2.718, 2.718]
>>> 

`--> stáhnout

Přidání do seznamu lze provádět také pomocí metody .append(object), .insert(object) nebo .extend(list). .append() a insert() přidává jeden prvek object. Pokud jako object použijeme seznam přidá se celý seznam pouze jako jedna položka seznamu.

>>> l = ['jedna']
>>> l.append(3.1415)
>>> l.append(77)
>>> l
['jedna', 3.1415, 77]
>>> 
>>> l.append([1,2,3])
>>> l
['jedna', 3.1415, 77, [1, 2, 3]]
>>> l[2]
77
>>> l[3]
[1, 2, 3]
>>> l[3][0]
1
>>> l[3][1]
2
>>> l[3][2]
3

`--> stáhnout

>>> l=['jedna', 3.1415, 77, [1, 2, 3]]
>>> l
--> ['jedna', 3.1415, 77, [1, 2, 3]]

>>> l.insert(2,"AAAAA")
>>> l
--> ['jedna', 3.1415, 'AAAAA', 77, [1, 2, 3]]

>>> l.insert(4,987654321)
>>> l
--> ['jedna', 3.1415, 'AAAAA', 77, 987654321, [1, 2, 3]]

`--> stáhnout

Jestli-že chceme přidat nejednou více prvků použijeme metodu .extend(iterator), která iterator -- seznam před přidáním do seznamu rozbalí.

>>> l = ['jedna']
>>> l.extend([1,2,3])
>>> l
['jedna', 1, 2, 3]
>>> 

`--> stáhnout

Metody reverse() a sort() mají výmluvný název -- slouží k převrácení a seřazení seznamu.

>>> l
--> [[1, 2, 3], 987654321, 77, 'AAAAA', 3.1415, 'jedna']

>>> l.sort()

>>> l
--> [3.1415, 77, 987654321, [1, 2, 3], 'AAAAA', 'jedna']

`--> stáhnout

K odstranění prvku se seznamu slouží metoda pop([index]). Pokud index není zadán odstraní se vždy poslední prvek. Důležité je, že návratovou hodnotou metody pop() je právě odstraněný prvek.

>>> l
--> [3.1415, 77, 987654321, [1, 2, 3], 'AAAAA', 'jedna']

>>> l.pop()
--> 'jedna'
>>> l
--> [3.1415, 77, 987654321, [1, 2, 3], 'AAAAA']

>>> l.pop()
--> 'AAAAA'
>>> l
--> [3.1415, 77, 987654321, [1, 2, 3]]

>>> l.pop(1)
--> 77
>>> l
--> [3.1415, 987654321, [1, 2, 3]]

`--> stáhnout

Metoda remove(value), také odstraní prvek, ale ne podle indexu nýbrž podle hodnoty value.

>>> l=['jedna', 3.1415, 'AAAAA', 77, 987654321]

>>> l.remove('AAAAA')
>>> l
--> ['jedna', 3.1415, 77, 987654321]

>>> l.remove(77)
>>> l
--> ['jedna', 3.1415, 987654321]

>>> l.remove('to tu neni')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-92-5bf3a791221d> in <module>()
----> 1 l.remove('to tu neni')

ValueError: list.remove(x): x not in list

`--> stáhnout

| navigace |

Množiny -- set()

Množina je neuspořádaná kolekce jedinečných prvků. Přidání duplicitních prvků je bezpečné, ale bezúčelné. Tento datový typ je měnitelný. Počet prvků v množině určíme pomocí funkce len().

Vytváří se pomocí složených závorek a/nebo pomocí funkce set(). Prázdná množina se vytváří výhradně pomocí funkce set() -- prázdné složené závorky by vedly k vytvoření prázdného slovníku.

>>> set({'jablko','hruska', 'merunka', 'jablko','merunka'})
--> {'hruska', 'jablko', 'merunka'}

>>> {'jablko','hruska', 'merunka'}
--> {'hruska', 'jablko', 'merunka'}

>>> set()
--> set()

>>> ovoce = {'jablko','hruska', 'merunka', 'jablko','merunka'}

>>> zelenina=set()

>>> type(ovoce)
--> set

>>> type(zelenina)
--> set

>>> set('alenka')
--> {'a', 'e', 'k', 'l', 'n'}

`--> stáhnout

Některé metody

s.add(x) Přidá prvek x do množiny s.
s.update(t) Přidá do množiny s prvky z množiny t.
s.pop() Odstraní z množiny s náhodný prvek a vydá ho jako svou návratovou hodnotu.
s.remove(x) Odstraní z množiny s prvek x.
s.clear() Odstraní všechny prvky z množiny s.
s.copy() Vrátí mělkou kopii množiny s.
>>> ovoce
--> {'hruska', 'jablko', 'merunka'}

>>> ovoce.add('tresne')

>>> ovoce
--> {'hruska', 'jablko', 'merunka', 'tresne'}

>>> ovoce.pop()
--> 'hruska'

>>> ovoce.pop()
--> 'jablko'

>>> ovoce
--> {'merunka', 'tresne'}

>>> ovoce.remove('tresne')

>>> ovoce
--> {'merunka'}

>>> ovoce.update({'hruska', 'jablko', 'merunka'})

>>> ovoce
--> {'hruska', 'jablko', 'merunka'}

`--> stáhnout

Operace s množinami

a | b Sjednocení -- vrátí všechny prvky množiny a i b.
a & b Průnik -- vrátí všechny prvky společné množině a a b.
a - b Rozdíl -- vrátí množinu a zbavenou všech prvků, které byly obsaženy v b
a ^ b Symetrický rozdíl -- vrátí množinu obsahující prvky množiny a i b, ale bez prvků, které jsou v obou množinách.
>>> set("KVOCNA") | set('NOCI')
--> {'A', 'C', 'I', 'K', 'N', 'O', 'V'}

>>> set("KVOCNA") & set('NOCI')
--> {'C', 'N', 'O'}

>>> set("KVOCNA") - set('NOCI')
--> {'A', 'K', 'V'}

>>> set("KVOCNA") ^ set('NOCI')
--> {'A', 'I', 'K', 'V'}

`--> stáhnout

Množiny lze také procházet:

>>> ovoce
--> {'hruska', 'jablko', 'merunka'}

>>> for o in ovoce:
...:     print o
hruska
jablko
merunka

`--> stáhnout

Pravdivostní operátory

== Testuje shodnost množin
in Testuje příslušnost prvku v množině
a.isdisjoint(b) Vrátí True pokud a a b nemají žádný společný prvek.
a < b a je podmnožinou b.
a <= b a je podmnožinou nebo ekvivalentem b.
a > b a je nadmnožinou b.
a >= b a je nadmnožinou nebo ekvivalentem b.
>>> {'hruska', 'jablko', 'merunka'} == {'jablko', 'merunka', 'hruska'}
--> True

>>> 'merunka' in {'jablko', 'merunka', 'hruska'}
--> True

>>> 'datel' in {'jablko', 'merunka', 'hruska'}
--> False

>>> ovoce.isdisjoint({'datel', 'zeli'})
--> True

>>> set('KOSTNI DREN') > set ('DREN')
--> True

>>> set('KOSTNI DREN') > set ('ODRENINA')
--> False

>>> set('KOSTNI DREN') > set ('ODRENINA')
--> False

>>> set('KOSTNI DREN') >= set ('DREN')
--> True

>>> set('KOSTNI DREN') >= set ('KOSTNI DREN')
--> True

>>> set('KOSTNI DREN') > set ('KOSTNI DREN')
--> False

`--> stáhnout

Slovníky -- dict()

Tento datový typ implementuje tzv. asociativní pole. Položky v kolekci nejsou indexovány pomocí celočíselných indexů, ale pomocí klíčů. Klíčem může být některý s neměnitelných datových typů. Datový type dict je ale měnitelný.

Zapisuje se složených závorek {} vždy jako dvojice klíč:hodnota. Pokud je při přiřazení použit klíč, který neexistuje vytvoří se.

>>> d = {1: 'ahoj', 'neco': 3.14, 'slovo': 1}
>>> d
--> {1: 'ahoj', 'neco': 3.14, 'slovo': 1}

>>> d={}
>>> d['slovo'] = 1
>>> d['neco'] = 3.14
>>> d[1] = 'ahoj'
>>> d
--> {1: 'ahoj', 'neco': 3.14, 'slovo': 1}

`--> stáhnout

Slovník dict() podporuje operátor příslušnosti in, počet prvků lze zjistit pomocí funkce len() a slovníky mezi sebou lze porovnat pomocí operátorů == a !=.

>>> d = {1: 'ahoj', 'cislo': 3.14}
>>> len(d)
--> 2

>>> 3.14 in d
--> False
>>> 'cislo' in d
--> True

>>> {1: 'ahoj', 'cislo': 3.14} == {1: 'ahoj', 'cislo': 3.14}
--> True

>>> {2: 'ahoj', 'cislo': 3.14} == {1: 'ahoj', 'cislo': 3.14}
--> False

>>> {1: 'ahojjj', 'cislo': 3.14} == {1: 'ahoj', 'cislo': 3.14}
--> False

`--> stáhnout

Slovníky lze procházet. Stejně jako při testování pomocí in se prochází klíče, nikoli hodnoty.

>>> for i in {1: 'ahojjj', 'cislo': 3.14}:
..:     print i
..: 
1
cislo

`--> stáhnout

Spojování slovníků se děje pomocí metody .updte() nebo pomocí funkce dict(). Operátor ** viz rozbalení slovníku.

>>> d1
--> {'a': 123, 'b': 985}

>>> d2
--> {'ahoj': 'pozdrav'}

>>> dict(d1, **d2)
--> {'a': 123, 'ahoj': 'pozdrav', 'b': 985}

>>> d={}

>>> d.update(d1)

>>> d
--> {'a': 123, 'b': 985}

>>> d.update(d2)

>>> d
--> {'a': 123, 'ahoj': 'pozdrav', 'b': 985}

>>> d = dict( d1.items() + d2.items() )

`--> stáhnout

Některé zajímavé metody

d.has_key(k) Vrátí True nebo False pokud slovník d obsahuje nebo neobsahuje klíč k.
d.keys() Vrátí pohled tvořený všemi klíči.
d.values() Vrátí pohled tvořený všemi hodnotami.
d.items() Vrátí pohled tvořený všemi dvojicemi (klíč,hodnota).
>>> d={}
>>> d['cislo']=3.14
>>> d['jmeno']='Karel'
>>> d[1]='ahoj'
>>> d[2]='nazdar'
>>> d
--> {1: 'ahoj', 2: 'nazdar', 'cislo': 3.14, 'jmeno': 'Karel'}

>>> d.values()
--> ['ahoj', 'nazdar', 'Karel', 3.14]

>>> d.keys()
--> [1, 2, 'jmeno', 'cislo']

>>> d.items()
--> [(1, 'ahoj'), (2, 'nazdar'), ('jmeno', 'Karel'), ('cislo', 3.14)]

>>> d.items()[2]
--> ('jmeno', 'Karel')
>>> d.items()[2][0]
--> 'jmeno'
>>> d.items()[2][1]
--> 'Karel'

`--> stáhnout

d.get(k) Vrátí hodnotu spojenou s klíčem k nebo None pokud klíč neexistuje.
d.get(k,v) Vrátí hodnotu spojenou s klíčem k nebo v pokud klíč neexistuje.
>>> d={}
>>> d['cislo']=3.14
>>> d['jmeno']='Karel'
>>> d[1]='ahoj'
>>> d[2]='nazdar'
>>> d
--> {1: 'ahoj', 2: 'nazdar', 'cislo': 3.14, 'jmeno': 'Karel'}

>>> d.get('jmeno')
--> 'Karel'

>>> d.get('HogoFogo')

>>> d.get('HogoFogo',59)
--> 59

`--> stáhnout

d.popitem() Odstraní náhodnou položku/hodnotu a vrátí ji jako pohled.
d.pop(k) Odstraní položku spojenou s klíčem k a vrátí ji jako pohled.
d.pop(k,v) Odstraní položku spojenou s klíčem k a vrátí ji jako pohled. Pokud klíč neexistuje vrátí v.
>>> d
--> {1: 'ahoj', 2: 'nazdar', 'cislo': 3.14, 'jmeno': 'Karel'}

>>> d.pop(2)
--> 'nazdar'
>>> d
--> {1: 'ahoj', 'cislo': 3.14, 'jmeno': 'Karel'}
>>> d.pop('jmeno')
--> 'Karel'
>>> d
--> {1: 'ahoj', 'cislo': 3.14}

>>> d.popitem()
--> (1, 'ahoj')
>>> d
--> {'cislo': 3.14}

`--> stáhnout

| navigace |

Práce s daty

Konverze datových typů

Python neprovádí automatickou typovou konverzi a proto se o ni musí postarat programátor.

>>> 5+3
--> 8

>>> 5+'3'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-152-34a41dff9c04> in <module>()
----> 1 5+'3'

TypeError: unsupported operand type(s) for +: 'int' and 'str'

>>> 5+float('3')
--> 8.0

`--> stáhnout

Každý datový typ má svou funkci, které se pokusí převést předložený data na svůj vlastní datový typ. Někdy to možné je. Jindy to možné není. Pokud to možné není dojde k běhové chybě.

>>> bool('0')
--> True

>>> bool(0)
--> False

>>> bool('ahoj')
--> True

>>> bool('')
--> False

>>> bool(10)
--> True

`--> stáhnout

>>> int('5')
--> 5

>>> int('5.1')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-162-e67d7b0b70d0> in <module>()
----> 1 int('5.1')

ValueError: invalid literal for int() with base 10: '5.1'

>>> int(5.1)
--> 5

>>> int(5.9)
--> 5

>>> float('5.1')
--> 5.1

>>> float('5')
--> 5.0

>>> complex('5')
--> (5+0j)

>>> complex(3.14)
--> (3.14+0j)

`--> stáhnout

>>> str(123)
--> '123'

>>> str(3.1415)
--> '3.1415'

>>> str(3+5j)
--> '(3+5j)'

>>> str('a','b','c')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-172-c6ee0c0a01c0> in <module>()
----> 1 str('a','b','c')

TypeError: str() takes at most 1 argument (3 given)

>>> str(('a','b','c'))
--> "('a', 'b', 'c')"

>>> print str(('a','b','c'))
('a', 'b', 'c')

>>> print str(['a','b','c'])
['a', 'b', 'c']

`--> stáhnout

>>> tuple('ahoj Karle')
--> ('a', 'h', 'o', 'j', ' ', 'K', 'a', 'r', 'l', 'e')

>>> list('ahoj Karle')
--> ['a', 'h', 'o', 'j', ' ', 'K', 'a', 'r', 'l', 'e']

>>> list( {"A", "B", "C"} )
--> ['A', 'C', 'B']

>>> set('ABC')
--> {'A', 'B', 'C'}

`--> stáhnout

>>> dict([ ('a',1), ('b',2)  ]) 
--> {'a': 1, 'b': 2}

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

>>> d=dict([ ('a',1), ('b',2) , ('c',3) ])

>>> d['a']
--> 1

>>> d['c']
--> 3

`--> stáhnout

Vícerozměrné seznamy a tečková notace

Odkazy, ukazatele

Pokud v Pythonu vytváříme nějaké kolekci jako je tuple(), list(), set() nebo dict() jedná se vždy pouze o kolekci ukazatelů. Z nepochopení toho principu vyplývá zdánlivě nelogické chování, které Python vykazuje. Proto mu prosím věnujte pozornost:

Protože kolekce uchovávají odkazy můžeme do nich uložit libovolný datový typ a vytvářet libovolné datové struktury libovolné hloubky. Pokud chceme k jednotlivým položkám přistupovat použijeme hranaté závorky [...].

V následující ukázce je proměnná l. Ta obsahuje odkazy na seznamy. Takže l[0] je seznam, na která ukazuje nultá položka l. l[0][2] je druhá položka seznamu x, na který ukazuje nultá položka l. :-)

V Pythonu lze pomocí tečky . přistoupit k metodám daného datového typu. To už známe:

>>> s='   ahoj   '

>>> s.strip()
--> 'ahoj'

>>> s.upper()
--> '   AHOJ   '

`--> stáhnout

Ale návratovou hodnotou metody .strip() je opět řetězec. Proto lze psát rovnou

>>> s.strip().upper()
--> 'AHOJ'

`--> stáhnout

Podobně tomu může být pokud vnoříme seznamy, nebo do seznamu vložíme řetězec.

>>> x = [0,1, 2, 3, 4 , 5 ]
>>> y = ['abcd','Ahoj', 'slovo']
>>> l=[x,y]

>>> l[1].pop()
--> 'slovo'

>>> l[1].pop().upper()
--> 'AHOJ'

>>> y
--> ['abcd']

`--> stáhnout

>>> seznam=[7,3.1415,"Ahoj"]

>>> seznam[2].swapcase()
--> 'aHOJ'
>>> seznam[2].swapcase().index('H')
--> 1

`--> stáhnout

Kopírování kolekcí

Mělká kopie

Jak bylo řečeno, všechny proměnné v Pythonu uchovávají pouze odkazy na objekty. To se pokouší demonstrovat následující ukázka.

Změním sice proměnnou b ale změna proběhne i uvnitř a protože a i b ukazuje na stejný objekt. Proto pokud chceme vytvořit skutečnou kopii (říká se jí mělká kopie) použijeme výřez, který vyřeže všechny prvky. Při výřezu totiž vždy vzniká nový objekt.

V následující ukázce je změna oproti předchozí pouze na řádku 2.

Předchozí ukázky byly pro přehlednost trochu zjednodušené. Ve skutečnosti každá proměnná i každá kolekce tuple, list, set, dict uchovává jen odkazy. Situace tedy ve skutečnosti vypadá takto:

Hluboká kopie

Jsou ale situace, kdy si s mělkou kopií nevystačíme. Například u vícerozměrných seznamů. Vytvoříme sice nový objekt seznam, ale jsou v něm ty stejné odkazy na ty stejné původní objekty.

Tuto situaci řeší modul copy a jeho metoda deepcopy.

import copy
food = copy.deepcopy(jidlo)

`--> stáhnout

Iterátory

Iterátor je objekt, který můžeme procházet a on nám postupně vrací jednotlivé položky. Pří každém průchodu si objekt pamatuje kde skončil. Iterátory jsou výhodné tím, že snižují spotřebu paměti. Každý objekt, ze kterého je možné vytvořit iterátor je iterovatelný. Iterovatelné jsou datové typy str, tuple, list, set, dict, ... a další, které ještě neznáme.

Iterátory se vytváří automaticky na pozadí, kdykoli se použije cyklus for. Ručně ho lze vytvořit pomocí funkce iter().

>>> i=iter('ABC')
>>> i.next()
--> 'A'
>>> i.next()
--> 'B'
>>> i.next()
--> 'C'
>>> i.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-75-e590fe0d22f8> in <module>()
----> 1 i.next()

StopIteration: 

`--> stáhnout

Pro jednoduché vytváření vlastních iterátorů slouží standardní modul itertools.

Operátory a funkci pro iterátory a iterovatelné objekty

Některé z nich už známe, ale je myslím vhodné uvést jejich přehled:

len(i)
Vrátí počet prvků.
x in i
Vrátí True pokud je prvek x v iterovatelném objektu i.
all(i)
Vrátí True pokud se všechny prvky v iterovatelném objektu i vyhodnotí jako True.
any(i)
Vrátí True pokud se alespoň jeden prvek v iterovatelném objektu i vyhodnotí jako True.
max(i[,f]), min(i[,f])
Vrací nejmenší/největší prvek. Jako volitelný parametr lze specifikovat i funkci key=f, která se provede s každým prvkem před zahájením porovnávání.
sum(i[,start])
Vrátí součet všech prvků v iterovatelném objektu i.
reversed(i)
Vrátí iterátor, který vrací prvky v opačném pořadí než původní i.
sorted(i)
Vrátí seřazený seznam prvků z iterátoru i. Má několik volitelných parametrů, pomocí kterých lze řazení řídit.
range(start[,stop[,krok]])
Vrátí list (v Pythonu3 iterátor) podle hranic start, stop s krokem krok. Prametry stop a krok jsou volitelné.
enumerate(i)
Poskytuje posloupnost objektů tuple o dvou dvou hodnotách: (index, prvek) z iterátoru i.
>>> seznam=['ahoj', 'nazdar', 'cus bus']
>>> i=enumerate(seznam)

>>> i.next()
--> (0, 'ahoj')
>>> i.next()
--> (1, 'nazdar')
>>> i.next()
--> (2, 'cus bus')

`--> stáhnout

Používá se běžně v cyklech for.

>>> for index,prvek in enumerate(seznam):
    ...:     print index,prvek
    ...: 
0 ahoj
1 nazdar
2 cus bus

`--> stáhnout

zip(i1, i2, .....,iN)
Vezme seznam iterátorů a postupně vrací první, druhý, třetí atd. prvek z každého z nich.
   1 >>> velka="ABCD"
   2 >>> mala="abcd"
   3 >>> cisla="1234"
   4 
   5 >>> for i in zip(velka, mala, cisla):
   6 ...:     print i
   7 ...: 
   8 ('A', 'a', '1')
   9 ('B', 'b', '2')
  10 ('C', 'c', '3')
  11 ('D', 'd', '4')

`--> stáhnout

Rozbalení seznamu

Seznam lze rozbalit pomocí prefixu *. Lze to použít například při volání funkce.

>>> def soucet(a,b):
..:     return a+b

>>> seznam=[3,10]

>>> soucet(seznam)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-302-97d5e195d033> in <module>()
----> 1 soucet(seznam)

TypeError: soucet() takes exactly 2 arguments (1 given)

>>> soucet(*seznam)
--> 13

`--> stáhnout

Pokud funkci předám seznam je celý seznam brán jako jeden argument. Pokud ale před seznam zařadím * seznam se rozbalí a každý jeho prvek je brán jako jeden argument.

Rozbalení slovníku

Slovník lze rozbalit pomocí operátoru **. Toto rozbalení se dá použít opět při volání funkce. Slovníkové klíče potom fungují jako jména parametrů předaných funkci.

>>> def soucet(a,b):
..:     return a+b

>>> slovnik={}
>>> slovnik['a']=11
>>> slovnik['b']=18
>>> slovnik
--> {'a': 11, 'b': 18}

>>> soucet(**slovnik)
--> 29

`--> stáhnout

| navigace |

Podmínky

Přiřazení podobné termálnímu operátoru

# absolutní hodnota
x = a if a>0 else -a

`--> stáhnout

if [ elif ] [ else ]

Podmíněné vykonání části programu je realizované pomocí konstrukce if. Podmínku if lze zapsat třemi různými formami. Podmínku tvoří vždy jakýkoliv pravdivostní výraz.

jednoduchá:

if cislo<0 :
    cislo = -cislo

`--> stáhnout

alternativní:

if cislo>0 :
    x = cislo
else:
    x = - cislo

`--> stáhnout

vícenásobná:

if vek>=0 and vek<=10 :
    print "Toto je dítě"
elif vek>=30 and vek<=50 :
    print "Toto je rodič"
elif vek>50 :
    print "Toto je prarodič"
else:
    print "Toto je mladík"

`--> stáhnout

| navigace |

Cykly

Python rozlišuje dva druhy cyklů. Cyklus for je určen pro předem známí počet opakování. Cyklus while je určen do situací, kdy nejde předem říci kolikrát se bude kód opakovat.

Cyklus for

Typickým použitím cyklu for je procházení nějakou kolekcí (str, list, tuple, set):

for cislo in (2,3,5,7,11,13,17):
    print cislo
print "KONEC"

`--> stáhnout

for pismenko in "Toto je veta": 
    print pismenko
print "KONEC"

`--> stáhnout

Dalším typickým použitím je procházení předem známého seznamu čísel:

print "Násobky čísla 5"
for i in range(5,100,5):
    pritn i
print "KONEC"

`--> stáhnout

V cyklu for můžeme použít i vícenásobné přiřazení pokud kolekce, kterou procházíme obsahuje další kolekci:

>>> souradnice = [ (1,2), (14,25), (128,574), (7895,6548) ]

>>> for x,y in souradnice:
   ...:     print x,y
   ...: 
1 2
14 25
128 574
7895 6548

`--> stáhnout

Tohoto se typicky využívá ve spojení s funkcí enumerate (viz operátory pro iterátory) tehdy, když zároveň s prvkem potřebujeme také jeho index.

>>> seznam = ['ahoj', 'nazdar', 'cus bus']
>>> for index,prvek in enumerate(seznam):
    ...:     print index,prvek
    ...: 
0 ahoj
1 nazdar
2 cus bus

`--> stáhnout

Cyklus while

Cyklus while má podmínku (stejně jako if) a o jeho opakování rozhoduje vždy platnost podmínky.

 i=1.0
while i>0.01:
    print i
    i = i - i/2.
print "KONEC"

`--> stáhnout

Řízení cyklu a else.

Pro naše pohodlí a větší srozumitelnost programů lze v cyklech využít příkazy break, continue a sekci else.

break

break -- brzda okamžitě ukončí vykonávání cyklu. Příkazy uvedení za break se už neprovádí.

for i in range(100):
    print i
    if i>5: 
        break
        print "tohle se neprovede"
    print "jedu"

`--> stáhnout

continue

continue vrátí řízení zpět na začátek cyklu. To znamená, že se přeskočí zbytek těla cyklu, ale cyklus neopustí. Pokud jde o cyklus while kontroluje se podmínka.

i=0
while i<10:
    i+=1
    print "pokracuji"
    if i>5: 
        continue
    print i

`--> stáhnout

else:

Cyklus for i while mají nepovinnou sekci else. Kód v sekci else se provádí po korektním ukončení cyklu. Pokud byl cyklus ukončen pomocí break, nebo return nebo pokud nastala výjimka kód se neprovede.

for n in range(2, 20):
    for x in range(2, n):
        if n % x == 0:
            print n, '=', x, '*', n/x
            break
    else:
        print n, 'je prvočíslo'

`--> stáhnout

| navigace |

Funkce

Funkce jsou prostředky, díky kterým můžeme určitou funkčnost zabalit, opakovaně používat a parametrizovat. Funkci vždy předáváme jeden nebo více parametrů (nebo žádný). Funkce nám obvykle vrátí nějaký výsledek.

def cislo(a,b,c):
    a = 100*a
    b *= 10
    return a+b+c

>>> cislo(3,5,4)
--> 354

>>> cislo(8,1,4)
--> 814

>>> cislo(x,1,y)
--> 813

>>> cislo(y,1,x)
--> 318

`--> stáhnout

Proměnné a,b a c jsou lokální a jsou přístupné jen uvnitř funkce. Proměnná uvnitř funkce nemají nic společného s proměnnými vně.

>>> a,b = 1,2

>>> cislo(9,a,b)
--> 912

>>> a,b
--> (1, 2)

`--> stáhnout

Výchozí hodnoty parametrů

Python umožňuje definovat u každého parametru výchozí hodnotu:

def cislo(a,b=8,c=9):
    a = 100*a
    b *= 10
    return a+b+c

`--> stáhnout

Při volání je potom možné parametry z výchozí hodnotou vynechat nebo je pojmenovat a vyměnit jejich pořadí.

>>> cislo(1)
--> 189

>>> cislo(1,2)
--> 129

>>> cislo(1,c=5)
--> 185
>>> cislo(a=1,c=5)
--> 185

>>> cislo(a=1, c=5, b=4)
--> 145

`--> stáhnout

Volitelné parametry

Dalším fíglem, který python umožňuje jsou volitelné parametry. Ty je možné kombinovat s klasickými (pozičními) parametry nebo je použít samostatně.

Volitelné poziční parametry

Volitelné parametry se deklarují pomocí operátoru * před názvem proměnné. Taková proměnná potom bude do funkce předána jako tuple.

def prumer(*args):
    soucet=0.0
    for i in args:
        soucet+=i
    return soucet/len(args)

>>> prumer(1,2,3,4)
--> 2.5

>>> prumer(1,2,3,4,8,12,1)
--> 4.428571428571429

>>> prumer(1,2)
--> 1.5

`--> stáhnout

Chování je poměrně logické, ale na druhou stranu nemůžeme po Pythonu chtít, aby si domyslel to, co domyslet nelze.

def funkce(a,b=5,*args):
    print 'a:',a
    print 'b:',b
    print args


>>> funkce(8)
a: 8
b: 5
()

>>> funkce(8,555)
a: 8
b: 555
()

>>> funkce(888,555,1,2,3)
a: 888
b: 555
(1, 2, 3)

>>> funkce(888,b=555,1,2,3)
  File "<ipython-input-46-edc32c0e4849>", line 1
    funkce(888,b=555,1,2,3)
SyntaxError: non-keyword arg after keyword arg

`--> stáhnout

Volitelné pojmenované parametry

Volitelné pojmenované parametry se deklarují pomocí operátoru ** před názvem proměnné. Taková proměnná potom bude do funkce předána jako dict.

def funkce(*args,**kwargs):
    print args
    print kwargs


>>> funkce(1,2,3)
(1, 2, 3)
{}

>>> funkce(1,2,3,jmeno='Karel', znamka=1)
(1, 2, 3)
{'znamka': 1, 'jmeno': 'Karel'}

>>> funkce(jmeno='Karel', znamka=1, cislo=89)
()
{'znamka': 1, 'jmeno': 'Karel', 'cislo': 89}

>>> funkce(1,2,3,jmeno='Karel', znamka=1,8)
  File "<ipython-input-59-3a00d57304cf>", line 1
    funkce(1,2,3,jmeno='Karel', znamka=1,8)
SyntaxError: non-keyword arg after keyword arg

`--> stáhnout

S voláním funkcí také velice úzce souvisí rozbalení seznamu a rozbalení slovníku.

| navigace |

Generátory

Generátor je iterovatelný objekt. Generátor lze použít všude tam, kde iterátor. Lze ho vytvořit jako výraz nebo jako funkci:

   1 >>> mocniny = (2**i for i in xrange(10))
   2 >>> type(mocniny)
   3 --> generator
   4 
   5 >>> mocniny.next()
   6 --> 1
   7 >>> mocniny.next()
   8 --> 2
   9 >>> mocniny.next()
  10 --> 4
  11 >>> mocniny.next()
  12 --> 8
  13 >>> mocniny.next()
  14 --> 16
  15 >>> mocniny.next()
  16 --> 32
  17 for i in mocniny:
  18    ...:     print i
  19    ...: 
  20 64
  21 128
  22 256
  23 512

`--> stáhnout

Generátorové funkce

Jsou to funkce, které obsahují výraz yield. Při každém zavolání funkce se vrátí hodnota výrazu yield, ale mezi jednotlivými voláními funkce se udržují hodnoty proměnných.

>>> def mocniny():
..:     a=1
..:     while a<1e6:
..:         yield a
..:         a = 2*a
..:     return

>>> for i in mocniny():
..:     print i,
1 2 4 8 16 32 64 128 256 512 1024 2048 4096 
8192 16384 32768 65536 131072 262144 524288

`--> stáhnout

| navigace |

Soubory, výjimky, moduly, balíčky, objekty

U těchto témat se spolehnu na to co napsaly jiní:

| navigace |

Funkcionální přístup

Comprehension

Tato kapitola by se dala také nazvat Stručný senzam

Obecný zápis je:

seznam = [VLOŽIT for prom in zdroj_seznam if vyraz] 

Například:

>>> mocniny = [i*i for i in range(10)]
--> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> suda = [i for i in range(20) if i%2==0]
--> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

>>> sez=[1,5,3]
>>> l=[n*m for n in sez for m in range(4)]
--> [0, 1, 2, 3, 0, 5, 10, 15, 0, 3, 6, 9]

>>> kvadrat = [[n,n*n] for n in range(5)]
--> [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16]]

`--> stáhnout

Comprehension se používají většinou pro seznamy list ale můžeme je stejně tak použít i pro množiny set nebo n-tice tuple.

>>> {i*i for i in range(10)}
--> {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

>>> tuple(i*i for i in range(10))
--> (0, 1, 4, 9, 16, 25, 36, 49, 64, 81)

`--> stáhnout

Podobně lze vytvářet i slovníky dict. Obecná syntax vypadá asi takto:

slovnik = { VLOŽ_KLÍČ : VLOŽ_HODNOTU for prom in zdroj_seznam if vyraz }
>>> slovnik = { k : ord(k) for k in "abcdefg".upper() }

>>> slovnik
--> {'A': 65, 'B': 66, 'C': 67, 'D': 68, 'E': 69, 'F': 70, 'G': 71}

`--> stáhnout

Lambda

Lambda je způsob, jak převést jednoduchý výraz na funkci. Používá se, když potřebujete získat funkci, která dělá totéž jako obyčejný výraz.

f=lambda x,y : x%y      # vytvoření funkce f(x,y) vracející zbytek po celočíselném dělení x/y
f(12,7)                 # volání funkce f, vrátí 5
liche=lambda x: x%2==1  # funkce, která vrací True, pokud je argument lichý
liche(12)               # vrátí False

`--> stáhnout

Zabudované funkce pro funkcionální programování

filter(f,sek)
f -- libovolná funkce;
sek -- posloupnost

Vrátí posloupnost těch prvků z posloupnosti sek, pro které vrátí funkce f hodnotu True.

>>> delitele_sesti=filter(lambda x: x%6==0 ,range(20,60))
--> [24, 30, 36, 42, 48, 54]

`--> stáhnout

map(f,sek)
f -- libovolná funkce
sek -- posloupnost

Zavolá postupně funkci f všemi hodnotami posloupnosti a vrátí novou posloupnost z výsledků pokud má funkce f více argumentů, musí se použít stejný počet posloupností (pokud jejich délka neodpovídá, místo chybějících prvků se posílá hodnota none)

>>> mocniny = map(lambda x: x*x, range(10))
--> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# hromadně převedu řetězce na čísla
>>> map(int, "1 2 3 4 5 6 7 8 9".split())
--> [1, 2, 3, 4, 5, 6, 7, 8, 9]

# roznásobí seznamy
>>> map(lambda x,y : x*y, [1,2,3,4,5], [2,3,4,5,6] )
--> [2, 6, 12, 20, 30]

# po vynechání funkce vrátí seznam dvojic tuplů
>>> map(None, range(5), range(2,6))
--> [(0, 2), (1, 3), (2, 4), (3, 5), (4, None)]

`--> stáhnout

reduce(f,sek)
f -- funkce se dvěma argumenty
sek -- posloupnost

Složí posloupnost do jediné hodnoty tak, že vezme první dva prvky poslounosti, dosadí je do funkce a vrátí místo nich výsledek. Takto pokračuje, až do konce seznamu.

>>> seznam = [1, 2, 3, 4]
>>> reduce(lambda x,y : x+y, seznam)
--> 10

>>> faktorial = reduce(lambda x,y : x*y, range(1,6))
--> 120

`--> stáhnout

| navigace |

Tipy a triky

| navigace |

Licence Creative Commons Valid XHTML 1.0 Strict Valid CSS! Antispam.er.cz Blog: Tlapicka.net