Tyto stránky již nejsou udržovány. Obsah je postupně přesouván/aktualizován na adrese chytrosti.marrek.cz.
1565/5732
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:
>>> i=176
>>> i
176
>>> 20 / 6
3
>>> 20 % 6
2
>>> 2**5
32
`--> stáhnout
+
, -
, *
/
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()
.
| |
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
>>> 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
.
>>> 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
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
==
, !=
-- 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.
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
\n
konec řádku
\r
návrat vozíku
\t
tabulátor
\\
a zpětné lomítko
\"
, \'
uvozovka, apostrof
\x
hh znak se zadanou hexadecimální hodnotou: např. \x64
je @
\u
hhhh 16-bitový znak Unicode
\U
hhhhhhhh 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:
.lower()
, .upper()
, .swapcase
>>> 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)
>>> 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)
>>> s='RETEZEC'
>>> s.join(['ahoj','nazdar','cau'])
'ahojRETEZECnazdarRETEZECcau'
>>> s.join('abcd')
'aRETEZECbRETEZECcRETEZECd'
>>> ':'.join(['ahoj','nazdar','cau'])
'ahoj:nazdar:cau'
>>>
`--> stáhnout
.strip([chars])
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 ] ])
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 ] ])
.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 ] ])
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)
old
řetězcem new
>>> s='ahoj nazdar cau'
>>> s.replace('naz','NE')
'ahoj NEdar cau'
`--> stáhnout
.decode(codepage)
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)
.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)
{...}
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
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é:
Můžeme zjistit jejich délku pomocí funkce len()
:
>>> s='ahoj Karliku'
>>> len(s)
--> 12
`--> stáhnout
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
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
.
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
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
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
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
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
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
== |
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
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
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
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ě.
int()
float()
bool()
comlex()
str()
tuple()
list()
set()
ditct()
>>> 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
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
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:
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á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.
Některé z nich už známe, ale je myslím vhodné uvést jejich přehled:
len(i)
x in i
True
pokud je prvek x
v iterovatelném objektu i
.
all(i)
True
pokud se všechny prvky v iterovatelném objektu i
vyhodnotí
jako True
.
any(i)
True
pokud se alespoň jeden prvek v iterovatelném objektu i
vyhodnotí jako True
.
max(i[,f])
, min(i[,f])
key=f
, která se provede s každým prvkem před zahájením porovnávání.
sum(i[,start])
i
.
reversed(i)
i
.
sorted(i)
i
. Má několik volitelných
parametrů, pomocí kterých lze řazení
řídit.
range(start[,stop[,krok]])
list
(v Pythonu3 iterátor) podle hranic start
, stop
s krokem krok
.
Prametry stop
a krok
jsou volitelné.
enumerate(i)
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)
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
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.
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
# absolutní hodnota
x = a if a>0 else -a
`--> stáhnout
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.
if cislo<0 :
cislo = -cislo
`--> stáhnout
if cislo>0 :
x = cislo
else:
x = - cislo
`--> stáhnout
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
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.
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
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
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
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
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
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é 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 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.
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
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
U těchto témat se spolehnu na to co napsaly jiní:
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 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
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
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
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