3. Neformální úvod do Pythonu

V následujících příkladech se vstup a výstup rozlišují přítomností či nepřítomností výzev (>>> a …): chcete-li příklad zopakovat, musíte napsat vše, co následuje za zobrazenou výzvou; řádky, které výzvou nezačínají, jsou výstupem interpretu. Sekundární výzva na samostatném řádku v příkladu znamená, že musíte zadat prázdný řádek; tím se ukončuje víceřádkový příkaz.

Ke zkopírování a vložení vstupních řádků do interpretu můžete použít tlačítko „Copy“ (zobrazí se v pravém horním rohu při najetí ukazatelem nebo klepnutí na ukázku kódu), které odstraní výzvy a vynechá výstup.

Mnohé příklady v této příručce, včetně těch zadávaných na interaktivní výzvě, obsahují komentáře. Komentář v Pythonu začíná znakem mřížky # a pokračuje do konce fyzického řádku. Může se nacházet na začátku řádku nebo za prázdnými znaky či kódem, nikoli však uvnitř řetězcového literálu. Znak mřížky uvnitř řetězcového literálu je prostě znakem mřížky. Protože komentáře slouží k objasnění kódu a Python je neinterpretuje, můžete je při zadávání příkladů vynechat.

Několik příkladů:

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

3.1. Použití Pythonu jako kalkulačky

Vyzkoušejme několik jednoduchých příkazů Pythonu. Spusťte interpret a počkejte na primární výzvu >>>. (Nemělo by to trvat dlouho.)

3.1.1. Čísla

Interpret funguje jako jednoduchá kalkulačka: můžete do něj zadat výraz a on vypíše jeho hodnotu. Syntaxe výrazů je přímočará: operátory +, -, * a / lze použít k aritmetickým operacím a závorky (()) k seskupování. Například:

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating-point number
1.6

Celá čísla (například 2, 4 a 20) jsou typu int, zatímco čísla s desetinnou částí (například 5.0 a 1.6) jsou typu float. O číselných typech se více dozvíme později v tutorialu.

Dělení (/) vždy vrací číslo s plovoucí desetinnou čárkou. Pro celočíselné dělení s celočíselným výsledkem můžete použít operátor //; zbytek po dělení vypočítáte pomocí %:

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # floored quotient * divisor + remainder
17

V Pythonu lze k výpočtu mocnin použít operátor ** [1]:

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

Rovnítko (=) slouží k přiřazení hodnoty proměnné. Po přiřazení se před další interaktivní výzvou nezobrazí žádný výsledek:

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

Není-li proměnná „definovaná“ (nemá přiřazenou hodnotu), pokus o její použití vyvolá chybu:

>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Operace s plovoucí desetinnou čárkou jsou plně podporované; operátory s operandy smíšených typů převedou celočíselný operand na číslo s plovoucí desetinnou čárkou:

>>> 4 * 3.75 - 1
14.0

V interaktivním režimu se naposledy vypsaný výraz přiřadí proměnné _. Při používání Pythonu jako stolní kalkulačky tak lze ve výpočtech o něco snáze pokračovat, například:

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

Uživatel by měl tuto proměnnou považovat za určenou pouze pro čtení. Nepřiřazujte jí hodnotu explicitně — vytvořili byste nezávislou lokální proměnnou stejného jména, která by zastínila vestavěnou proměnnou s jejím zvláštním chováním.

Kromě typů int a float podporuje Python také další číselné typy, například Decimal a Fraction. Python má rovněž vestavěnou podporu komplexních čísel a jejich imaginární část označuje příponou j nebo J (například 3+5j).

3.1.2. Text

Python dokáže kromě čísel pracovat také s textem (reprezentovaným typem str, takzvanými „řetězci“). Patří sem znaky „!“, slova „rabbit“, názvy „Paris“, věty „Got your back.“ a podobně. „Yay! :)“. Lze je uzavřít do jednoduchých ('...') nebo dvojitých uvozovek ("...") se stejným výsledkem [2].

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"  # double quotes
'Paris rabbit got your back :)! Yay!'
>>> '1975'  # digits and numerals enclosed in quotes are also strings
'1975'

Chceme-li uvozovku uvést jako součást řetězce, musíme ji „escapovat“ přidáním \ před ni. Případně můžeme použít druhý typ uvozovek:

>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

V shellu Pythonu může definice řetězce vypadat jinak než jeho výstupní podoba. Funkce print() vytváří čitelnější výstup: vynechá vnější uvozovky a interpretuje escapované a speciální znaky:

>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), special characters are included in the string
'First line.\nSecond line.'
>>> print(s)  # with print(), special characters are interpreted, so \n produces new line
First line.
Second line.

Nechcete-li, aby se znaky uvedené znakem \ interpretovaly jako speciální, můžete použít surové řetězce (raw strings) přidáním r před první uvozovku:

>>> print('C:\this\name')  # here \t means tab, \n means newline
C:      his
ame
>>> print(r'C:\this\name')  # note the r before the quote
C:\this\name

Surové řetězce mají jednu záludnost: nesmějí končit lichým počtem znaků \. Další informace a možnosti řešení najdete v příslušné položce FAQ.

Řetězcové literály mohou zabírat více řádků. Jednou z možností jsou trojité uvozovky: """...""" nebo '''...'''. Znaky konce řádku se do řetězce zahrnou automaticky, tomu však lze zabránit přidáním \ na konec řádku. V následujícím příkladu není úvodní znak nového řádku zahrnut:

>>> print("""\
... Usage: thingy [OPTIONS]
...      -h                        Display this usage message
...      -H hostname               Hostname to connect to
... """)
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

>>>

Řetězce lze zřetězit (spojit) operátorem + a opakovat operátorem *:

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

Dva nebo více řetězcových literálů (tedy řetězců uzavřených v uvozovkách) uvedených vedle sebe se automaticky zřetězí.

>>> 'Py' 'thon'
'Python'

Tato vlastnost je užitečná zejména při rozdělování dlouhých řetězců:

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

Funguje to však pouze pro literály, nikoli pro proměnné nebo výrazy:

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  File "<stdin>", line 1
    prefix 'thon'
           ^^^^^^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  File "<stdin>", line 1
    ('un' * 3) 'ium'
               ^^^^^
SyntaxError: invalid syntax

Chcete-li zřetězit proměnné nebo proměnnou a literál, použijte +:

>>> prefix + 'thon'
'Python'

Řetězce lze indexovat (přistupovat k nim pomocí indexu), přičemž první znak má index 0. Samostatný znakový typ neexistuje; znak je jednoduše řetězec délky jedna:

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

Indexy mohou být také záporná čísla; v takovém případě se počítá zprava:

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

Protože -0 je totéž co 0, záporné indexy začínají hodnotou -1.

Kromě indexování jsou podporovány také výřezy (slicing). Indexování slouží k získání jednotlivých znaků, zatímco výřez umožňuje získat podřetězec:

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

Indexy výřezu mají užitečné výchozí hodnoty: vynechaný první index má hodnotu nula a vynechaný druhý index má hodnotu délky řetězce, z něhož se výřez vytváří.

>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'on'

Všimněte si, že začátek je vždy zahrnut, zatímco konec nikoli. Díky tomu se s[:i] + s[i:] vždy rovná s:

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

Fungování výřezů si lze zapamatovat tak, že indexy ukazují mezi znaky a levý okraj prvního znaku má číslo 0. Pravý okraj posledního znaku řetězce o n znacích má potom index n, například:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

První řada čísel udává pozici indexů 0…6 v řetězci, druhá řada odpovídající záporné indexy. Výřez od i do j tvoří všechny znaky mezi okraji označenými i a j.

Pokud jsou oba nezáporné indexy v platném rozsahu, délka výřezu se rovná jejich rozdílu. Například délka word[1:3] je 2.

Pokus o použití příliš velkého indexu skončí chybou:

>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Indexy mimo rozsah se však při vytváření výřezů zpracují bez chyby:

>>> word[4:42]
'on'
>>> word[42:]
''

Řetězce Pythonu nelze měnit — jsou neměnné. Přiřazení na indexovanou pozici v řetězci proto skončí chybou:

>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Potřebujete-li jiný řetězec, vytvořte nový:

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

Vestavěná funkce len() vrací délku řetězce:

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

Viz také

Text Sequence Type — str

Řetězce jsou příkladem sekvenčních typů a podporují operace společné těmto typům.

String Methods

Řetězce podporují mnoho metod pro základní transformace a vyhledávání.

f-strings

Řetězcové literály s vloženými výrazy.

Format string syntax

Informace o formátování řetězců pomocí str.format().

printf-style String Formatting

Podrobnější popis starých formátovacích operací, které se vyvolají, když je řetězec levým operandem operátoru %.

3.1.3. Seznamy

Python zná několik složených datových typů, které slouží k seskupování jiných hodnot. Nejuniverzálnějším z nich je seznam, zapisovaný jako hodnoty (prvky) oddělené čárkami a uzavřené v hranatých závorkách. Seznamy mohou obsahovat prvky různých typů, obvykle však mají všechny prvky stejný typ.

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

Stejně jako řetězce (a všechny ostatní vestavěné sekvenční typy) lze seznamy indexovat a vytvářet z nich výřezy:

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

Seznamy podporují také operace, jako je zřetězení:

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Na rozdíl od řetězců, které jsou neměnné, jsou seznamy měnitelným typem, takže jejich obsah lze změnit:

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

Nové prvky můžete na konec seznamu přidávat také pomocí metody list.append() (o metodách se více dozvíme později):

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

Prosté přiřazení v Pythonu data nikdy nekopíruje. Přiřadíte-li seznam proměnné, proměnná odkazuje na existující seznam. Jakékoli změny provedené v seznamu prostřednictvím jedné proměnné budou viditelné přes všechny ostatní proměnné, které na něj odkazují.:

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba)  # they reference the same object
True
>>> rgba.append("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]

Všechny operace s výřezy vracejí nový seznam obsahující požadované prvky. Následující výřez tedy vrátí mělkou kopii seznamu:

>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
>>> rgba
["Red", "Green", "Blue", "Alph"]

Do výřezů lze rovněž přiřazovat, čímž lze dokonce změnit velikost seznamu nebo jej zcela vyprázdnit:

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

Vestavěnou funkci len() lze použít také na seznamy:

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

Seznamy lze vnořovat (vytvářet seznamy obsahující jiné seznamy), například:

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2. První kroky k programování

Python samozřejmě můžeme použít ke složitějším úlohám, než je sčítání dvou a dvou. Počáteční část Fibonacciho posloupnosti můžeme například zapsat takto:

>>> # Fibonacci series:
>>> # the sum of two elements defines the next
>>> a, b = 0, 1
>>> while a < 10:
...     print(a)
...     a, b = b, a+b
...
0
1
1
2
3
5
8

Tento příklad představuje několik nových vlastností.

  • První řádek obsahuje vícenásobné přiřazení: proměnné a a b současně získají nové hodnoty 0 a 1. Na posledním řádku se tento postup použije znovu a ukazuje, že před provedením kteréhokoli přiřazení se nejprve vyhodnotí všechny výrazy na pravé straně. Výrazy na pravé straně se vyhodnocují zleva doprava.

  • Cyklus while se provádí, dokud je podmínka (zde a < 10) pravdivá. Stejně jako v C je v Pythonu každá nenulová celočíselná hodnota pravdivá a nula nepravdivá. Podmínkou může být také řetězec, seznam, či dokonce libovolná sekvence; vše s nenulovou délkou je pravdivé, prázdné sekvence jsou nepravdivé. Test použitý v příkladu je jednoduché porovnání. Standardní porovnávací operátory se zapisují stejně jako v C: < (menší než), > (větší než), == (rovná se), <= (menší nebo rovno), >= (větší nebo rovno) a != (nerovná se).

  • Tělo cyklu je odsazené: odsazení je v Pythonu způsobem seskupování příkazů. Na interaktivní výzvě musíte u každého odsazeného řádku zadat tabulátor nebo jednu či více mezer. Složitější vstupy pro Python budete v praxi připravovat v textovém editoru; všechny kvalitní textové editory nabízejí automatické odsazování. Po interaktivním zadání složeného příkazu musí následovat prázdný řádek označující jeho dokončení (syntaktický analyzátor nedokáže odhadnout, kdy jste zadali poslední řádek). Každý řádek v základním bloku musí být odsazen o stejnou úroveň.

  • Funkce print() vypíše hodnoty předaných argumentů. Od prostého zadání výrazu, jehož hodnotu chcete vypsat (jako v předchozích příkladech s kalkulačkou), se liší způsobem zpracování více argumentů, hodnot s plovoucí desetinnou čárkou a řetězců. Řetězce se vypisují bez uvozovek a mezi prvky se vkládá mezera, takže lze výstup pěkně formátovat, například:

    >>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536

    Pomocí argumentu klíčového slova end lze zabránit vložení nového řádku za výstup nebo výstup ukončit jiným řetězcem:

    >>> a, b = 0, 1
>>> while a < 1000:
...     print(a, end=',')
...     a, b = b, a+b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Poznámky pod čarou