and del for is raise
assert elif from lambda return
break else global not try
class except if or while
continue exec import pass yield
def finally in print
| Popis |
|---|
| "řetězec uvnitř dvojitých uvozovek" |
| 'jiný řetězec unvitř jednoduchých uvozovek s " uvnitř' |
| '''řetězec uvnitř trojitých uvozovek, může obsahovat Enter i " ''' |
| """ také možno použít 3 dvojité uvozovky """ |
| u'unicode řetězec' - čeština v řetězcích;
pro správnou fungování je nutné: 1) deklarovat kódování na 1. řádce
programu (třebas # -*- coding: cp1250 -*- ) a 2) uložit v tom samém
kódování (záležitost vašeho editoru). |
| r'surový řetězec, používá se u windowsovských cest, které obsahují \' |
| Escape sekvence | Význam |
|---|---|
| \n | Enter |
| \a | Zvonek |
| \r | Návrat vozíku |
| \t | Tabulátor |
str) délky 0, 1, 2 (viz výše)tuple) délky 0, 1, 2,
atd:list) délky 0, 1, 2, atd:dict) délky 0, 1, 2, apod.: {} ,
{1 : 'prvni'}, {1 : 'prvni', 'dalsi': 'druhy'}| Operace | Výsledek |
|---|---|
| x + y | součet x a y |
| x - y | rozdíl x a y |
| x * y | součin x a y |
| x / y | dělení x a y. Podíl dvou celých čísel je v Pythonu celé číslo
(stejně jako ve 4. třídě ;-)): 5/3=1. Pokud chceme desetinný výsledek,
musí být jedno z čísel desetinné : 5.0/3 = 1.66666; případně
float(5)/3=1.6666 |
| x % y | zbytek po dělení čísel x a y : 5%3=2 (jako doplněk
předchozího) |
| x ** y | mocnina: x na y |
| abs(x) | absolutní hodnota x |
| int(x) | převod x na celé číslo |
| float(x) | převod x na desetinné číslo |
| -x | negace x |
| +x | x nezměněno |
| Operace | Výsledek |
|---|---|
| ~x | invertované bity |
| x ^ y | bitové exkluzivní nebo nad x a yy |
| x & y | bitový součin x a y |
| x | y | bitové nebo x a y |
| x << n | x posunuto doleva o n bitů |
| x >> n | x posunuto doprava o n bitů |
| Operace | Výsledek | Poznámky |
|---|---|---|
| s + t | spojení s a t | |
| s * n, n*s | n kopií s | |
| s[i] | i-tý prvek s, začíná se na 0 | když i je záporné, počítá se od konce. 0 a -0 je
stejné. 1. prvek má index 0! |
| s[i:
j] s[i: j:krok] |
Ukrojení s od i (včetně) do j (vyjma). Nepovinně krok, možno i záporná hodnota (předvoleno: 1). |
Výsledkem bude podposloupnost. Krájení posloupností [zacina-na-indexu : je-mensi-nez-index [ : krok]]. Příklad: a =
(0,1,2,3,4,5,6,7) |
| len(s) | délka s (počet prvků) | |
| min(s) | nejmenší prvek z s | |
| max(s) | největší prvek z s | |
| x in s | Pravda, když x je rovno nějakému prvku z s,
jinak Nepravda |
|
| x not in s | Opak předchozího |
list)| Operace | Výsledek |
|---|---|
| s[i] =x | prvek s indexem i je nahrazen x 1. prvek má index 0! |
| s[i:j [:krok]] = t | část seznamu s od indexu i do j je nahrazena t |
| del s[i:j [:krok]] | smaže prvky od i do j; stejné jako s[i:j] = [] |
| s.append(x) | přiřadí x na konec seznamu; stejné jako s[len(s) : len(s)] = [x] |
| s.extend(x) | přiřadí seznam x na konec seznamu s; stejné jako s[len(s):len(s)]= x |
| s.count(x) | vrací počet prvků, které se rovnají x (s[i] == x) |
| s.index(x [, start[, stop]]) | vrací první index i, kde platí s[i]== x.
start a stop mohou omezit rozsah hledání. |
| s.insert(i, x) | vloží x před index i; stejné jako s[i:i] =
[x] i == -1 vkládá před poslední prvek. |
| s.remove(x) | smaže první x, které najde; stejné jako del s[s.index(x)] |
| s.pop([i]) | smaže a vrátí poslední (i-tý) prvek |
| s.reverse() | otočí na místě seznam. Příklad:chybně:
print s.reverse() # vytiskne None, tedy nic |
| s.sort() | seřadí na místě seznam podle velikosti |
dict)| Operace | Výsledek |
|---|---|
| len(d) | Počet prvků v d |
| dict( **kw) | Vytváří slovník. Pojmenované argumenty kw jako počáteční seznam. |
| d[k] | Hodnota na klíči k |
| d[k] = x | Přiřaď x na d[k] |
| del d[k] | Smaž d[k] z d |
| d.has_key(k) k in d |
Pravda, když klíč k je ve slovníku d, jinak
Nepravda |
| d.items() | Seznam dvojic (klíč, hodnota) ze slovníku d |
| d.keys() | Seznam klíčů slovníku d |
| d1.update(d2) | Aktualizace slovníku d1 slovníkem d2 |
| d.values() | Seznam hodnot slovníku d |
| d.iteritems() | Vrací iterátor přes dvojice (klíč, hodnota). Příklad:for
klic, hodnota in d.iteritems(): |
| d.pop(k[, default]) | Maže klíč k a vrací jeho hodnotu. Pokud není nalezen, vrací default. |
str)| Operace | Výsledek |
|---|---|
| s.count(sub[ ,start[,end]]) | Vrací počet výskytů podřetězce sub v řetězci s. Nepovinný argument starturčuje, odkud se má začít prohledávat. Podobně i end. |
| s.endswith(suffix [,start[,end]]) | Vrací Pravdu, když s končí na suffix,
jinak vrací nepravdu. |
| s.find(sub[ ,start[,end]]) | Vrací první index ze s, kde je nalezen podřetězec sub. Vrací -1, když není nalezen. |
| s.index(sub[ ,start[,end]]) | Jako find(), ale vrací chybu, když sub není nalezen. |
| separator.join(seq) | Vrací spojené řetězce ze seznamu seq, oddělené oddělovačem
separator. např.: ", ".join(['A', 'B', 'C']) ->
"A, B, C" |
| s.lower() | Vrací řetězec převedený na malá písmena. |
| s.replace(old, new[, maxCount =-1]) | Vrací kopii s, kde budou všechny podřetězce old nahrazeny podřetězcem new. Možno zadat maximální počet nahrazeni maxCount. |
| s.split([ separator[, maxsplit]]) | Vrací seznam slov v řetězci s, jako oddělovače slov se použije separator. Možno omezit počet dělení pomocí maxsplit. |
| s.startswith(prefix [, start[, end]]) | Vrací Pravdu, když s začíná na prefix,
jinak vrací Nepravdu. |
| s.strip([znaky]) | Vrací kopii řetězce s, kde budou odstraněny ze začátku a konce znaky. Standardně jsou to tzv. bílá místa, tedy netisknutelné znaky jako mezera, tabulátor, enter,... |
| s.swapcase() | Vrací řetězec, kde místo malých budou velká písmena a naopak. |
| s.upper() | Vrací řetězec převedený na velká písmena. |
file().
| Operace | Výsledek |
|---|---|
| f.close() | Uzavři soubor f. |
| f.read([pocetbytu]) | Přečte celý soubor a vrátí ho jako řetězec. Při zadání pocetbytu čte a vrací jen zadaný počet bytů. |
| f.readline() | Čte a vrací jednu řádku ze souboru f. |
| f.readlines() | Čte až do konce souboru a vrací seznam řádek. |
| for radka in
f: print radka |
Opakovaně čte řádky ze souboru. |
| f.write(str) | Zapíše řetězec do souboru f. |
| f.writelines(seznam) | Zapíše seznam řetězců do souboru f. |
| Příkaz | Výsledek |
|---|---|
| if podmínka: tělo [elif podmínka: tělo]* [else: tělo] |
Obvyklý if/else příkaz. Provede se vždy jen jedno tělo, to první
pravdivé, pak if končí. |
| while podmínka: tělo [else: tělo] |
Obvyklý příkaz while. Tělo else se provede jen
tehdy, pokud dojde k obyčejnému ukončení cyklu, tedy ne pomocí
break. |
| for element in posloupnost
: tělo [else: tělo] |
Procházení posloupností a přiřazování každé položky do proměnné
element. Na vytváření jednoduchých posloupností používejte funkci
range (xrange) . Tělo else se
provede jen tehdy, pokud dojde k obyčejnému ukončení cyklu, tedy ne
pomocí break. |
| break | Okamžitě ukončuje cykly for a while. |
| continue | Okamžitě se posune na další prvek v posloupnosti v cyklech
for a while. |
| return [výsledek] | Návrat z funkcí. |
| Příkaz |
Výsledek |
|---|---|
| try: tělo1 except : tělo2 [else: tělo3] |
Příkazy v těle1 jsou normálně prováděny. Pokud se vyskytne
nějaká chyba, provádění se přerušuje a pokračuje se v except
v těle2. Po provedení části except se pokračuje až za
else. Pokud tělo1 skončí bez chyby, provede ještě
případná část else. |
| try: tělo1 finally: tělo2 |
Příkazy v těle1 jsou normálně prováděny. Pokud nenastane žádná chyba, provede se i tělo2. Pokud chyba nastane, provede se tělo2, ale ihned se znovu-vyvolá původní chyba. |
| raise | Úmyslné vyvolání chyby (předchozí nebo nové) |
| Příkaz |
Výsledek |
|---|---|
| import modul1 [as jmeno1] | Importuje moduly. Pokud je zadáno jmeno1, je modul přejmenován.
Použití: import time |
| from modul import * | Importuje modul přímo do prostoru jmen programu, takže se nemusí před
funkcemi vypisovat jméno modulu. Nebezpečné, možnost konfliktu jmen!
Použití: from time import * |
| global jmeno1 [, jmeno2] | Jména zadaných proměnných se stanou globálními, to znamená že budou
jedinečná a měnitelná ve všech funkcích programu. |
| Funkce | Výsledek |
|---|---|
| abs(x) | Vrací absolutní hodnotu čísla x. |
| chr(i) | Vrací znak, jehož ASCII hodnota je číslo i. |
| cmp(x,y) | Vrací -1,0 nebo +1, pokud x <, == nebo > než y. |
| complex(real[, imag]) | Vytváří komplexní číslo; dá se udělat také pomocí j, např. 1+3j. |
| dict( [posloupnost nebo slovník]) | Vrací nový slovník. Možnost zadat počáteční stav jako argument.
Příklad:
|
| dir([objekt]) | Bez argumentu vrací seznam jmen lokálního prostoru jmen. S argumentem (modul, třída, instance,...) vrací seznam jmen v jeho slovníku. |
| divmod(a,b) | Vrací dvojici (a/b, a%b) |
| enumerate(iterable) | Iterátor vracící dvojici (index, hodnota) z iterable. |
| eval(s[, globals[, locals]]) | Vyhodnotí (vykoná) řetězec s. Volitelně možno
provádět v kontextu globals, locals. Příklad: x = 1 |
| execfile(file[, globals[,locals]]) | Spustí program. |
| file(filename [, mode='r']) | Vrací objekt souboru.
|
| float(x) | Převádí celé číslo nebo řetězec na desetinné číslo. |
| help([object]) | Vyvolává vestavěnou nápovědu. |
| input([prompt]) | Čeká na vstup čísla od uživatele. Možno zadat výzvu (prompt). |
| int(x) | Převádí číslo nebo řetězec na celé číslo. |
| len(objekt) | Vrací délku (počet prvků) objektu (seznam, slovník, ....). |
| list(posloupnost) | Převádí posloupnost na seznam. |
| max(posloupnost[, args...]) | Při jednom argumentu (posloupnost) vrací největší prvek z posloupnosti. Při více argumentech vrací největší z argumentů. |
| min(seq[, args...]) | Při jednom argumentu (posloupnost) vrací nejmenší prvek z posloupnosti. Při více argumentech vrací nejmenší z argumentů. |
| ord(c) | Vrací ASCII hodnotu c (řetězec délky 1). |
| pow(x, y [, z]) | Vrací mocninu x**y (modulo z). |
| range(start [,end [, krok]]) | Vrací seznam čísel od start
(včetně) do end
(mimo).range(10): # od 0 do 9 (10 tam
nepatří)range(2,8): # 2,3,4,5,6,7 (8 tam
nepatří) |
| raw_input([prompt]) | Čeká na řetězec od uživatele. Možno zadat výzvu (prompt). Viz také input(). |
| round(x, n=0) | Vrací číslo zaokrouhlené na n desetinných míst. |
| str(object) | Převádí cokoliv na řetězec. |
| sum(posloupnost) | Vrací součet posloupnosti čísel. |
| tuple([posloupnost]) | Vytváří n-tici se stejnými prvky, jako má posloupnost. |
| type(objekt) | Vrací typ objektu. |
| xrange(start [, end [, krok]]) | Jako range(), ale nevrací celý seznam najednou, ale jako iterátor čísel. Vhodné pro velká čísla a málo paměti. |
| zip(posl1[, posl2,...]) | Vrací seznam n-tic, kde každá n-tice obsahuje i-tý prvek z každé posloupnosti. |