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ář.'
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 ">>
> ".
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.
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
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'
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.
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í:
a
a b
jsou zároveň přiřazeny dvě nové hodnoty 0 a 1. Na poslední řádce
je tento obrat použit znovu, zároveň ukazuje, že výrazy na pravé straně jsou
vyhodnoceny před samotným přiřazením. Výrazy na pravé straně přiřazení jsou
vyhodnocovány zleva do prava.
b < 10
) zůstává pravdivá.
V Pythonu, podobně jako v C, jakékoli nenulové číslo znamená pravdu, nula
nepravdu. Podmínkou může být i řetězec nebo seznam, vlastně libovolná sekvence -
cokoli s nenulovou délkou je pravda, prázdná sekvence je nepravda. Test
použitý v tomto příkladě je ukázkou jednoduchého porovnání. Standardní
porovnávací operátory jsou schodné s jazykem C: <
(menší než), >
(větší než), ==
(rovno), <=
(menší nebo rovno), >=
(větší nebo rovno) a !=
(nerovno).
>>> i = 256*256 >>> print 'Hodnota proměnné i je', i Hodnota proměnné i je 65536
Ukončující čárka zamezí vložení znaku nového řádku za výstup:
>>> a, b = 0, 1 >>> while b < 1000: ... print b, ... a, b = b, a+b ... 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
Interpretr však vloží znak nového řádku před vytisknutím další výzvy, jestliže předchozí řádek nebyl ukončen.