Přehled všech témat

Algoritmické myšlení je součást obecnějšího informatického myšlení, která se zaměřuje na navrhování algoritmů. Algoritmus je přesně daný postup kroků, kterým řešíme určitý problém. Algoritmické myšlení se typicky využívá při programování, tj. při zápisu algoritmů, které provádí počítač. Má však svoje využití i v běžném životě: typickými příklady jednoduchých algoritmů jsou recepty na vaření nebo instrukce k sledování cesty z jednoho místa na druhé.

Algoritmické myšlení zahrnuje nejen tvorbu algoritmu, ale i další související kroky:

• Porozumění problému, jasná formulace problému.
• Zvážení různých přístupů k řešení problému, porovnání efektivity algoritmů.
• Porozumění algoritmu, který vymyslel někdo jiný, a jeho provedení.
• Hledání a opravování chyb.

Základním krokem jakéhokoliv algoritmu je provádění posloupnosti akcí v předepsaném pořadí. Pořadí, v jakém akce provádíme, je důležité. Někdy je to úplně jasné. Když připravujeme palačinky, musíme nejdříve těsto zamíchat, a až potom dát na pánvičku. Kdybychom pořadí akcí prohodili, nedopadlo by to příliš palačinkově. Podobně to dopadne, když chystáme program pro robota. Pokud se robot nejdřív otočí a pak udělá krok, dopadne to jinak, než když udělá krok a pak se otočí.

Kdybychom všechny algoritmy vyjadřovali jako prostou posloupnost akcí, byly by často velmi dlouhé a nepřehledné. Proto se snažíme v problémech hledat pravidelnosti a vzory a ty následně vyjádřit v algoritmu pomocí opakovaného provádění stejných instrukcí.

U většiny algoritmů potřebujeme, aby postup závisel na aktuálním stavu. Polévku musíme zahřívat a míchat, dokud nezačne vřít. Pokud při příjezdu na křižovatku svítí červená, auto musí zastavit.

Při vyjadřování podmínek často využíváme logické spojky (a zároveň, nebo).

V pokročilé informatice se rozlišuje souběžnost a paralelismus, zde však do těchto detailů nebudeme zacházet. Tyto pojmy označují souběh více dějů současně. To je pochopitelně něco, co se ve světě kolem nás děje neustále. Pokud se však snažíme vymýšlet algoritmická řešení problémů, je souběžnost většinou oříšek. Není totiž vůbec jednoduché souběh více událostí správně naplánovat.

Pro trénink přemýšlení o souběžnosti využijeme především úlohy na čtverečkované mřížce, kde se současně pohybuje několik agentů.

V programování je proměnná úložiště, které udržuje hodnotu, přičemž tato hodnota se může měnit. Příklad:

• Do proměnné x uložíme hodnotu 3.
• Hodnotu proměnné x následně zvětšíme o 2.
• Vypíšeme hodnotu proměnné x (tj. 5).

Typickým příkladem použití proměnné je výpočet celkové ceny nákupu. Program v pokladně na začátku uloží do proměnné sum hodnotu 0. Při načtení každé položky nákupu, přičte její cenu do této proměnné.

Jiný příklad: V programu pro hraní piškvorek potřebujeme zjistit, jestli již jeden z hráčů vyhrál. Procházíme tedy jednotlivé směry na hracím plánu a v každém z nich počítáme, kolik křížků (či koleček) se vyskytuje v řadě za sebou. Tento počet si ukládáme v proměnné. Krom toho si do nějaké proměnné potřebujeme uložit i celý herní plán… V základních cvičeních však zůstaneme pouze u číselných proměnných, které vesměs budou fungovat jako jednoduché čítače.

Funkce jsou základním stavebním blokem, pomocí kterého vytváříme programy. Představují konkrétní realizaci obecného principu rozklad na části.

Zjednodušeně řečeno, funkce je kouzlo, kterému něco předložíme (vstup) a ono nám vykouzlí něco jiného (výstup).

• Pohádkový příklad: Zvětšovací kouzelná hůlka, kterou poťukáme zeleninu a ona ji zvětší na dvakrát větší velikost.
• Matematický příklad: Funkce odmocnina, která dáme na vstup číslo a ona nám vrátí jiné číslo (např. pro vstup 25, vrátí výsledek 5).
• Programátorský příklad: Funkce polygon(sides, length), které dáme na vstup dvě čísla (počet stran a délku strany) a ona vykreslí obrázek mnohoúhelníku.

Abychom byli schopni řešit problémy, pracovat s daty a vymýšlet algoritmy, musíme být schopni hledat pravidelnosti a vzory. Nalezené vzory se následně snažíme využít pro hledání společných prvků a zobecňování, která nám umožní tvořit efektivní řešení.

Ilustrační, zjednodušený příklad ze života:

• Karlovi neustále dochází peníze, tak si začal zapisovat výdaje.
• Nejdříve si do sešitku zapisuje výdaje zcela konkrétně, např. „kniha Hobit, 243 Kč“, „chleba a sýr na večeři, 58 Kč“. Z takového zápisu je ale těžké se poučit.
• Karel prohlédne výdaje, najde pravidelně se vyskytující typy výdajů a použije zobecňování: výdaje rozdělí do vhodných kategorií („jídlo“, „oblečení“, „studium“, …).
• Následně si výdaje přepíše do tabulkového editoru. Ten mu umožní snadno vypočítat celkové výdaje v jednotlivých kategoriích.
• Karel tak zjistí, že utrácí až příliš za oblečení. Ví, na čem je, a může s tím něco dělat.

Velmi užitečný přístup k řešení problémů je rozložit problém na dílčí části, které jsou pokud možno co nejvíce nezávislé, a následně řešit tyto části jednu po druhé.

Příklad z běžného života: Potřebujeme se nachystat na putovní výlet na hory. Je potřeba zařídit spoustu věcí a můžeme se cítit přehlceni a snadno na něco důležitého zapomenout. Může pomoct, když si celkový problém příprava na hory rozdělíme na dílčí podproblémy: 1) naplánovat trasu a najít spoj, 2) vymyslet jídelníček a nakoupit jídlo, 3) nachystat tábornické vybavení a zkontrolovat jeho stav, 4) rozmyslet a nabalit oblečení. Tyto dílčí úkoly jsou do velké míry na sobě nezávislé a mohou je tudíž řešit různí lidé. I pokud je řeší ten stejný člověk, tak se při řešení dílčího podproblému může soustředit pouze na něj, což mu postup usnadní.

Příklad z programování: Programy nepíšeme jako dlouhé seznamy příkazů, ale dělíme je na funkce, z nichž každá řeší nějaký dílčí problém. Rozdělení na podproblémy je klíčovým prvkem dobrého návrhu programů.

Rozklad problémů na části je složitá dovednost, kterou se člověk učí dlouhodou praxí. Pro základní trénink nabízíme příklady s obrázky. Složitě vypadající obrázek často lze vytvořit z jednoduchých částí, které pouze vhodným způsobem poskládáme.

Abstrakce je schopnost odhlížet od detailů, které nejsou důležité pro řešení zkoumaného problému. Soustředíme se na společné prvky a vlastnosti, pomocí kterých nacházíme obecnější řešení.

Příklad z běžného života: Alík, Ben a Rex jsou tři konkrétní domácí zvířata. Můžeme je označit abstraktním pojmem „pes“ – tím zanedbáváme řadu jejich vlastností (např. stáří, barvu srsti či rasu) a soustředíme se jen na to, co mají společné. Kdybychom měli doma ještě kocoura Mourka, tak bychom mohli pro jejich společné označení použít třeba kategorii „savec“.

Příklad z programování: Při vykreslování obrázků můžeme vytvořit funkci squareA(), která vykreslí modrý čtverec o velikosti 100, a squareB(), která vykreslí žlutý čtverec o velikosti 200. Lepší je ale vytvořit abstraktnější funkci square(length, color), která vykreslí čtverec libovolné velikosti a barvy (podle zadaných parametrů). Případně můžeme v abstrakci pokračovat dál a vytvořit funkci, která vykreslí libovolný mnohoúhelník (se zadaným počtem vrcholů).

Pravdivostní hodnoty

V informatice používáme většinou zaměnitelně následující:

• 1 = true = pravda
• 0 = false = nepravda

Logické spojky

Pravdivostní tabulka logických operací

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

Matematické funkce

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.

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

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

Python obsahuje i další pokročilejší operátory. Mezi záludné patří is, které se chová podobně jako == a jeho použití bývá zdrojem chyb. Operátor is je užitečný nástroj pro pokročilé programátory, začátečníkům silně doporučujeme se mu vyhnout.

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

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

V některých programovacích jazycích se logické spojky zapisují pomocí symbolů &, |, !. V Pythonu se tyto symboly nepoužívají, logické spojky se píší anglickými slovy:

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

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

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 10x 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í lidi). 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

Výpis informace o sudosti a lichosti prvních n čísel:

n = 20

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

    if i % 2 == 0:

        print(i, "je sudé")

    else:

        print(i, "je liché")

Výpočítet součtu čísel od 1 do n:

n = 10

s = 0

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

    s = s + i

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

Výpis informaci o prvních n mocninách dvojky:

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é, které vystupuje v podmínce cyklu.

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. Co by se stalo, kdybychom jej odsadili více/méně?

• Kdybychom print() odsadili o úroveň více, byl by součástí vnitřního cyklu, takže by se odřádkování provedlo po každém čísle. Výstupem programu by pak byla řada čísel pod sebou.
• Kdybychom print() odsadili o úroveň méně, byl by zcela mimo cykly, takže by se odřádkování provedlo jen jednou, až úplně nakonec. Výstupem programu by pak byla řada čísel v jednom řá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.

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

Pro základní představu u binárních číslech můžeme použít pomůcku, kterou máme vždy po ruce – totiž ruku samotnou. Představme si, že si na prsty ruky napíšeme mocniny dvojky:

Pak můžeme na prstech jedné ruky počítat nejen do pěti, ale až do třiceti jedné. Každé číslo lze totiž vyjádřit (jednoznačně) jako součet mocnin dvojky. Pokud polohu prstů zaznačíme pomocí nul a jedniček, dostaneme zápis v binární soustavě:

Pomocí HTML můžeme označovat význam a zobrazení textu, například takto:

Toto je <b>tučný</b> text. A toto <i>kurzíva</i>.

Přehled běžných značek:

Některé značky udávají význam textu, např. <strong> a <em>, zatímco jiné udávají pouze způsob zobrazení, např. <b> a <i>. Typické zobrazení <strong> a <em> je tučné písmo a kurzíva, to však lze upravit pomocí kaskádových stylů (CSS).

Párové značky lze zanořovat, například tučnou kurzívu zapíšeme <b><i>takto</i></b>. Značky nelze „křížit“, tj. před uzavřením značky musíme vždy nejprve uzavřít všechny zanořené značky. Nepárové značky nemají žádný obsah ani ukončovací značku, např. <br>.

Mezery a nové řádky

Libovolné množství mezer a nových řádků v HTML kódu se zobrazí jako jedna mezera. Pokud potřebujeme nový řádek, použijeme značku <br>. Pokud chceme zachovat přesné počty mezer a nových řádků, použijeme značku <pre>:

<pre>

10x +  2y  =  16

 5x +   y  =   8

</pre>

Značky h1–h6, p, pre a hr jsou blokové, což znamená, že se před nimi i za nimi zalomí řádek. Například každý odstavec začne na novém řádku, i pokud ve zdrojovém kódu nový řádek není:

<p>První odstavec.</p> <p>Druhý odstavec.</p>

Atributy

Některé značky mají atributy, které ovlivňují jejich zobrazení či chování. Například u odkazů potřebujeme určit jejich adresu (atribut href z anglického hypertext reference) a volitelně, zda se má odkaz otevřít v novém okně (atribut target). U obrázků určujeme cestu k souboru (src), alternativní text (alt), který se vypíše, pokud obrázek nemůže být zobrazen, a volitelně velikost v pixelech (width, height). Atributy zapisujeme do úvodní značky a hodnoty obalujeme do uvozovek:

<a href="https://www.umimecesky.cz/">Umíme česky</a>

<img src="celer.png" alt="celer" width="400">`

Seznamy

Nečíslované seznamy vytvoříme pomocí párové značky <ul> (unordered list). Jednotlivé položky seznamu označíme pomocí značky <li> (list item):

<ul>

<li>vlk</li>

<li>los</li>

<li>sob</li>

</ul>

• vlk
• los
• sob

Číslované seznamy vytvoříme pomocí párové značky <ol> (ordered list). Jednotlivé položky označíme opět pomocí značky <li>:

<ol>

<li>vlk</li>

<li>los</li>

<li>sob</li>

</ol>

1. vlk
2. los
3. sob

Typ odrážek a číslování lze změnit pomocí atributu type:

<ol type="A">

<li>vlk</li>

<li>los</li>

<li>sob</li>

</ol>

1. vlk
2. los
3. sob

Tabulky

Tabulku vytvoříme pomocí značky <table>, její řádky pomocí <tr> (table row), buňky pomocí <td> (table data):

<table>

<tr><td>pes</td><td>vlk</td></tr>

<tr><td>los</td><td>sob</td></tr>

</table>

Pro zvýraznění textu v hlavičce použijeme <th> místo <td>:

<table>

<tr><th>Zvíře</th><th>Výška</th></tr>

<tr><td>los</td><td>180 cm</td></tr>

<tr><td>sob</td><td>120 cm</td></tr>

</table>

Výchozí zobrazení tabulek je typicky bez čar oddělujících jednotlivé buňky. Vzhled lze změnit pomocí kaskádových stylů (CSS).

Spojování buněk

Buňky lze spojovat pomocí atributů rowspan a colspan. Hodnota atributu udává, kolik řádků či sloupců slučujeme.

<table>

<tr><td rowspan=2>vlk</td><td colspan=2>pes</td></tr>

<tr><td>los</td><td>sob</td></tr>

</table>

A1 je odkaz na hodnotu v buňce na řádku 1 ve sloupci A. Takovéto odkazy můžeme použít ve vzorcích, například A1+A2.

Často chceme vzorec nakopírovat do dalších buněk tabulky přetažením (nebo Ctrl+C, Ctrl+V, atd.), abychom podobný výpočet provedli na dalších datech. Například

• spočítat součet hodnot na každém řádku,
• porovnat všechny hodnoty v řádku s hodnotou v jedné dané buňce,
• atd.

Relativní a absolutní odkazy

Absolutní odkaz jako $A$1 odkazuje na hodnotu v buňce A1 a zkopírováním se nezmění. Pokud bychom v třetím řádku tabulky chtěli mít hodnoty ve druhém řádku zmenšené o hodnotu v A1, mohli bychom do buňky A2 napsat za rovnítko vzorec A$2-$A$1 a nakopírovat jej do dalších buněk ve třetím řádku. Vzorce ve třetím řádku budou postupně vypadat takto A$2-$A$1, B$2-$A$1, C$2-$A$1,… Absolutní odkaz na buňku A1 se nakopírováním nezmění. Absolutní souřadnice $2 se také nakopírováním nezmění. (I když v tomto případě by se souřadnice 2 nezměnila, ani kdyby u ní nebyl dolar, protože kopírujeme v rámci jednoho řádku.)

Relativní odkaz jako A1 odkazuje, pokud jej použijeme ve vzorci v buňce B1 na hodnotu v sousední buňce vlevo. Nakopírujeme-li relativní odkaz, bude opět ukazovat na hodnotu v sousední buňce vlevo od buňky, kam vzorec nakopírujeme. Například nakopírováním vzorce =2*A1 z buňky B1 do C2 způsobíme, že v C2 bude vzorec =2*B2.

Spočítat součet hodnot v prvních pěti buňkách na každém řádku můžeme tak, že do prvního řádku napíšeme rovnítko a vzorec SUM($A1:$E1) a nakopírujeme tento vzorec do dalších buněk dolů. V dalších řádcích zůstanou ve vzorci stejné souřadnice s $, ale změní se čísla řádků, na druhém řádku bude SUM($A2:$E2).

Zajímavost: Spočítat součet hodnot v prvních pěti buňkách na každém řádku můžeme i tak, že použijeme vzorec SUM(A1:E1) a nakopírujeme tento vzorec do dalších buněk do stejného sloupce dolů. V dalších řádcích zůstanou ve vzorci stejné sloupcové souřadnice, protože kopírujeme rovně dolů, ale změní se čísla řádků, na druhém řádku bude SUM(A2:E2) atd. Když ale použijem v buňce F1 vzorec SUM($A1:$E1), můžeme jej nakopírovat i diagonálně do G2, F3, H4 a v těchto buňkách se objeví vzorce SUM($A2:$E2), SUM($A3:$E3) a SUM($A4:$E4) s nezměněnými souřadnicemi sloupců.

Na každém listu v tabulkovém procesoru (editoru) jsou označené sloupce písmeny A, B, C, atd. a řádky čísly 1, 2, 3… Takže každá buňka je zadaná svými souřadnicemi, označením sloupce a řádku, např. A1, C10.

Hodnotu v buňce můžeme použít při výpočtu v jiné buňce. A1+B1 znamená součet hodnot v buňkách A1 a B1.

Zápis rozsahů

Rozsahy, které obsahují víc než jednu buňku zapisujeme pomocí dvojtečky, např. A2:A4 zadává rozsah tvořený třemi buňkami A2, A3 a A4 v prvním sloupci. C3:F7 zadává rozsah, který se táhne přes pět řádků 3, 4, 5, 6, 7 a čtyři sloupce C, D, E, F. Tento rozsah má 5 * 4 = 20 buněk.

Rozsahy A3:F3 a C1:E4 mají společné buňky C3, D3 a E3.

Rozsahy jako argumenty funkcí

Funkce mohou brát jako některé ze svých vstupních argumentů rozsah(y). Například SUM(B1:C2) je součet čísel v buňkách B1, B2, C1 a C2.

V tabulkovém editoru můžeme zapisovat vzorce, ve kterých se vyskytují hodnoty jako 2, 0.01 (v české verzi se desetinná čísla zapisují s čárkou 0,01), odkazy na hodnoty v buňkách jako B2, matematické vzorečky jako A1+2, B2*B3, D3/100, 3-A2, funkce, aj. Několik nejjednodušších funkcí je v tabulce.

Kdykoliv potřebujete v textu něco nahradit, najít nebo poupravit, můžete k tomu využít regulárních výrazů. Především u rozsáhlejších textů je jejich používání velice užitečné. Regulární výrazy široké uplatnění v mnoha programovacích jazycích (především skriptovacích jako Python, PHP, Perl, JavaScript). Můžete je ale použít i unixových příkazech (např. grep) nebo v textových editorech (např. Notepad++, Emacs). Regulární výrazy jsou velice bohaté. V našich příkladech shrneme především základní operátory.

Základními prvky regulárních jazyků jsou obyčejná písmena. Ty při vyhledávání odpovídají sami sobě. Pokud tedy zadáme regulární výraz kr, tak mu budou odpovídat slova, která obsahují podřetězec „kr“.

Tečka odpovídá libovolnému znaku.

Metaznaky jsou speciální znaky, které používáme na konstrukci regulárních výrazů (např. .*+?). Co když ale chceme hledat právě tyto znaky? Na to použijeme zpětné lomítko, které ruší význam metaznaku a chápe jej jako znak obyčejný.

Pomocí následujících speciálních znaků můžeme v regulárním výrazu označit skupiny písmen:

Dále můžeme využít následující konstrukce, které vymezují více možností, případně seskupují znaky k sobě:

Kvantifikátory v regulárních výrazech vyznačují, kolikrát se má předcházející výraz opakovat. Například hvězdička v pe*s značí libovolný počet výskytů písmene e.

Pomocí následujících speciálních znaků můžeme v regulárním výrazu označit hranice (začátek, konec) slov i celých řetězců: