Subsections

 
3. Úvod do jazyka Python

V následujících príkladech je vstup a výstup z/do programu rozlišen uvedením/neuvedením výzvy (">>" a "... "). Chcete-li si vyzkoušet libovolný příklad, musíte napsat vše následující po výzvě. Řádky, které nezačínají výzvou, jsou výstupem programu.

Sekundární výzva uvedená v příkladech na samostatném řádku znamená prázdný řádek, a je použita k ukončení víceřádkového příkazu.

Mnoho příkladů v tomto manuálu, i když jsou určeny pro zápis v interaktivním módu, obsahuje komentáře. Komentáře v Pythonu začínají znakem křížek "#" a pokračují do konce fyzického řádku. Komentář se může objevit jak na začátku řádky, tak může následovat po "bílých znacích" nebo kódu, ale nemůže se objevit uvnitř řetězce. Znak křížek uvnitř řetězce je jako každý jiný znak součástí tohoto řetězce.

Například:

# toto je první komentar
SPAM = 1                 # a toto je druhý komentář
                         # ... a nyní třetí!
STRING = '# Toto není komentář.'

 
3.1 Python jako kalkulátor

Nyní si vyzkoušíme několik jednoduchých příkazů jazyka Python. Spusťte si interpretr a vyčkejte, dokud se neobjeví primární výzva ">>".

 
3.1.1 Čísla

Interpretr se chová jako jednoduchý kalkulátor, můžete zapsat libovolný výraz a on vypíše jeho hodnotu. Zápis výrazů je jednoduchý: operátory +, -, * a / většinou fungují jako v jiných jazycích (například Pascal nebo C), rovněž můžete používat závorky pro změnu priority výrazů. Například:

>>> 2+2
4
>>> # Toto je komentář
... 2+2
4
>>> 2+2  # a toto je kometář na stejném řádku jako kód
4
>>> (50-5*6)/4
5
>>> # Dělení celých čísel vratí celé číslo:
... 7/3
2
>>> 7/-3
-3

Stejně jako v C je znak rovnítko ("=") určen pro přiřazení hodnoty proměnné. Hodnota proměnné po přiřazení již není interaktivním intepretrem vypsána:

>>> vyska = 20
>>> sirka = 5*9
>>> vyska * sirka
900

Hodnota může být přiřazena i více proměnným najednou:

>>> x = y = z = 0  # Vynuluj x, y a z
>>> x
0
>>> y
0
>>> z
0

Python plně podporuje operace v plovoucí řádové čárce, operátory s různými typy operandů zkonvertují nejprve celá čísla na čísla v plovoucí řádové čárce:

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

Jazyk má také zahrnutu podporu pro komplexní čísla, imaginární čísla jsou psána s příponou "j" nebo "J". Komplexní čísla s nenulovou reálnou částí jsou psána jako "(real+imagj)" nebo mohou být vytvořena pomocí funkce "complex(real, imag)".

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

Komplexní čísla jsou vždy reprezentována dvojicí desetinných čísel, reálnou a imaginární částí. Pro získání těchto částí z komplexního čísla z použijeme zápisu z.real a z.imag.

>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5

Konverzní funkce pro desetinná a celá čísla (float(), int() a long()) nepracují s komplexními čísly -- v matematice neexistuje způsob jak převést komplexní číslo na reálné. Použijte raději abs(z) pro získání jeho absolutní hodnoty (desetinné číslo) nebo z.real pro získání reálné části.

>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use e.g. abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2 + a.imag**2)
5.0
>>>

V interaktivním módu je poslední vytisknutý výraz přiřazen proměnné _. To znamené, že pokud používáte Python jako stolní kalkulátor, pak je velice snadné se vrátit k předchozímu výsledku, například:

>>> urok = 12.5 / 100
>>> penize = 100.50
>>> penize * urok
12.5625
>>> penize + _
113.0625
>>> round(_, 2)
113.06
>>>

Tato proměnné by měla být uživatelem považována za proměnnou určenou pouze pro čtení. Nikdy explicitně nepřiřazujte této proměnné nějakou hodnotu -- vytvořili byste nezávislou lokální proměnnou, která by zakryla interní proměnnou s tímto chováním.

 
3.1.2 Řetězce

Spolu s čísly dokáže Python také pracovat s řetězci, které mohou být zapsány mnoha způsoby. Jednak mohou být uzavřeny buď jednoduchými nebo dvojitými uvozovkami:

>>> 'houby s octem'
'houby s octem'
>>> 'rock\'n\'roll'
"rock'n'roll"
>>> "rock'n'roll"
"rock'n'roll"
>>> '"To je vražda," napsala.'
'"To je vražda," napsala.'
>>> "\"To je vražda,\" napsala."
'"To je vražda," napsala.'
>>> '"To je rock\'n\'roll," řekla.'
'"To je rock\'n\'roll," řekla.'

Řetězce také mohou být rozloženy přes více řádků. Dosáhnout toho lze opět několika způsoby. Spojení dvou po sobě jdoucích řádků se docílí ukončením řádku znakem zpětného lomítka, který způsobí pokračování na dalším řádku:

hello = 'Toto je dlouhý řetězec obsahující mnoho\n\
řádek textu, stejně jej zapisujete i v C.\n\
    "Bílé" znaky na začátku řádku se samozřejmě\
 berou v úvahu.'

print hello

Každý řádek řetězce je ale nutné ukončit vložením znaků \n, znak nového řádku následující po zpětném lomítku je ignorován. Tento příklad vypíše následující:

Toto je dlouhý řetězec obsahující mnoho
řádek textu, stejně jej zapisujete i v C.
    "Bílé" znaky na začátku řádku se samozřejmě berou v úvahu.

Jestliže vytvoříme 'raw' řetězec, pak není posloupnost znaků \n převedena na znaky nového řádku, ale zpětná lomítka a znaky nového řádku jsou obsaženy v řetězci jako data. Třeba příklad:

hello = r'Toto je dlouhý řetězec obsahující mnoho\n\
řádek textu, stejně jej zapisujete i v C.'

print hello

vytiskne:

Toto je dlouhý řetězec obsahující mnoho\n\
řádek textu, stejně jej zapisujete i v C.

Stejně tak můžeme řetězec uzavřít mezi odpovídající pár trojitých uvozovek """ nebo '''. V tomto případě není třeba uvozovat konce řádků, ty budou obsaženy ve výsledném řetězci přesně tak, jak jsou.

print """
Použití: nakladač [VOLBY] 
     -h                        Zobraz tuto zprávu
     -H hostname               Připoj se na tento počítač
"""

Tento příklad vytiskne následující výstup:

Použití: nakladač [VOLBY]
     -h                        Zobraz tuto zprávu
     -H hostname               Připoj se na tento počítač

Interpretr vytiskne výsledek operace s řetězci stejným způsobem, jako je zapisujete v jednotlivých příkazech - uvnitř uvozovek a všechny speciální znaky jsou uvezeny zpětným lomítkem - pro zobrazení jejich přesné hodnoty. Řetězec je uzavřen ve dvojitých uvozovkách jestliže řetězec obsahuje jednoduché uvozovky (apostrofy) nebo je bez uvozovek, jinak je uzavřen v jednoduchých uvozovkách (Příkaz print, popsaný později, může být použit pro zobrazení řetězců bez uvozovek a jiných uvození).

Řetězce mohou být spojeny pomocí operátoru + a opakovány operátorem *:

>>> slovo = 'Help' + 'A'
>>> slovo
'HelpA'
>>> '<' + slovo*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'

Dva zápisy řetězců za sebou jsou spojeny dohromady, první řádek předchozího příkladu mohl být zapsán rovněž jako "slovo = 'Help' 'A'", toto ale funguje jen se zápisem řetězců - nelze spojovat řetězec a výraz:

>>> import string
>>> 'str' 'ing'                   #  <-  Správně
'string'
>>> string.strip('str') + 'ing'   #  <-  Správně
'string'
>>> string.strip('str') 'ing'     #  <-  CHYBNĚ!!!
  File "<stdin>", line 1, in ?
    string.strip('str') 'ing'
                            ^
SyntaxError: invalid syntax

Řetězce mohou být, podobně jako v C, indexovány - první znak řetězce má vždy index 0. V Pythonu není nějaký zvláštní znakový typ - jeden znak je jednoduše řetězec o délce 1. Podřetězce mohou být, podobně jako v jazyce Icon, specifikovány pomocí indexování subsekvencí (slice) -- dvěma indexy oddělenými dvojtečkou:

>>> slovo[4]
'A'
>>> slovo[0:2]
'He'
>>> slovo[2:4]
'lp'

Narozdíl od C ale nemohou být řetězce v Pythonu změněny. Přiřazení řetězce na určitou pozici vyústí v chybu:

>>> slovo[0] = 'x'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> slovo[:1] = 'Splat'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object doesn't support slice assignment

Nicméně, vytváření nových řetězců kombinováním jiných je jednoduché a efektivní:

>>> 'x' + slovo[1:]
'xelpA'
>>> 'Splat' + slovo[4]
'SplatA'

Slice indexy mají své implicitní hodnoty: vynechaný první index znamená nulu, vynechaný druhý index je nahrazen délkou řetězce před jeho "rozřezáním" 3.1.

>>> slovo[:2]    # První dva znaky
'He'
>>> slovo[2:]    # Vše s výjimkou prvních dvou znaků
'lpA'

Kód s[:i] + s[i:] je vyhodnocen jako s:

>>> slovo[:2] + slovo[2:]
'HelpA'
>>> slovo[:3] + slovo[3:]
'HelpA'

Je-li index použitý ve slice konstrukci příliš velký, je nahrazen délkou řetězce. Je-li horní index větší než dolní, výsledný podřetězec je prázdný řetězec.

>>> slovo[1:100]
'elpA'
>>> slovo[10:]
''
>>> slovo[2:1]
''

Indexy menší než nula značí počítání z opačného konce řetězce. Například:

>>> slovo[-1]     # Poslední znak
'A'
>>> slovo[-2]     # Předposlední znak
'p'
>>> slovo[-2:]    # Poslední dva znaky
'pA'
>>> slovo[:-2]    # Vše kromě posledních dvou znaků
'Hel'

Je třeba ale dát pozor, -0 je totéž co 0 a k žádnému počítání zprava nedojde!

>>> slovo[-0]     # (-0 je totéž co 0)
'H'

Záporné indexy při indexování podřetězců jsou poopraveny a není chybou, sahá-li rozsah indexů mimo řetězec. Indexy vystupující samostatně ale upraveny nejsou:

>>> slovo[-100:]
'HelpA'
>>> slovo[-10]    # CHYBNĚ!!!
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
IndexError: string index out of range

Nejlepší cesta, jak si zapamatovat jak slice pracují, je myslet na to, že indexy ve slice ukazují mezi znaky, kde levá hrana prvního znaku má číslo 0. Pravá hrana posledního znaku řetězce o n znacích má index n, například:

 +---+---+---+---+---+ 
 | H | e | l | p | A |
 +---+---+---+---+---+ 
 0   1   2   3   4   5 
-5  -4  -3  -2  -1

První řádek ukazuje pozice slice-indexů 0...5 v řetězci 'HelpA', druhý pak odpovídající záporné hodnoty. Řez od i do j sestává ze všech znaků mezi hranami označenými i, respektive j.

Pro nezáporné slice-indexy je délka řezu rozdílem slice-indexů pokud oba padnou dovnitř řetězce. Například, délka řezu word[1:3] je 2.

Interní funkce len() vrací délku řetězce:

>>> s = 'supercalifragilisticexpialidociální'
>>> len(s)
35

 
3.1.3 Řetězce Unicode

Vydáním Pythonu 2.0 se jazyk dostal mezi skupinku jazyků podporujících Unicode. Od té doby Python umí pracovat s Unicode řetězci (viz http://www.unicode.org/) úplně stejným způsobem jako s obyčejnými řetězci a umožňuje integraci s exitujícími ne-Unicode řetězci díky konverzním funkcím, které jsou automaticky volány.

Unicode je pokrokové v tom, že každému znaku, jenž se vyskytuje v novém globálním vícejazyčném světě, přiřazuje jedinečný index. Dříve bylo pouze 256 možných indexů (a tudíž pouze 256 různých znaků), které byly použity pro znaky skriptu a texty byly typicky svázány s kódovou stránkou, ve které byly vytvořeny. To vedlo k velkým zmatkům, protože bylo nutné respektovat internacionalizaci (anglicky internationalization, často psáno jako "i18n" -- "i" + 18 znaků + "n") programů, tj. proces, který má zajistit, že program bude schopen pracovat v různých národních prostředích a že bude akceptovat národní znaky apod. Unicode vyřešilo tento problém definováním jediné kódové stránky pro všechny skripty ve všech možných jazycích.

Vytváření Unicode řetězců v Pythonu je stejně jednoduché jako vytváření normálních řetězců:

>>> u'Hello World !'
u'Hello World !'

Malé písmeno "u" před řetězcem indikuje, že se jedná o Unicode řetězec. Jak vidíme, Unicode řetězec byl bez problémů vytvořem. Chcete-li do řetězce vložit speciální řetězec, můžete tak učinit použitím Unicode-Escape módu. Následující příklad ukazuje jak:

>>> u'Hello\u0020World !'
u'Hello World !'

Escape sekvence \u0020 znamená vložení Unicode znaku s hodnotou 0x0020 (znak mezera) na danou pozici.

Ostatní znaky jsou interpretovány použitím jejich odpovídajících hodnot v kódové stránce Unicode. Máte-li řetězce zapsané pomocí kódování Latin-1, které je standardem v zemích západní Evropy, jistě jste si všimli, že prvních 256 znaků Unicode přesně odpovídá všem 256 znakům Latin-1.

Pro pokročilejší: Python rovněž nabízí raw mód zápisu Unicode řetězců, který má obdobnou funkci jako raw mód obyčejných řetězců - zapsáním znaků 'ur' před otevírající uvozovku řetězce začne pro tento řetězec Python používat Raw-Unicode-Escape mód. V tomto módu Python nahrazuje pouze sekvence \uXXXX a ostatní (třeba \n) nechává tak jak jsou.

>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'

Raw mód je užitečný pokud chcete zapsat množství zpětných lomítek, což je typický požadavek při zápisu regulérních výrazů.

Nehledě na tyto standardní módy nabízí Python celou řadu jiných způsobů jak vytvořit Unicode řetězec.

Interní funkce unicode() umožňuje přístup ke všem registrovaným kodekům. Tyto kodeky dokáží konvertovat množství kódování, např. Latin-1, ASCII, UTF-8 nebo UTF-16. Implicitní kódování je normálně ASCII, které používá znaky v rozsahu 0 až 127 a při výskutu ostatních vyvolá chybu. Při tisku Unicode řetězce, jeho zápisu do souboru nebo konverzi funkcí str(), proběhne konverze právě za použití implicitního kódování.

>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
UnicodeError: ASCII encoding error: ordinal not in range(128)

Pro převod Unicode řetězce na 8bitový řetězec za použití specifikovaného kódování definuje každý Unicode objekt metodu encode(), které přejímá jediný argument - jméno kódování (jména kódování je doporučováno psát malými písmeny).

>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'

Máte-li data v určitém kódování a chcete je převést na odpovídající Unicode řetězec, můžete funkci unicode() předat jméno kódování jako druhý argument.

>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'

 
3.1.4 Seznamy

Python podporuje množství složených datových typů určených k uložení jiných hodnot. Nejuniverzálnější je seznam, který může být zapsán jako výčet hodnot (prvků) oddělených čárkou a uzavřený mezi hranatými závorkami. Seznam nevyžaduje, aby všechny jeho prvky měly stejný typ.

>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]

Seznamy mohou být, podobně jako řetězce, indexovány (indexy začínají 0) a také mohou být děleny konstrukcemi slice, spojovány atd.:

>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boe!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']

Narozdíl od řetězců, které jsou neměnné, je možné u seznamu měnit jeho jednotlivé prvky:

>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]

Rovněž lze přiřadit hodnotu určité subsekvenci. Takto je můžeme změnit i velikost seznamu:

>>> # Změna prvků:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Jejich odstranění:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Vložení nových:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a     # Vložení kopie seznamu do sebe sama
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]

Interní funkci len() můžeme také použít na seznamy. Obdržíme pak počet prvků obsažených v seznamu:

>>> len(a)
8

Rovněž je možné vytvořit seznam obsahující jiné seznamy, například:

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra')     # Viz. sekce 5.1
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

Věřte, že v posledním příkladě objekty p[1] a q opravdu ukazují na jeden a ten samý objekt. Později se k odkazům na objekty ještě vrátíme.

 
3.2 První kroky

Python samozřejmě můžeme použít ke komplikovanějším úlohám. Například můžeme vypsat počáteční prvky Fibonacciho rozvoje3.2:

>>> # Fibonacci rozvoj:
... a, b = 0, 1
>>> while b < 10:
...       print b
...       a, b = b, a+b
... 
1
1
2
3
5
8

Tento příklad ukazuje několik pro nás nových vlastností:



Footnotes

... "rozřezáním"3.1
Ve skutečnosti je nahrazen velikostí proměnné sys.maxint určující maximální velikost celého čísla na dané platformě.
... rozvoje3.2
Fibonacciho rozvoj má tu vlastnost, že n+2 prvek je roven součtu prvků n a n+1. Začíná čísly 1, 1, 2, 3, 5, 8, 13 atd.
See About this document... for information on suggesting changes.