Programovací jazyk Python

Python je v současnosti nejoblíbenější programovací jazyk pro výuku programování. Není to však jen výukový jazyk, je také široce prakticky používaný. Na Umíme programovat používáme Python 3.

Pokud s Pythonem začínáte, může se hodit náš přehled základní syntaxe (jeden list A4 k vytištění).

Pokud chcete v Pythonu více programovat, doporučujeme nainstalovat si ho na vlastní počítač. Nicméně na to, abyste se naučili základy programování v Pythonu, vystačíte i s prohlížečem. Na Umíme programovat nabízíme spoustu cvičení a příkladů, které můžete řešit přímo na stránkách:

• Pro úplné začátky zkuste cvičení Rozhodovačka, kde pouze vybíráte z nabízených možností. Jak se trochu rozcvičíte, můžete zkusit Psaná odpověď, kde píšete odpověď na klávesnici.
• Čtení kódu si můžete procvičit ve cvičení Kód kostky, kde je vaším úkolem správně vykonat uvedený program. Další vypracované příklady programů v Pythonu najdete ve cvičení Porozumění. Ke každému příkladu je připravena série kontrolních otázek, pomocí kterých si můžete prověřit, jak programu rozumíte.
• Především si však zkuste samostatné programování. K tomu slouží cvičení Programování v Pythonu a Python želva. Program píšete přímo v prohlížeči, kde si ho můžete i spustit a hlavně automaticky otestovat, zda je správně.

Pro úplné začátečníky doporučujeme jako rozcvičku příklady ze sekce algoritmické myšlení, kde si lze základní koncepty vyzkoušet formou grafického programování.

Práce s proměnnými a výrazy představují základní stavební bloky, ze kterých následně stavíme programy pomocí konstrukcí pro řízení výpočtu.

Základní procvičování v tomto tématu máme rozdělené na tři podtémata:

• Proměnné a číselné výrazy v Pythonu – základní použití proměnných, zápis aritmetických výrazů
• Matematické funkce v Pythonu – použití základních matematických funkcí (např. zaokrouhlování, minimum, absolutní hodnota)
• Logické výrazy v Pythonu – operátory porovnání, logické spojky a jejich použití

Další výrazy pak tvoříme například za využití řetězců a seznamů.

Pro úplné začátečníky v Pythonu může být užitečné si jako rozcvičku projít cvičení na proměnné z oblasti algoritmické myšlení. Tam je možné si procvičit základní principy proměnných bez specifik Pythonu.

Proměnná je jméno, které odkazuje na nějakou hodnotu. Hodnota proměnné se může měnit – ostatně se taky jmenuje „proměnná“.

Názvy proměnných

Názvy proměnných mohou obsahovat písmena, čísla a znak podtržítko. Nesmí obsahovat mezeru a nesmí začínat na číslo. V názvech proměnných se rozlišují velká a malá písmena, tj. number a Number jsou dvě různé proměnné. V Pythonu je zvykem psát jména proměnných malými písmeny. Ve víceslovných názvech proměnných používáme podtržítko, např. list_length. Python 3 umožňuje používat v názvech proměnných i znaky české abecedy. Dobrá praxe však je psát názvy proměnných anglicky. Názvy proměnných volíme popisné.

Příklady:

• korektní názvy proměnných: name, k, max_value
• neplatné názvy proměnných: 2nd_var, actor name, max-value

Vytvoření a aktualizace proměnné

Proměnnou vytvoříme prostě tak, že do ní přiřadíme hodnotu. Hodnotu můžeme následně aktualizovat. Proměnná drží poslední hodnotu, která do ní byla přiřazena. Pro přiřazení používáme rovnítko:

x = 20       # vytvoření proměnné x a přiřazení hodnoty 20

y = 5        # vytvoření proměnné y a přiřazení hodnoty 5

x = 10       # změna hodnoty x na 10

print(x, y)  # vypíše 10 5

Proměnné mohou být různého typu. Python je dynamicky typovaný programovací jazyk. To znamená, že v programu nemusíme uvádět typ proměnné, interpret jazyka jej určí automaticky. Pokud provedeme přiřazení x = 5, proměnná x bude automaticky typu int (celé číslo).

Výpis proměnných a výrazů

Výpis provádíme pomocí funkce print. Ta může mít více parametrů. Pokud chceme vypisovat znaky pro aritmetické operace, musíme je dát do uvozovek či apostrofů. Příklady:

a = 3

b = 8

print(a)           # výstup: 3

print(a, b)        # výstup: 3 8

print(a + b)       # výstup: 11

print(a, "+", b)   # výstup: 3 + 8

Aritmetické operace

S čísly můžeme provádět základní aritmetické operace, zápis je stejný jako na běžných kalkulačkách (+, -, /, *). Python také nabízí podporu pro operace celočíselné dělení (//), dělení se zbytkem (%) a umocňování (**) – tyto operace se při programování často hodí.

x + y      # sčítání

x - y      # odčítání

x * y      # násobení

x / y      # dělení

x // y     # celočíselné dělení

x % y      # dělení se zbytkem

x ** y     # umocňování

V programování nemůžeme vynechávat zápis násobení tak jako v matematice, tj. nemůžeme psát y = 2x, musíme násobení zapsat s hvězdičkou y = 2*x.

Priorita operací je stejná jako v matematice a stejně jako v matematice můžeme používat závorky:

print(2+3*4)    # -> 14

print((2+3)*4)  # -> 20

x = 5

print(3*x**2)   # -> 75

print((3*x)**2) # -> 225

Zkrácený zápis

Při programování často aktualizujeme hodnotu proměnné tak, že k ní přičítáme určitou hodnotu, např. x = x + 1, money = money + wage. Protože to je častá operace, nabízí Python zkrácený zápis pomocí operátoru +=. Podobný operátor máme i pro další aritmetické operace.

x += 1           # to stejné jako x = x + 1

x *= 2           # to stejné jako x = x * 2

money -= price   # to stejné jako money = money - price

Python nabízí vestavěné funkce pro základní matematické funkce, například:

abs(x)        # absolutní hodnota x

round(x)      # zaokrouhlená hodnota x (na celé číslo)

round(x, 2)   # zaokrouhlená hodnota x na 2 desetinná místa

min(x, y)     # minimum z x, y

max(x, y, z)  # maximum z x, y

Další užitečné matematické funkce (např. log, sqrt, sin, floor) Python nabízí v knihovně math.

Logické výrazy Python vyhodnocuje na hodnoty True (pravda) a False (nepravda). Přesný zápis těchto konstant bývá zdrojem chyb:

• Velké písmeno je důležité: True je logická konstanta (pravda), kdežto true je název proměnné (která může držet libovolnou hodnotu).
• "True" a "False" (tj. názvy logických konstant psány v uvozovkách) jsou obyčejné řetězce, nikoliv konstanty se speciálním významem.

Operátory porovnání

Základním logickým výrazem je porovnání mezi dvěma výrazy (např. porovnání hodnoty proměnné a konstanty). Operátory větší/menší zapisujeme podobně jako v matematice (> a <), „větší/menší nebo rovno“ zapisujeme >= a <=. Test na rovnost provádíme pomocí dvou rovnítek (==). Test na nerovnost zapisujeme !=.

Příklady:

x = 42     # přiřazení do proměnné

x == 42    # test rovnosti

x != 42    # test nerovnosti

x > 42     # je větší

x >= 42    # je větší nebo rovno

Pozor na rozdíl mezi přiřazením do proměnné (jedno rovnítko) a testem na rovnost (dvě rovnítka).

Logické spojky

Základní logické výrazy můžeme kombinovat pomocí klasických logických spojek:

• not = negace
• and = a zároveň (konjunkce) = výsledek je True, pokud jsou oba dva argumenty True
• or = nebo (disjunkce) = výsledek je True, pokud je alespoň jeden z argumentů True

a = True    # pravda

b = False   # nepravda

c = a or b  # nebo -> True

c = a and b # a zároveň -> False

c = not a   # negace -> False

Pro procvičení významu spojek využijte cvičení Binární křížovka.

Priority logický spojek

Priority operátorů jsou sestupně: not, and, or (tj. nejvyšší prioritu má not). Pro změnu priority či větší čitelnost výrazů můžeme využít závorky.

x = a or b and c   # nejdříve se vyhodnotí and, až poté or

x = a or (b and c) # to stejné jako předchozí, jen čitelněji zapsáno

x = (a or b) and c # tentokrát se nejdřív vyhodnotí or

x = not a or b     # nejdříve not, až potom or

x = not (a or b)   # nejdříve or, potom not

Program v Pythonu se skládá z více příkazů, které vhodným způsobem kombinujeme:

• Sekvence příkazů znamená, že prostě voláme příkazy jeden po druhém. Věnujeme při tom pozornost jejich výběru a řazení.
• Podmíněný příkaz nám umožňuje některé příkazy vykonat, jen pokud je splněna zadaná podmínka.
• Cyklus for a while využíváme pro opakované spouštění příkazů. Každý z těchto cyklů má trochu jiné použití a je dobré si důkladně procvičit oba dva.
• Řídicí struktury můžeme do sebe vnořit, např. mít podmínku uvnitř cyklu. Samostatně vyčleněné máme téma vnořené cykly, protože to je oblast, se kterou začátečníci typicky bojují.
• Programy dělíme do funkcí, které nám umožňují části kódu opakovaně používat.

Pro úplné začátečníky v Pythonu může být užitečné si jako rozcvičku projít cvičení na základy algoritmického myšlení, kde je možné si základy použití cyklů a podmínek procvičit formou grafického programování.

Podmíněné vykonání příkazu zapisujeme pomocí if. Jako podmínku můžeme použít libovolný logický výraz. Podmíněně můžeme vykonat také více příkazů. Blok příkazů vyznačujeme odsazením:

if answer != 42:           # příkazy se vykonají pouze, pokud je podmínka splněna:

    print("Bad answer")    # vypíšeme text

    answer = 42            # a navíc změníme proměnnou

Else větev

Můžeme také říct, co se má stát, když podmínka splněna není. K tomu slouží příkaz else, který je následovaný odsazeným blokem příkazů:

if x < 10:

    print("small")    # provede se, pokud podmínka je splněna

else:

    print("big")      # provede se, pokud podmínka není splněna

Jednotlivým variantám výpočtu říkáme větve a podmíněný příkaz můžeme také označovat jako větvení.

Vícenásobné větvení

Pokud chceme testovat více možností, můžeme použít konstrukci if / elif / else. V některých programovacích jazycích se pro vícenásobné větvení používá příkaz switch. Tento příkaz v Pythonu nemáme, vystačíme si s využitím elif. Příklad:

if age < 6:

    print("předškolák")

elif age < 18:        # testuje se, pokud neplatí předchozí podmínka

    print("školák")

elif age < 65:        # testuje se, pokud neplatí ani jedna předchozí podmínka

    print("dospělý ")

else:                 # provede se, pokud neplatí ani jedna předchozí podmínka

    print("důchodce")

Z if/elif větví se provede maximálně jedna z nich – ta první, u které je splněna podmínka. Pokud v uvedeném příkladě je v proměnné age uložena hodnota 15, vypíše se pouze text „školák“. Podmínka age < 65 je sice také splněna, ale k jejímu vyhodnocování již nedojde.

Vnořené větvení

Podmíněné příkazy můžeme i zanořovat, tj. některá z větví můžem mít další větvení. U následných větví pak musíme zvýšit odsazení. Můžeme tedy psát například:

if choice == "tea":

    if money >= 10:

        print("ok")

    else:

        print("refuse")

else:

    print("not available")



if n % 2 == 1:

    if x > 13:

        print("Win!")

V některých případech je však jednodušší a přehlednější místo vnořeného kódu použít jednoduchý podmíněný příkaz s podmínkou využívající logické operace. Například druhý uvedený příklad můžeme zjednodušit takto:

if n % 2 == 1 and x > 13:

    print("Win!")

Cykly při programování využíváme pro opakování skupiny příkazů. Opakování označujeme často pojmem iterace.

Cyklus for využíváme, pokud dopředu víme, kolik opakování bude cyklus mít. V ostatních případech využíváme cyklus while.

Jednoduchý for cyklus

Základní využití cyklu for je pro prosté opakování sady příkazů. Pomocí for i in range(10) zopakujeme 10× sadu příkazů. Příkazy, které se mají opakovat, musíme odsadit. Takto tedy vypíšeme desetkrát Ahoj:

for i in range(10):

    print("Ahoj")

Řídící proměnná

V průběhu cyklu se mění hodnota řídící proměnné (ve výše uvedeném příkladu je to i). V každém opakování cyklu tak můžeme provést něco trochu jiného v závislosti na aktuální hodnotě této proměnné. Jakých hodnot řídící proměnná nabývá určuje část za in. Pokud použijeme základní range, bude se řídící proměnná postupně zvětšovat o jedničku. Tento cyklus například vypíše čísla od 0 do 9:

for i in range(10):

    print(i)

V rámci cyklu můžeme využívat více proměnných, pouze u řídící proměnné se však hodnota mění automaticky. Uvažme tento příklad:

y = 1

z = 2

for x in range(10):

    y = x + y + z

    print(x, y, z)

Řídící proměnnou cyklu je x, jehož hodnota se tedy bude postupně měnit (od 0 po 9). U proměnné y se bude hodnota měnit, protože v rámci cyklu máme přiřazovací příkaz do y. Hodnota proměnné z zůstane ve všech opakováních stejná, protože z není řídící proměnná ani do ní v cyklu nic nepřiřazujeme.

Využití range

Při základním použití kombinujeme for cyklus s funkcí range, která vrací interval čísel a řídící proměnná následně nabývá hodnot z tohoto intervalu.

Pozor: V informatice často počítáme od nuly (nikoliv od jedničky jako normální lidé). Na to narážíme i zde: range(n) vrací hodnoty od 0 do n-1.

Pokud funkci range zadáme dva parametry, tj. voláme range(a, b) dá nám interval čísel od a do b-1. Můžeme zadat i třetí parametr, který udává délku skoku. Příklady:

for x in range(5, 13): print(x, end=" ")     # 5 6 7 8 9 10 11 12

for x in range(5, 16, 3): print(x, end=" ")  # 5 8 11 14

for x in range(8, 0, -1): print(x, end=" ")  # 8 7 6 5 4 3 2 1

For cyklus se dá využít nejen ve spojení s range, ale i obecněji. Můžeme například použít seznamy:

for x in [3, 7, 10]:

    print(x)

Ukázky použití for cyklu

n = 20

for i in range(1, n+1):

    if i % 2 == 0:

        print(i, "je sudé")

    else:

        print(i, "je liché")

n = 10

s = 0

for i in range(1, n+1):

    s = s + i

print("Součet od 1 do", n, "je", s)

n = 10

for x in range(1, n+1):

    print("Dvojka umocněna na", x, "je", 2**x)

Cykly při programování využíváme pro opakování skupiny příkazů. Opakování označujeme často pojmem iterace.

Cyklus while využíváme, pokud dopředu nevíme, kolikrát se bude cyklus opakovat. Pokud dopředu počet opakování známe, využíváme cyklus for.

Základní použití

While cyklus se opakuje tak dlouho, dokud je splněna řídící podmínka cyklu (v následující ukázce jde o n > 5). Tělo cyklu (příkazy, které se mají opakovat) vyznačujeme odsazením.

n = 5

while n > 0:

    print("Tohle se vypíše pětkrát.")

    n = n - 1

Tímto cyklem vypisujeme mocniny dvou, dokud nepřekročí stovku:

n = 1

while n < 100:

    print(n)

    n = n * 2

Nula i nekonečno opakování

Podmínka se vyhodnocuje ještě před prvním vykonáním těla cyklu. Pokud není splněna, tak se tělo while cyklu neprovede ani jednou:

n = 200

while n < 100:

    print("Tohle se nevypíše.")

Může se stát, že while cyklus neskončí nikdy. Tento program vypisuje donekonečna jedničky:

n = 1

while n < 100:

    print(n)

Takový nekonečný cyklus většinou znamená chybu v programu. Typickou chybou je, že zapomeneme v těle cyklu měnit hodnotu proměnné vystupující v podmínce cyklu. Tuto situaci označujeme jako „zacyklení programu“.

Ukázky použití while cyklu

n = 1

while n < 1000:

    print(n)

    n *= 2

total = 0

value = int(input())

while value:

    total += value

    print("Current sum:", total)

    value = int(input())

print("Final sum:", total)

K opakování příkazů slouží základní cyklus for a cyklus while.

V těle cyklu mohou být nejen základní příkazy, ale třeba i další cyklus – ten nazýváme vnořený cyklus. Pro jeho použití nepotřebujeme žádný nový příkaz. Prostě jen cyklus zapíšeme (a odsadíme) uvnitř jiného cyklu. Vnořené cykly se ovšem vyplatí trénovat, jsou častým zdrojem problémů.

Příklad:

n = 5

for i in range(n):

    for j in range(n):

        print(i+j, end=" ")

    print()

Tento program vypisuje tuto tabulku:

0 1 2 3 4

1 2 3 4 5

2 3 4 5 6

3 4 5 6 7

4 5 6 7 8

Vnitřní cyklus (s řídící proměnnou j) vypisuje jednotlivé řádky. Vnější cyklus (s řídící proměnnou i) pak zařídí vypsání celé tabulky. Na tomto příkladu je dobře vidět důležitá role správného odsazení. Příkaz print() způsobuje odřádkování – používáme jej v programu vždy po výpisu kompletního řádku.

Funkce je pojmenovaný blok příkazů. Funkcím můžeme předávat argumenty. Funkce vrací návratovou hodnotu.

Definice funkce

Python nabízí celou řadu vestavěných funkcí, tedy takových, které jsou již připravené tvůrci jazyka. Příkladem je třeba funkce len, která počítá délku řetězce.

Vlastní funkci definujeme pomocí klíčového slova def:

def say_hello(name):

    print("Hello", name)

Tímto jsme definovali funkci say_hello, která má parametr name. Funkce může mít i více parametrů.

Volání funkce

Tím, že definujeme funkci, se ještě nevykoná. Aby se funkce vykonala, musíme ji zavolat. To uděláme tak, že napíšeme jméno funkce a do závorek předáme konkrétní argument:

say_hello("Alice")  # vypíše Hello Alice

say_hello("Bob")    # vypíše Hello Bob

Některé funkce jsou bez parametrů. U jejich volání musíme závorky stále uvést, např. say_goodbye().

Návratová hodnota

Funkce může vracet návratovou hodnotu pomocí klíčového slova return. Následující funkce vypočítá a vrátí faktoriál.

def factorial(n):

    f = 1

    for i in range(1, n+1):

        f = f*i

    return f

Takováto funkce sama o sobě nic neprovede, pouze vrátí hodnotu, se kterou můžeme dále pracovat.

factorial(5)         # vypočítá hodnotu faktoriálu z 5, ale pak se tato

                     # hodnota nijak nepoužije

print(factorial(4))  # tentokrát výsledek výpočtu vypíšeme

x = factorial(6)     # výsledek výpočtu se uloží do proměnné

print(x)             # a pak třeba můžeme hodnotu proměnné vypsat

Příkaz return ukončuje provádění funkce. Při volání následující funkce se tedy vypíše pouze foo:

def test():

    print("foo")

    return 0

    print("bar")

Rozdíl return a print

Častý zdroj problémů u začátečníků je správné rozlišování mezi použitím print a return ve funkcích.

Použití print způsobí okamžitý výpis hodnoty, nelze však s touto hodnotou nijak dál pracovat.

Použití return ukončí funkci a vrátí hodnotu. Ta se automaticky nevypíše, ale můžeme ji přiřadit do proměnné a dále s ní pracovat.

Základním prvkem programování je práce s daty. Data si udržujeme v proměnných a datových strukturách. Pro tento účel máme v Pythonu různé datové typy a každý z nich má své specifické způsoby použití. Základní notaci a označení v Pythonu se věnuje téma přehled datových typů.

Procvičování na Umíme se soustředí na nejvíce používané datové typy:

• Číselné typy (int, float) pokrývá základní téma proměnné a číselné výrazy.
• Logický typ (bool) souvisí úzce s tématem logické výrazy.
• Řetězce jsou sekvence znaků, které oproti číslům přidávají navíc především princip indexování.
• Seznamy jsou obecnější než řetězce, mimo jiné tím, že jsou dynamicky měnitelné a mohou obsahovat prvky různých typů.
• Slovníky umožňují indexování nejen čísly, ale třeba i řetězci.

S datovými typy pak souvisí obecnější téma objektů, které už patří k pokročilejším a zde pokrýváme jen úplné základy.

Přehled typů

Základní datové typy v Pythonu jsou:

Python nabízí i další typy, např. complex (komplexní čísla), tuple (entice, neměnitelná sekvence), set (množina).

Měnitelnost a neměnitelnost

Typy rozlišujeme podle toho, zda jejich hodnoty můžeme měnit:

• měnitelné (mutable) typy jsou list, set, dict,
• neměnitelné (immutable) typy jsou int, float, bool, str, tuple.

Toto rozlišení je důležité například při využití slovníků – slovníky můžeme indexovat pouze neměnitelnými typy.

Přetypování

Názvy typů jsou současně názvy vestavěných funkcí, které provedou přetypování. Typy proměnných jsou velice důležité. Ovlivňují například význam operátorů. Typický příklad je přetypování čísla na řetězec:

x = 15

print(x)    # vypíše 15

print(3*x)  # vypíše 45

x = str(x)  # přetypování na řetězec, x nyní obsahuje "15"

print(x)    # vypíše 15 (zde se rozdíl typu neprojeví)

print(3*x)  # vypíše 151515 (protože x je nyní řetězec a operace * pro řetězec

            # znamená opakované zřetězení)

Zápis řetězců

Řetězce zapisujeme do uvozovek nebo apostrofů. V Pythonu 3 mohou řetězce obsahovat i znaky s diakritikou.

a = "Toto je řetězec"

b = 'Toto je taky řetězec'

print(a, b)

Indexování

K jednotlivým znakům řetězce přistupujeme pomocí indexování hranatými závorkami. Pozor, indexujeme od nuly. Python (na rozdíl od většiny jiných programovacích jazyků) umožňuje indexovat i od konce pomocí záporných čísel.

text = "prase"

text[0]     # první písmeno => 'p'

text[1]     # druhé písmeno => 'r'

text[4]     # páté, poslední písmeno => 'e'

text[-1]    # poslední písmeno => 'e'

text[-2]    # předposlední písmeno => 's'

Pomocí dvojtečky můžeme indexovat podřetězec.

text = "panoramata"

print(text[2:6])  # od 2. po 6. pozici => nora

print(text[:3])   # první 3 znaky => pan

print(text[-4:])  # poslední 4 znaky => mata

Pokročilejším prvkem pak je využití dvou dvojteček, kde třetí hodnota udává délku skoku:

text = "Běží-liška-k-táboru"

print(text[5:15:2])  # od 5. po 14. pozici, ob 2 => lšakt

print(text[::3])     # od začátku do konce, ob 3 => Bíia-bu

print(text[::-1])    # pozpátku => urobát-k-akšil-ížěB

Iterování přes řetězec

Jednotlivé znaky řetězce můžeme snadno procházet pomocí for cyklu.

text = "koniklec"

for letter in text:

    print("písmeno:", letter)

Neměnitelnost řetězců

Řetězce jsou v Pythonu neměnitelný datový typ. To je jeden z výrazných rysů, ve kterých se liší od seznamů. Neměnitelnost znamená, že nemůžeme změnit dílčí písmeno v znaku. Musíme vytvořit nový řetězec, ve kterém bude příslušné písmeno změněno.

text = "kopec"

text[2] = "n"                 # TypeError - řetězec neumožňuje změnu znaku

text = text[:2]+"n"+text[3:]  # vytvoříme nový, upravený řetězec

print(text)

Operace s řetězci

Řetězce můžeme sčítat (= zřetězit). Řetězce můžeme také násobit celým číslem (= opakovaně zřetězit). Mezi další užitečné operace patří zjištění délky (len) či test na přítomnost podřetězce (in).

text = "petr"

text + "klíč"  # => petrklíč

3*text         # => petrpetrpetr

len(text)      # => 4

"e" in text    # => True

Řetězce jsou objekty, které mají k dispozici řadu užitečných metod, které voláme pomocí tečkové notace. Příklady jsou převod na velká/malá písmena (upper, lower), rozdělení řetězce podle zadaného znaku (split), nebo nahrazování podřetězce (replace):

text = "Liberec"

text.upper()               # => LIBEREC

text.lower()               # => liberec

text.split("e")            # => ['Lib', 'r', 'c']

text.replace("ber", "dej") # => Lidejec

Všimněte si, že zde využíváme takzvanou tečkovou notaci: píšeme text.upper(), nikoliv běžné volání funkce tvaru upper(text). To souvisí s tím, že řetězce jsou reprezentovány jako objekty.

Operace se znaky

Při práci s řetězci se občas hodí i operace pro manipulaci s jednotlivými znaky, především funkce ord a chr, které převádí znaky na celá čísla a zpět:

• ord(c) vrátí pořadové číslo znaku c,
• chr(i) vrátí znak s pořadovým číslem i.

Pod „pořadové číslo“ se rozumí číslo v kódování Unicode. Pro základní programátorské úlohy stačí vědět, že písmena jsou v tomto kódování abecedně za sebou (bohužel to však platí jen pro písmena anglické abecedy). Takto tedy můžeme vypsat písmena anglické abecedy:

start = ord('A')

for i in range(26):

    print(chr(start + i))

Seznam (list) je uspořádaná kolekce hodnot libovolného typu.

Vytvoření seznamu

Seznamy zapisujeme pomocí hranatých závorek:

s = []           # prázdný seznam

s = [8, 3, 45]   # seznam tří čísel

Seznam můžeme také vytvořit pomocí klíčového slova list.

s = list("prase")   # vytvoří seznam ['p', 'r', 'a', 's', 'e']

Indexování

K jednotlivým prvkům seznamu přistupujeme pomocí indexování hranatými závorkami. Pozor, indexujeme od nuly. Zápornými čísly můžeme indexovat odzadu:

s = ["pes", "prase", "ovce", "koza"]

s[0]      # první prvek seznamu => "pes"

s[1]      # druhý prvek seznamu => "prase"

s[-1]     # poslední prvek seznamu => "koza"

s[-2]     # předposlední prvek seznamu => "ovce"

Pomocí dvojtečky můžeme indexovat část seznamu:

numbers = [37, 99, 42, 7, 13, 1, 1000]

print(numbers[2:5])  # => [42, 7, 13]

print(numbers[:3])   # => [37, 99, 42]

print(numbers[-2:])  # => [1, 1000]

Operace se seznamy

Užitečné funkce se seznamy:

s = [8, 3, 45]

a = len(s)    # délka seznamu

s.append(7)   # přidání prvku do seznamu

s.sort()      # seřazení prvků v seznamu

t = sorted(s) # seřadí prvky v s a tento nový seznam přiřadí do t

              # s se nezmění

Všimněte si, že zde využíváme takzvanou tečkovou notaci: píšeme s.sort(), nikoliv běžné volání funkce tvaru sort(s). To souvisí s tím, že seznamy jsou reprezentovány jako objekty.

Seznamy a for cyklus

Pomocí for cyklu můžeme procházet prvky seznamu:

s = [8, 3, 45]

for x in s:

    print(x)

Alternativně můžeme procházet prvky seznamu takto (tento zápis je bližší tomu, jak procházíme seznamy v jiných programovacích jazycích):

for i in range(len(s)):

    print(s[i])

Slovník (dictionary, dict) udává mapování klíčů na hodnoty. Můžeme si třeba pamatovat počty kusů ovoce na skladě.

Vytvoření slovníku

Slovník vytváříme v Pythonu pomocí složených závorek.

fruits = {"apple": 5,

          "banana": 10,

          "orange": 2}



empty_dictionary = {}    # prázdný slovník

Přístup k položkám

K položkám slovníku přistupujeme pomocí indexování hranatými závorkami. Podobně můžeme do slovníku položku přidat.

print(fruits["apple"])

fruits["pear"] = 3

Pokud se pokusíme přistoupit k položce, která ve slovníku není, dostaneme chybu. Bezpečný přístup provedeme pomocí get:

print(fruits["plum"])    # => KeyError: 'plum'

print(fruits.get("plum", 0))   # pokud položka ve slovníku není,

                               # vrátí zadanou hodnotu (0)

Práce se slovníky

Další užitečné funkce pro práci se slovníky:

len(fruits)        # počet klíčů ve slovníku

fruits.keys()      # klíče ve slovníku, tj. 'pear', 'orange', 'banana', 'apple'

fruits.values()    # hodnoty ve slovníku, tj. 10, 2, 3, 5

"apple" in fruits  # test na přítomnost ve slovníku

Python, stejně jako většina dalších moderních programovacích jazyků, podporuje objektově orientované programování. To už je poměrně pokročilé programátorské téma. Zde si shrneme jen některé základní pojmy.

Objekt (object) je kolekce dat (proměnných) a metod (funkcí), které s těmito daty pracují. V Pythonu jsou téměř všechna data, se kterými se setkáme, objekty (čísla, řetězce, seznamy, …).

Objekty jsou speciální instance tříd (class). Třídu můžeme chápat jako obecný vzor, podle kterého se tvoří objekty.

Příklad definice třídy:

class Person:

    def __init__(self, name, age):

        self.name = name

        self.age = age

        

    def introduce(self):

        print("My name is ", self.name)

        print("I am ", self.age, "years old")

A takto vytvoříme objekty (instance třídy) a použijeme je:

homer = Person("Homer Simpson", 39)

bart = Person("Bart Simpson", 10)

homer.introduce()

bart.introduce()

V tomto příkladě:

• Person je třída,
• homer a bart jsou objekty,
• name a age jsou datové atributy,
• introduce() je metoda,
• __init__ je inicializační metoda, která se automaticky volá při vytváření objektu.