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. |