Cvičení č. 5 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2026/27)

V minulém díle jste viděli...

Data, se kterými pracuje počítač, jsou vždy zakódována v binární soustavě, bez ohledu na to, v jaké soustavě nebo multimediální reprezentaci jsou zobrazena uživateli na výstupu nebo vstupu.

Základní aritmetické typů v jazyku Python jsou bool, int, float a complex. Kromě booleovských konstant True a False existuje také speciální hodnota None, která má svůj vlastní typ. Čísla můžeme zadávat v desítkové, dvojkové, osmičkové nebo šestnáctkové soustavě:

print(11)
print(0o11)
print(0x11)
print(0b11)

11
9
17
3

S číselnými hodnotami můžeme provádět běžné aritmetické operace pomocí operátorů +, -, *, /, //, % a **. Také jsou k dispozici funkce abs, min, max a můžeme importovat modul math pro zpřístupnění matematických konstant a funkcí:

import math

print("Číslo π je přibližně", math.pi)
print("Hodnota cos(π) je ", math.cos(math.pi))

Číslo π je přibližně 3.141592653589793
Hodnota cos(π) je  -1.0

Komentáře v jazyku Python

Důležitým prvkem programovacích jazyků, který však nemá vliv na vykonávání kódu, jsou komentáře. Komentáře ve zdrojovém kódu programu slouží programátorům k bližšímu vysvětlení příkazu nebo bloku příkazů, které se v programu vyskytují, a umožňují tak program učinit pro lidi pochopitelnějším. Na rozdíl od ostatních prvků jazyka Python nejsou komentáře vázány žádnými syntaktickými pravidly – interpret je zcela ignoruje, pro něj je komentář ekvivalentem mezery: kam se smí vložit mezera, tam se smí vložit komentář.

V jazyku Python komentáře začínají znakem # a končí na konci řádku:

# první komentář
a = 1
b = 2 # druhý komentář
c = 3 # třetí komentář

Pokud je komentář delší, typicky pokud komentuje několik příkazů společně, můžeme jej rozdělit na několik řádků. Takové blokové komentáře je běžné psát před kód, který komentují:

# Zde nastavíme poloměr kruhu, spočítáme jeho obvod,
# a výslednou hodnotu vypíšeme pomocí funkce print.
import math
r = 1.5
obvod = 2 * math.pi * r
print("Obvod kruhu je", obvod)

Obvod kruhu je 9.42477796076938

"""
Zde nastavíme poloměr kruhu, spočítáme jeho obvod,
a výslednou hodnotu vypíšeme pomocí funkce print.
"""
r = 1.5
obvod = 2 * math.pi * r
print("Obvod kruhu je", obvod)

Obvod kruhu je 9.42477796076938

4 + 3
r = 1.5
obvod = 2 * math.pi * r
print("Obvod kruhu je", obvod)

Obvod kruhu je 9.42477796076938

Strukturování programu: podmínky a cykly

Potřebujeme-li se v programu rozhodnout, jak dále řešit zadanou úlohu, používáme podmíněný příkaz, který vyhodnotí zadanou podmínku a na základě obdrženého výsledku se rozhodne, které příkazy bude provádět dál. Dalším velmi častým prvkem pro strukturování programu jsou cykly, které umožňují provádět určité příkazy opakovaně.

Podmíněný příkaz

Podmíněný příkaz začíná klíčovým slovem if, za nímž následuje podmínka a dvojtečka (znak :). Podmínku podmíněného příkazu může tvořit libovolný booleovský výraz (resp. libovolný výraz, který lze převést na typ bool) a tělo podmíněného příkazu je tvořeno blokem příkazů, které se mají provést v případě, je-li podmínka splněna:

a = 1
if a > 0:
    print("číslo je kladné")
    print("číslo se rovná", a)
print("provede se vzdy")

číslo je kladné
číslo se rovná 1
provede se vzdy

a = -1
if a > 0:
    print("číslo je kladné")
    print("číslo se rovná", a)
print("provede se vzdy")  

# tyto i předchozí buňku si pusťte v pytutoru

provede se vzdy

# správné odsazení je důležité:
a = 1
if a > 0:
    print("číslo je kladné")    
     print("číslo se rovná", a)
print("provede se vzdy")

  Cell In[2], line 5
    print("číslo se rovná", a)
    ^
IndentationError: unexpected indent

# správné odsazení je důležité:
a = 1
if a > 0:
    print("číslo je kladné")
    
    print("číslo se rovná", a)
 print("provede se vzdy")

  File <string>:7
    print("provede se vzdy")
                            ^
IndentationError: unindent does not match any outer indentation level

Univerzální syntaktické pravidlo:

Ve všech případech, kde znak : uvozuje nějaký blok příkazů, ať už jde o podmíněný příkaz, cyklus nebo definici nějakého objektu, musí být všechny příkazy, které do daného bloku patří, odsazeny stejným počtem mezer.

Běžně se používá konvence odsazování pomocí 4 mezer. Přesný počet mezer sice není určen syntaktickými pravidly jazyka, ale všichni se této konvence budeme držet. Také pozor na míchání znaků "mezera" (" ", číslo 40 v ASCII) a "tabulátor" (" ", reprezentován symbolem "\t", číslo 9 v ASCII).

Za jednoduchým podmíněným příkazem může následovat příkaz else, který uvozuje blok příkazů, které se mají provést, pokud podmínka v předchozím příkazu if není splněna:

# Větev else
a = 0
if a > 0:
    print("číslo je kladné")
    print("číslo se rovná", a)
else:
    print("číslo není kladné")
    print("číslo se rovná", a)
print("provede se vzdy")

číslo není kladné
číslo se rovná 0
provede se vzdy

vek = 25

kategorie = "plná cena"
cena = 200

if vek > 65:
    kategorie = "sleva"
    cena = 100
    
print(kategorie, cena)    

plná cena 200

vek = 25

kategorie = ""
cena = 0

if vek > 65:
    kategorie = "sleva"
    cena = 100
else:
    kategorie = "plná cena"
    cena = 200
    
print(kategorie, cena)    

plná cena 200

Podmíněné příkazy lze samozřejmě vnořovat, přičemž je nutné dbát na správnou úroveň odsazení vnořených příkazů:

# Podmínky můžeme vnořovat do sebe:
a = 0
if a > 0:
    print("číslo je kladné")
    print("číslo se rovná", a)
else:
    if a == 0:
        print("číslo se rovná 0")
    else:
        print("číslo není kladné")
        print("číslo se rovná", a)

číslo se rovná 0

Mezi příkazy if a else spolu s jejich bloky příkazů může ještě vystupovat libovolný počet příkazů elif (zkratka pro else-if), které umožňují provádět ověření dodatečné podmínky v případě, že žádná z předchozích podmínek nebyla splněna. Předchozí příklad tedy můžeme zjednodušit takto:

# větve elif - výpočet spadne do první větve, kde podmínka platí
# ukázali jsme si, jak to funguje, pokud je pravdivých více podmínek
a = 100
if a > 0:
    print("číslo je kladné")
    print("číslo se rovná", a)
elif a == 0:
    print("číslo se rovná 0")  
elif a > 10: # neprovede se!
    print("číslo vetsi nez 10") 
else:
    print("číslo není kladné")
    print("číslo se rovná", a)

číslo je kladné
číslo se rovná 100

Porovnávací operátory

V jazyku Python jsou k dispozici následující operátory pro porovnávání hodnot výrazů:

Operátor	Význam
==	Rovnost dvou hodnot. Pozor: neplést s přiřazovacím operátorem =.
!=	Nerovnost dvou hodnot ($a \ne b$).
<	Ostře menší.
>	Ostře větší.
<=	Menší nebo rovno ($\le$).
>=	Větší nebo rovno ($\ge$).

Jazyk Python dále umožňuje provádět zřetězené porovnávání. Např. výraz x < y <= z > a je ekvivalentní výrazu x < y and y <= z and z > a.

Všechny operátory jsou k dispozici pro datové typy, kde uvedený význam má smysl (např. operátory <, >, <=, >= nejsou k dispozici pro komplexní čísla, kombinace číslo a textový řetězec, apod.) a jejich výsledek je booleovská hodnota True nebo False.

# Podmínka může být složitější: použijeme operátory and, or, not
# Operátory pro porovnávání: ==, !=, >, <, >=, <=
vek = 40
skupinova_sleva = True

kategorie = "plna cena"
cena = 200
if vek <= 15 or vek > 65 or skupinova_sleva:
    kategorie = "sleva"
    cena = 100
print(kategorie, cena)

sleva 100

# TODO: zřetězené porovnání
x = 0
if x < 10 and x > 3:
    print("ano, je z intervalu")
else:
    print("ne, x není z intervalu")

ne, x není z intervalu

x = 5
if 3 < x < 10 == 10.0:
    print("ano, je z intervalu")
else:
    print("ne, x není z intervalu")

ano, je z intervalu

V podmíněných příkazech, kde je očekávána booleovská hodnota, je možné použít libovolný výraz, jehož hodnotu lze implicitně převést na typ bool. Převod se řídí těmito pravidly: None → False, 0 → False, 0.0 → False, complex(0, 0) → False, všechny ostatní číselné hodnoty → True.

# jako podmínka může sloužit i výraz, jehož hodnota lze implicitně převést na bool:
x = 10
if x != 0:
    print("ano")
else:
    print("ne")

ano

# jako podmínka může sloužit i výraz, jehož hodnota lze implicitně převést na bool:
x = 10
if x:
    print("ano")
else:
    print("ne")

ano

x = -100
if x + 2.6:
    print("ano")
else:
    print("ne")

ano

if "False":
    print("ano")
else:
    print("ne")

ano

if "":
    print("ano")
else:
    print("ne")

ne

# operátory == a !=
a = 3
b = 1 + 2
a == b

True

# čísla typu float neporovnáváme pomocí == a !=, ale lépe pomocí přibližného porovnání:
a = 0.3
b = 0.1 + 0.2
if a == b:
    print("ano")
else:
    print("ne")

ne

a = 0.3
b = 0.1 + 0.2
abs(a - b) < 1e-9

True

a = 0.3
b = 0.1 + 0.2
math.isclose(a, b)

True

Příklady

1. Sudé-liché. Napište program, který zjistí a vypíše, zda je zadané číslo sudé nebo liché.

# %
cislo = int(input("Zadej cislo"))
if cislo % 2 == 1:
    print(cislo, "je liche")
else:
    print(cislo, "je sude")

4 je sude

cislo = int(input("Zadej cislo"))
if cislo % 2:
    print(cislo, "je liche")
else:
    print(cislo, "je sude")

4 je sude

cislo = int(input("Zadej cislo"))
if not cislo % 2:
    print(cislo, "je sude")
else:
    print(cislo, "je liche")

4 je sude

2. Je větší. Napište program, který zjistí a vypíše, které ze dvou zadaných čísel je větší.

a = int(input("Zadej první číslo"))
b = int(input("Zadej druhé číslo"))
if a > b:
    print(a, "je větší než", b)
elif a == b:
    print("čísla jsou stejná")
else:
    print(b, "je větší než", a)

6 je větší než 4

3. Je největší. Napište program, který zjistí a vypíše, které ze tří zadaných čísel je největší.

a = int(input("Zadej první číslo"))
b = int(input("Zadej druhé číslo"))
c = int(input("Zadej třetí číslo"))
if a >= b and a >= c:
    print(a, "je největší.")
elif b >= a and b >= c:
    print(b, "je největší.")
else:
    print(c, "je největší.")

7 je největší.

x = int(input("Zadej první číslo"))
y = int(input("Zadej druhé číslo"))
z = int(input("Zadej třetí číslo"))
print("nejvetsi je", max(x, y, z))

if x >= y and x >= z:
    print(x, "je nejvetsi (první číslo)")
if y >= x and y >= z:
    print(y, "je nejvetsi (druhé číslo)")
if z >= x and z >= y: 
    print(z, "je nejvetsi (třetí číslo)")

nejvetsi je 4
4 je nejvetsi (první číslo)
4 je nejvetsi (druhé číslo)
4 je nejvetsi (třetí číslo)

4. Seřaď. Napište program, který vypíše tři zadaná čísla v pořadí od největšího po nejmenší.

x = int(input("Zadej první číslo"))
y = int(input("Zadej druhé číslo"))
z = int(input("Zadej třetí číslo"))
if x >= y >= z:
    print(x, y, z)
elif x >= z >= y:
    print(x, z, y)
elif y >= x >= z:
    print(y, x, z)
elif y >= z >= x:
    print(y, z, x)
elif z >= x >= y:
    print(z, x, y)
else:
    print(z, y, x)

5 5 4

5. Trojúhelník. Napište program, který zjistí a vypíše, zda lze sestrojit trojúhelník zadaný pomocí tří délek stran.

a = int(input("Zadej stranu a"))
b = int(input("Zadej stranu b"))
c = int(input("Zadej stranu c"))
if (a + b > c) and (a + c > b) and (b + c > a):
    print("ano")
else:
    print("ne")

ano

a = float(input("zadej stranu a"))
b = float(input("zadej stranu b"))
c = float(input("zadej stranu c"))

if a > b and a > c and  b + c > a:
    print("ano, jde to")
elif b > c and b > a and  a + c > b:
    print("ano, jde to")
elif c > b and c > a and  a + b > c:
    print("ano, jde to")
else:
    print("ne, nejde to")

ne, nejde to

6. Test plnoletosti. Napište program, který se zeptá uživatele na věk a odpoví, zda je plnoletý.

Příkaz while – cyklus se vstupní podmínkou

Příkaz while je variantou cyklu, který umožňuje ověření libovolné podmínky. Obecná syntaxe vypadá takto:

while nějaká_podmínka:
    tělo_cyklu
    ...

K ověření podmínky dochází vždy před provedením příkazů z těla cyklu. Interpretace chování příkazu while tedy je: dokud platí podmínka, prováděj příkazy.

Příklad: následující program vypíše všechna čísla od 0 do 10 včetně:

# program vypíše všechna čísla od 0 do 5 včetně:
# zkuste si v pytutoru
n = 0
while n <= 5:
    print(n)
    n += 1

0
1
2
3
4
5

# print co místo odřádkování končí mezerou ... výpis na jedem řádek
print ("ahoj", end = " ")
print ("ahoj", end = " ")

ahoj ahoj 

# program vypíše všechna čísla od 0 do 10 včetně, výpis na jeden řádek:
n = 0
while n <= 10:
    print(n, end = " ")
    n += 1

0 1 2 3 4 5 6 7 8 9 10 

# program vypíše mocniny dvojky 2^0 ... 2^10:
n = 0
while n <= 10:
    print(2 ** n, end = " ")
    n += 1

1 2 4 8 16 32 64 128 256 512 1024 

# cykly a podmínky můžeme vnořovat:
# program vypíše jen sudá čísla z posloupnosti čísel od 0 do 10 (včetně)
n = 0
while n <= 10:
    if n % 2:
        print(n, end = " ")
    n += 1

1 3 5 7 9 

# cyklus můžeme ukončit příkazem break:
# zkuste si v pytutoru
n = 0
while n <= 10:
    if n == 2:
        break
    print(n, end = " ")
    n += 1

0 1 

# continue - okamžitě ukončí aktuální iteraci cyklu:
n = 0
while n <= 10:
    if n % 2:
        n += 1
        continue
    print(n, end = " ")
    n += 1

0 2 4 6 8 10 

# bez continue se snadno obejdeme (využijeme else):
n = 0
while n <= 10:
    if n % 2:
        n += 1
    else:
        print(n, end = " ")
        n += 1

0 2 4 6 8 10 

# while True + break
while True:
    x = input("uz je konec?")
    if x == "ano":
        break
    print("pokracuji")

pokracuji

pokracuji

pokracuji

# cyklus se neprovede ani jednou:
n = 20
while n <= 10:
    print(n, end = " ")
    n += 1
print("pokracuj")

pokracuj

# program se může tzv. zacyklit (pokud podmínku neuděláme správně)
n = 5
while n > 0:
    #print(n, end = " ")
    n += 1
print("pokracuj")

---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
Cell In[51], line 4
      1 n = 5
      2 while n > 0:
      3     #print(n, end = " ")
----> 4     n += 1
      5 print("pokracuj")

KeyboardInterrupt: 

7 + 4

11

# součet čísel od 0 do 10:
n = 0
soucet = 0
while n <= 10:
    #print(n, end=" ")
    soucet += n
    n += 1
print("soucet:", soucet)

soucet: 55

# počet sudých čísel mezi 0 a 10:
n = 0
pocet = 0
while n <= 10:
    if n % 2 == 0:
        #print(n, end=" ")
        pocet += 1
    n += 1
print("pocet:", pocet)

pocet: 6

Tip: Kliknutím na tlačítko pytutor v rozhraní JupyterLab se zobrazí grafická interpretace toho, co se v programu děje.

Příkaz for – cyklus s parametrem

Příkaz while je sice obecný cyklus (umožňuje ověřovat libovolnou podmínku), ale často je poměrně nešikovný, protože musíme sami zajistit správný přechod na následující iteraci. Alternativní příkaz for je užitečný v případech, kdy chceme opakovat příkazy pro předem známou sadu hodnot.

Obecná syntaxe příkazu for vypadá takto:

for parametry_cyklu in zdroj:
    tělo_cyklu

Parametr cyklu bývá většinou jen jeden. Může jich být i více, ale pak potřebujeme zdroj, který v každém kroku dodává příslušně velkou sadu hodnot.

Jako zdroj hodnot pro příkaz for může sloužit mnoho různých objektů, např. kontejnery a datové struktury, se kterými se seznámíme později. Dnes si ukážeme jen základní, ale velmi častý zdroj hodnot: funkci range, která představuje posloupnost celých čísel v určitém rozmezí. Chování funkce range se liší podle počtu (celočíselných!) argumentů, které jí předáme:

1. Zadáme-li jeden argument, zdroj představuje posloupnost celých čísel od nuly až po zadanou hodnotu, ale tu už ne. Zadáte-li proto jako argument nulu nebo nějaké záporné číslo, dostaneme prázdnou posloupnost. Následující program vypisuje čísla od 0 do 10 včetně:

for n in range(11):
    print(n)

0
1
2
3
4
5
6
7
8
9
10

# udělej něco pětkrát:
for n in range(5):
    print("ahoj")

ahoj
ahoj
ahoj
ahoj
ahoj

# program vypíše všechna čísla od 0 do 10 včetně:
for n in range(11):
    print(n, end = " ")

0 1 2 3 4 5 6 7 8 9 10 

# program vypíše mocniny dvojky 2^0 ... 2^10
for n in range(11):
    print(2 ** n, end = " ")

1 2 4 8 16 32 64 128 256 512 1024 

# cykly a podmínky můžeme do sebe vnořovat:
# program vypíše jen sudá čísla z intervalu od 0 do 10 (včetně)
for n in range(11):
    if n % 2:
        print(n, end = " ")

1 3 5 7 9 

2. Zadáme-li dva argumenty, zdroj představuje posloupnost celých čísel od hodnoty prvního argumentu po hodnotu druhého, ale hodnotu druhého už ne. Následující program vypisuje hodnoty od 7 do 10 včetně:

for n in range(7, 11):
    print(n, end = " ")

7 8 9 10 

# cyklus se neprovede ani jednou:
for n in range(11, 7):
    print(n, end = " ")

for n in range(2, 11, 3):
    print(n, end = " ")

2 5 8 

for n in range(22, 11, -1):
    print(n, end = " ")

22 21 20 19 18 17 16 15 14 13 12 

# cyklus se neprovede ani jednou:
for n in range(2, 11, -1):
    print(n, end = " ")

3. Zadáme-li tři argumenty, zdroj představuje posloupnost celých čísel od hodnoty prvního argumentu až po hodnotu druhého (jeho hodnotu už ne) s krokem zadaným ve třetím argumentu. Pro kladný krok bude posloupnost rostoucí, pro záporný bude klesající.

for n in range(10, 0, -3):
    print(n, end = " ")

10 7 4 1 

Příklady

1. Součet čísel pomocí for cyklu. Napište program, který sečte čísla od 1 do n (pomocí for cyklu).

# kontrola:
n = int(input("Zadej číslo:"))
součet = (n * (n + 1)) // 2
print("Součet čísel je", součet) 

Součet čísel je 5050

# a) pomoci for cyklu
# mezikrok
for i in range(1, n + 1):  # pozor, použijte jinou řídící proměnnou
    print(i, end = " ")

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 

# a) pomoci for cyklu: místo výpisu sčítám
součet = 0
for i in range(1, n + 1):  # pozor, použijte jinou řídící proměnnou
    součet += i
    
print("Součet čísel je", součet)

Součet čísel je 5050

# to same pomoci while cyklu

# b) totéž pomocí while cyklu
n = int(input("Zadej číslo:"))
součet = 0
i = 1
while i <= n:
    součet += i
    i += 1
print(součet) 

5050

2. Sudé-liché podruhé. Napište program, který bude pořád dokola žádat uživatele, aby zadal celé číslo, a poté vypíše, jestli je zadané číslo sudé nebo liché. Jakmile uživatel napíše "konec", tak program skončí.

s = input("Zadej cele cislo")
while s != "konec":
    n = int(s)
    if n % 2:
        print(n, "je liche")
    else:
        print(n, "je sude")
    s = input("Zadej cele cislo")

45 je liche

40 je sude

while True:
    s = input("Zadej cele cislo")
    if s == "konec":
        break
    n = int(s)
    if n % 2:
        print(n, "je liche")
    else:
        print(n, "je sude")

3. Načti a sečti čísla. Napište program, který postupně načítá čísla ze vstupu, dokud nepřijde prázdný řetězec "". Pak vypíše počet zadaných čísel a jejich součet.

soucet = 0
pocet = 0
while True:
    s = input("Zadej cislo")
    if s == "":
        break
    x = float(s)
    soucet += x
    pocet += 1

print(pocet, soucet)
    

2 47.3

4. Chci číslo z intervalu. Program-kecálek čte čísla od uživatele, dokud uživatel nezadá číslo z požadovaného intervalu. Pak mu poděkuje a vypíše počet neúspěšných pokusů.

a = 3
b = 4
pokusu = 0
print("Zadej cislo z intervalu (", a, ",",b, ")" )
while True:
    x = float(input("zadej cislo"))
    if a < x < b:
        print("Prima, zadal jsi číslo ", x, ", počet neúspěšných pokusů je ", pokusu)
        break
    pokusu += 1

Zadej cislo z intervalu ( 3 , 4 )

Prima, zadal jsi číslo  3.5 , počet neúspěšných pokusů je  4

5. Posloupnost. Napište program, který vypíše prvních n členů následující posloupnosti: 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 ...

# a) pro 5 clenu vypis 1 1 2 1 2 3 1 2 3 4 1 2 3 4 5
n = 5
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(j, end = " ")
    # print()

1 1 2 1 2 3 1 2 3 4 1 2 3 4 5 

# b) pro 5 clenu vypis 1 1 2 1 2
n = 5
pocet = 0
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(j, end = " ")
        pocet += 1
        if pocet == n:
            break
    if pocet == n:
            break

1 1 2 1 2