Přehled všech témat

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

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

Python dále nabízí vestavěné funkce jako abs(x) (absolutní hodnota x), round(x) (zaokrouhlená hodnota x), min(x, y) (minimum z x a 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 (pro procvičení významu spojek využijte cvičení Binární křížovka:

• 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

Příklady:

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ých 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.

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

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

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. Tento cyklus tedy vypíše čísla od 0 do 9:

for i in range(10): 

    print(i)

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í

Takto vypočítáme pomocí for cyklu součet čí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)

Takto vypíšeme 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ů. 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í

Může se stát, že tělo while cyklu se 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.

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á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ř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'

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

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í

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.

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é. Shrneme především základní operátory.

Kvantifikátory

Kvantifikátory 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.

Hranice

Skupiny znaků

Alternativy a seskupování

Vymezují více možností, případně seskupují znaky k sobě.

Metaznaky

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