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

# poznámka k domácímu úkolu:
n = 12345678987654327789456432131
x = n // 2
x

6172839493827163894728216065

y = int(n / 2)
y

6172839493827164197082890240

x - y

-302354674175

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

Rekurzivní funkce je taková funkce, která volá sama sebe, a to buď přímo (f → f) nebo nepřímo (f → g → h → f). Použití rekurze může v určitých případech zjednodušit řešení dané úlohy.

Obecná struktura rekurzivní funkce se skládá z následujících částí:

1. základní případ: nejjednodušší úloha, kterou lze vyřešit přímo bez použití rekurze
2. rekurzivní volání: rozdělení velké úlohy na menší části a použití stejné funkce pro vyřešení těchto menších úloh
3. rekombinace: spojení výsledků menších úloh pro vyřešení původní velké úlohy

Rekurzivní funkce pro výpočet Fibonacciho čísel (je velmi neefektivní):

def fib(n):
    if n == 0:
        # ověření první počáteční podmínky
        return 0
    elif n == 1:
        # ověření druhé počáteční podmínky
        return 1
    else:
        # rekurzivní volání pro vyřešení menších úloh
        # rekombinace a vrácení finálního výsledku
        return fib(n - 2) + fib(n - 1)

print(fib(8))

21

Efektivnější implementaci s lineární složitostí můžeme dostat pomocí iteračního přístupu:

def fib_iterative(n):
    # nastavení počátečních hodnot
    term1 = 0
    term2 = 1

    # iterační výpočet
    while n > 0:
        new = term1 + term2
        term1 = term2
        term2 = new
        n -= 1

    return term1

print(fib_iterative(8))

21

Kontejnery

Kontejner je libovolný objekt, který představuje datovou strukturu obsahující libovolný počet jiných objektů. Kontejnery poskytují způsob uchování několika objektů a přístup k nim.

Python obsahuje několik vestavěných kontejnerů, které jsou rozděleny do několika kategorií podle jejich vlastností:

Číselné typy a hodnotu None jsme viděli v minulých dílech. Poté v diagramu následují posloupnosti, zejména seznamy (list), n-tice (tuple) a stringy (str). V samostatných kategoriích jsou množinové typy (set a frozenset) a zobrazení neboli slovníky (dict). Pro úplnost jsou v diagramu kategorizace objektů i volatelné objekty (sem patří např. funkce) a moduly.

Zápis a vytváření základních kontejnerů

Základní kontejnery mají následující význam:

• string neboli textový řetězec je posloupnost znaků, v Pythonu reprezentovaná třídou str. Stringy zapisujeme typicky mezi dvojici uvozovek ("string" nebo 'string'). Podrobnosti týkající se zápisu stringů si ukážeme na příštím cvičení.
• seznam je modifikovatelná (mutable) posloupnost libovolných objektů, v Pythonu reprezentovaná třídou list.
• n-tice je nemodifikovatelná (immutable) posloupnost libovolných objektů, v Pythonu reprezentovaná třídou tuple.
• množina (třída set) je datová struktura obsahující objekty, pro které není určené jejich vzájemné pořadí.
• slovník (třída dict) je datová struktura, která představuje zobrazení z množiny klíčů (keys) na libovolné hodnoty (values).

Kromě slovníků můžeme ostatní kontejnery mezi sebou jednoduše převádět pomocí příslušných funkcí (str, list, tuple, set):

# ukázka: seznam čísel, jmen, prázdný, různých prvků + print 

# seznam prvků ... datový typ list
seznam_cisel = [1, 6, 56, 0, -1, 1, 6]
seznam_jmen = ["Anna","Bob","Cilka"]
prazdny_seznam = []

# objekty v seznamu nemusejí mít stejný datový typ:
seznam_ruznych_prvku = [True, 1, 3.3, 1+2j, "Tomáš", [1]]

# výpis:
print(seznam_cisel)
print(seznam_jmen)
print(prazdny_seznam)
print(seznam_ruznych_prvku)

[1, 6, 56, 0, -1, 1, 6]
['Anna', 'Bob', 'Cilka']
[]
[True, 1, 3.3, (1+2j), 'Tomáš', [1]]

# ukázka: type, isinstance
type(seznam_ruznych_prvku)

list

# ukázka: type, isinstance
isinstance(seznam_ruznych_prvku, list)

True

# ukázka: další typy kontejnerů + print + type
a = 0
b = "A"
seznam  = [a, b, 3]
ntice   = (a, b, 3)
množina = {a, b, 3}
string = "ahoj lidi :)  "

print("seznam: ", seznam,  type(seznam))
print("ntice:  ", ntice,   type(ntice))
print("množina:", množina, type(množina))
print("string: ", string,  type(string))

seznam:  [0, 'A', 3] <class 'list'>
ntice:   (0, 'A', 3) <class 'tuple'>
množina: {0, 3, 'A'} <class 'set'>
string:  ahoj lidi :)   <class 'str'>

# ukázka: převod kontejnerů mezi sebou
seznam  = [a,  b, 3]
ntice   = tuple(seznam)
množina = set(seznam)
seznam  = list(množina)

print("seznam: ", seznam,  type(seznam))
print("ntice:  ", ntice,   type(ntice))
print("množina:", množina, type(množina))

seznam:  [0, 3, 'A'] <class 'list'>
ntice:   (0, 'A', 3) <class 'tuple'>
množina: {0, 3, 'A'} <class 'set'>

# konverze z textového řetězce: 
string = "Hello, world!"
seznam = list(string)
ntice = tuple(string)
množina = set(string)

print("string:", string)
print("seznam:", seznam)
print("ntice:", ntice)
print("množina:", množina)

string: Hello, world!
seznam: ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']
ntice: ('H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!')
množina: {'w', 'H', 'd', 'o', '!', 'e', ',', 'l', 'r', ' '}

# ukázka konverze na string ... je to jinak!
string = "Hello, world!"
seznam = list(string)
mnozina = set(string)
print("seznam:", seznam)
print("množina:", mnozina)
str(mnozina)

seznam: ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']
množina: {'d', ',', 'w', 'H', 'e', 'r', ' ', 'o', '!', 'l'}

"{'d', ',', 'w', 'H', 'e', 'r', ' ', 'o', '!', 'l'}"

str(seznam)

"['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']"

Předchozí výstup nám napovídá, jakým způsobem lze zapsat určitý kontejner přímo v kódu. Objekty v ostatních kontejnerech nemusí být jen znaky a navíc všechny objekty v daném kontejneru nemusí mít stejný typ:

a = 0
b = "A"
seznam = [a, 1, b, "hello"]
a = 2  # změní se hodnota proměnné `a`, ale v seznamu zůstane původní hodnota
ntice = (a, b, 1, 2)
množina = {a, b, 1, 2}

print("seznam:", seznam)
print("ntice:", ntice)
print("množina:", množina)

seznam: [0, 1, 'A', 'hello']
ntice: (2, 'A', 1, 2)
množina: {1, 2, 'A'}

Poznámka: V tomto cvičení se budeme soustředit na posloupnosti, tedy seznamy a n-tice. Množiny a slovníky probereme podrobně na příštím cvičení.

Základní operace s kontejnery

Všechny kontejnery poskytují dvě základní operace:

1. Testování, jestli kontejner obsahuje danou hodnotu. Testovací výraz obsahuje operátor in, případně not in, a vrací vždy hodnotu True nebo False:

print(1 in [0, 1, 2])
print(1 not in [0, 1])

True
False

# ukázka: použití v podmínce
t = (1, 7, 9)
if 1 in t:
    print("je tam")
if 10 not in t:
    print("neni tam")

je tam
neni tam

2. Iterování: každý kontejner lze použít jako zdroj dat v příkazu for. Zde opět vystupuje klíčové slovo in, ale v jiném významu: for hodnota in kontejner. Podle typu kontejneru mají iterované prvky buď určité nebo nespecifikované pořadí.

seznam = [0, 1, "A", "hell0"]
for x in seznam:
    print(x)
print(seznam)

0
1
A
hellp
[0, 1, 'A', 'hellp']

Kromě těchto základních operací má každý typ kontejneru své vlastní rozhraní, které jej odlišuje od ostatních. Proto si postupně probereme všechny zmíněné kontejnery.

# ukázka: počet prvků kontejneru: len(kontejner)
L = len(seznam)
L

4

Indexování posloupností

Předpokládejme, že máme seznam my_list definovaný následovně:

my_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
my_list[0]

10

Pro přístup k jednotlivým prvkům seznamu můžeme použít operátor [], např. my_list[i], kde i je celočíselná hodnota určující pořadí daného prvku. Přípustné hodnoty indexu i jsou znázorněny na tomto obrázku:

Tento způsob indexování funguje stejně pro všechny typy posloupností (list, tuple, str, atd). Navíc pro všechny posloupnosti můžeme použít funkci len, která vrací aktuální počet prvků v daném kontejneru. Např. pokud máme L = len(my_list), ve výrazu my_list[i] můžeme za i dosadit libovolnou hodnotu z -L, -L+1, -L+2, ..., 0, 1, 2, ..., L-2, L-1.

# Ukázka navíc:
my_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
L = len(my_list)
print(L)

# prvni prvek:
print(my_list[0])
print(my_list[-10])
print(my_list[-L])

# posledni prvek:
print(my_list[L-1])
print(my_list[-1])
print(my_list[9])

# pátý prvek
print(my_list[4])

# změním pátý prvek
my_list[4] = 9000
print(my_list)

10
10
10
10
100
100
100
50
[10, 20, 30, 40, 9000, 60, 70, 80, 90, 100]

# Ukázka navíc:
# pro n-tici:
t = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100)
L = len(t)
print(L)

print(t[4])

# chyba:
t[4] = 10000

10
50

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[29], line 9
      7 print(t[4])
      8 # chyba:
----> 9 t[4] = 10000

TypeError: 'tuple' object does not support item assignment

Známe již dva způsoby iterování přes prvky seznamu:

1. for value in my_list: – my_list slouží přímo jako zdroj dat pro příkaz for, v proměnné value dostáváme postupně hodnoty uložené v seznamu.
2. for i in range(len(my_list)): – funkce len zjistí počet prvků v seznamu a funkce range představuje posloupnost všech nezáporných hodnot, které můžeme použít pro indexování seznamu my_list. Všimněte si, že funkce range příhodně vynechává koncovou hodnotu len(my_list).

# ukázka navíc:
t = (10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

# dvě možnosti průchodu:
# iterace přes prvky
for x in t:
    print(x, end = " ")
print()

# iterace pres indexy
L = len(t)
for i in range(L):
    print(t[i], end = " ")

10 20 30 40 50 60 70 80 90 100 
10 20 30 40 50 60 70 80 90 100 

# ukázka navíc:
# výpis pozpátku (pomocí kladných indexů):
for i in range(L-1, -1, -1):
    print(t[i], end = " ")
print()

# výpis pozpátku (pomocí záporných indexů):
for i in range(1, L+1):
    print(t[-i], end = " ")

100 90 80 70 60 50 40 30 20 10 
100 90 80 70 60 50 40 30 20 10 

První způsob iterování je snadněji pochopitelný a vhodný pro případy, kdy potřebujeme zpracovat všechny hodnoty z určitého seznamu stejným způsobem. Druhý způsob je hůře čitelný, ale hodí se v případech, kdy potřebujeme modifikovat hodnoty uložené v modifikovatelné (mutable) posloupnosti, což není možné prvním způsobem. Např. pokud bychom chtěli všechny hodnoty v seznamu my_list zmenšit o 1:

# změna hodnoty v cyklu:
for i in range(len(my_list)):
    my_list[i] = my_list[i] - 1

print(my_list)

# ukázka navíc:
# zde se hodnota nezmění:
my_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
for x in my_list:
    x = x - 1

print(my_list)

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Slicing (výřez)

Velmi příjemným syntaktickým rozšířením indexování jednotlivých prvků posloupnosti je slicing (česky vykrajování). Při něm se v hranatých závorkách za názvem posloupnosti zadají dva indexy oddělené dvojtečkou, např. my_list[i:j], a výsledkem výrazu je podposloupnost daná těmito indexy:

• index i představuje počáteční index podposloupnosti
• index j představuje index „po-posledního“ prvku podposloupnosti

Není-li zadán první index, dosadí se nula, a není-li zadán druhý index, dosadí se délka posloupnosti. Bude-li proto v indexových závorkách pouze dvojtečka, výsledná podposloupnost bude celá posloupnost.

Slicing je názorně ukázán v následujícím příkladu, kde jako vstupní posloupnost používáme proměnnou python (zde string, ale stejný princip je možné aplikovat pro všechny posloupnosti):

# vstupní posloupnost
python = "Python"

# ukázky operace slicing (mezery uvnitř hranatých závorek nehrají roli)
print(python[ 2: 5])  # "tho"
print(python[ 2:  ])  # "thon"
print(python[  : 2])  # "Py"
print(python[ 2:-1])  # "tho"
print(python[-4:-1])  # "tho"
print(python[  :-2])  # "Pyth"
print(python[-2:  ])  # "on"
print(python[  :  ])  # "Python" ... kopie

tho
thon
Py
tho
tho
Pyth
on
Python

# ukázka navíc ... krok
print(python[0 : 7: 2])  
print(python[ : : -1])  

['P', 't', 'o']
['n', 'o', 'h', 't', 'y', 'P']

# ukázka navíc ... krok
python = list(python)
print(python[ : : -1])  # "Python"

['n', 'o', 'h', 't', 'y', 'P']

Tip: V případě operace slicing je vhodné si představit, že indexy nepředstavují pozice jednotlivých prvků posloupnosti, ale pozice mezer mezi nimi. Viz následující tabulku:

   0   1   2   3   4   5    <-- Indexování od počátku
  -6  -5  -4  -3  -2  -1    <-- Indexování od konce
 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6  <-- Slicing od počátku
-6  -5  -4  -3  -2  -1      <-- Slicing od konce

Dále si podrobněji ukážeme práci se seznamy a n-ticemi. Stringům se budeme podrobně věnovat na příštím cvičení, protože mají velmi odlišné rozhraní.

Seznamy a n-tice

Seznam (list) a n-tice (tuple) jsou datové struktury představující posloupnosti, které se ale zásadním způsobem liší:

• seznam je modifikovatelná (mutable) datová struktura – do seznamu můžeme přidávat nové objekty a nebo z něj objekty odebírat
• n-tice je nemodifikovatelná (immutable) datová struktura – nelze přidat nebo odebrat objekt v existující n-tici (jediný způsob jak změnit n-tici je vytvořit nový objekt)

Seznam se často používá v algoritmech, kde je potřeba si průběžně ukládat nějaké hodnoty a později se k nim vracet. Často začínáme s prázdným seznamem, do kterého postupně přidáváme prvky pomocí metod append (přidání na konec) nebo insert (vložení na zadanou pozici):

# ukázka navíc: append, insert samostatně
# prázdný seznam
seznam = []

# výpočet prvků
for i in range(10):
    seznam.append(i)
    #seznam.insert(0, i)

# výpis seznamu
print(seznam)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# ukázka navíc: append, insert samostatně
# prázdný seznam
seznam = []

# výpočet prvků
for i in range(10):
    #seznam.append(i)
    seznam.insert(0, i)

# výpis seznamu
print(seznam)

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# prázdný seznam
seznam = []

# výpočet prvků
for i in range(10):
    if i % 2 == 0:
        # sudé číslo vložíme na konec
        seznam.append(i)
    else:
        # liché číslo vložíme na začátek
        seznam.insert(0, i)

# výpis seznamu
print(seznam)

[9, 7, 5, 3, 1, 0, 2, 4, 6, 8]

Úplný přehled metod použitelných pro seznam (resp. každou modifikovatelnou posloupnost) je možné najít v dokumentaci.

# ukázka navíc: operace se seznamy:
s = [1, 2, 5]
t = ["a", "b", "c"]
# operátor + ... zřetězení seznamů
u = s + t
print(u)

# metoda extend
u.extend(t)
print(u)

# operátor *
v = s * 3
print(v)

[1, 2, 5, 'a', 'b', 'c']
[1, 2, 5, 'a', 'b', 'c', 'a', 'b', 'c']
[1, 2, 5, 1, 2, 5, 1, 2, 5]

# ukázka navíc: operace se seznamy:
s = [1, 2, 5, 2, 3, 4, 6, 5]

# smazání prvku podle hodnoty (první výskyt)
s.remove(5)
print(s)

# smazani prvku na indexu nebo výřezu
del s[4]
print(s)

del s[2 :]
print(s)

[1, 2, 2, 3, 4, 6, 5]
[1, 2, 2, 3, 6, 5]
[1, 2]

# vložení prvku na index (prvky od indexu dál se posunou)
s = [1, 2, 5, 2, 3, 4, 6, 5]
print(s)
s.insert(3, 8)
print(s)

# změna prvku na indexu
s[3] = 80
print(s)

# vyjmi prvek (poslední / na indexu)
x = s.pop()
print(s, x)

x = s.pop(3)
print(s, x)

[1, 2, 5, 2, 3, 4, 6, 5]
[1, 2, 5, 8, 2, 3, 4, 6, 5]
[1, 2, 5, 80, 2, 3, 4, 6, 5]
[1, 2, 5, 80, 2, 3, 4, 6] 5
[1, 2, 5, 2, 3, 4, 6] 80

# vytvoření nového odkazu na seznam
s = [1, 2, 5, 2, 3, 4, 6, 5]
t = s
s[0] = 100
print(t, s)

[100, 2, 5, 2, 3, 4, 6, 5] [100, 2, 5, 2, 3, 4, 6, 5]

# kopirovani seznamu 
s = [1, 2, 5, 2, 3, 4, 6, 5]
t = s.copy()
s[0] = 100
print(t, s)

[1, 2, 5, 2, 3, 4, 6, 5] [100, 2, 5, 2, 3, 4, 6, 5]

# kopirovani seznamu 
s = [1, 2, 5, 2, 3, 4, 6, 5]
t = s[ : ]
s[0] = 100
print(t, s)

[1, 2, 5, 2, 3, 4, 6, 5] [100, 2, 5, 2, 3, 4, 6, 5]

# kopirovani seznamu 
s = [1, 2, 5, 2, 3, 4, 6, 5]
t = list(s)
s[0] = 100
print(t, s)

[1, 2, 5, 2, 3, 4, 6, 5] [100, 2, 5, 2, 3, 4, 6, 5]

# otočení seznamu (na místě)
s = [1, 2, 5, 2, 3, 4, 6, 5]
x = s.reverse()
print(s, x)

# setřídění seznamu (na místě)
x = s.sort()
print(s, x)

[5, 6, 4, 3, 2, 5, 2, 1] None
[1, 2, 2, 3, 4, 5, 5, 6] None

# vytvořím nový, setříděný seznam
s = (1, 2, 5, 2, 3, 4, 6, 5)
t = sorted(s)
print(s, t)

(1, 2, 5, 2, 3, 4, 6, 5) [1, 2, 2, 3, 4, 5, 5, 6]

N-tice

ntice = (1, 2, 3)
print(ntice, type(ntice))

(1, 2, 3) <class 'tuple'>

# není jednotice:
ntice = (1)
print(ntice, type(ntice))

1 <class 'int'>

# je jednotice:
ntice = (1,)
print(ntice, type(ntice))

(1,) <class 'tuple'>

# pro seznam je to jednoduché:
seznam = []
print(seznam, type(seznam))

seznam = [1]
print(seznam, type(seznam))

seznam = [1, 2]
print(seznam, type(seznam))

[] <class 'list'>
[1] <class 'list'>
[1, 2] <class 'list'>

Naopak n-tice (tuple) se běžně používá tam, kde modifikace posloupnosti není potřeba. Jeden z typických případů jsou funkce, které vrací více než jednu hodnotu, např. funkce divmod, která vrací dvojici (tuple o dvou prvcích) hodnot, z nichž první je celočíselný podíl a druhá je zbytek po celočíselném dělení:

dvojice = divmod(11, 3)
print(dvojice)

...

(3, 2)

K jednotlivým prvkům dvojice se dostaneme pomocí indexovacího operátoru: dvojice[0] je první prvek a dvojice[1] je druhý prvek. Protože počet prvků v n-tici nelze změnit a jednotlivé prvky je často vhodné pojmenovat pro větší přehlednost kódu, umožňuje syntaxe jazyka Python tzv. rozbalování (unpacking):

# definice trojice
point = (1, 2, 3)

# přístup k prvkům přes indexy
x = point[0]
y = point[1]
z = point[2]
print(x, y, z)

# rozbalení
x, y, z = point
print(x, y, z)

1 2 3
1 2 3

# ukázka navíc
# zabalení a rozbalení ntice: kulaté závorky mohu vynechat
point = (1, 2, 3)
(x, y, z) = point
print(x, y, z)

point = 1, 2, 3
x, y, z = point
print(x, y, z)

1 2 3
1 2 3

Při rozbalování je potřeba zajistit, že počet proměnných definovaných na levé straně odpovídá počtu prvků v n-tici, jinak dojde k chybě ValueError. Rozbalování je možné provést obecně pro libovolnou posloupnost, ale právě kvůli zajištění odpovídajícího počtu prvků je toto použití nejtypičtější pro n-tice.

A jak vrátit více hodnot z námi definované funkce? Stačí v příkazu return zadat tuple, např. return (a, b, c) nebo ekvivalentně return a, b, c.

# ukázka navíc: vlastní funkce
def komplexni_cislo(z):
    return z.real, z.imag
    
z = 2 - 3j
d = komplexni_cislo(z)
print(d)
r, i = komplexni_cislo(z)
print(r, i)

(2.0, -3.0)
2.0 -3.0

Příklady

1. Napište funkci, která vezme vstupní posloupnost a vrátí seznam, ve kterém jsou všechny prvky posloupnosti uspořádané pozpátku.

# pomocí iterace přes prvky (for-cyklus)
def pozpatku(posloupnost):
    seznam = []
    for x in posloupnost:
        seznam.insert(0, x)
    return seznam

# pomocí iterace odzadu přes záporné indexy (for-cyklus)
def pozpatku(posloupnost):
    seznam = []
    for i in range(1, len(posloupnost) + 1):
        seznam.append(posloupnost[-i])
    return seznam

# pomocí iterace odzadu přes kladné indexy (for-cyklus)
def pozpatku(posloupnost):
    seznam = []
    for i in range(len(posloupnost) - 1, -1, -1):
        seznam.append(posloupnost[i])
    return seznam

# pomocí výřezů
def pozpatku(posloupnost):
    return list(posloupnost[ : : -1])

# pomocí metody pro seznamy
def pozpatku(posloupnost):
    seznam = list(posloupnost)
    seznam.reverse()
    return seznam

# test pro různé typy posloupností
seznam = [1, 2, 3, 3, 4, 10]
vysledek = pozpatku(seznam)
print(vysledek, seznam)
assert vysledek == [10, 4, 3, 3, 2, 1]

seznam = (1, 2, 3, 3, 4, 10)
vysledek = pozpatku(seznam)
print(vysledek)

seznam = "abcdef"
vysledek = pozpatku(seznam)
print(vysledek)

2. Napište funkci, která vrátí medián vstupní posloupnosti čísel.

def median(posloupnost):
    L = len(posloupnost)
    if L % 2 == 1:
        return posloupnost[L // 2]
    else:
        return (posloupnost[L // 2] + posloupnost[L // 2 - 1]) / 2

seznam = [1, 2, 3, 4, 5]
print(median(seznam))

assert median([1, 2, 3]) == 2
assert median([1, 2]) == 1.5

3

3. Napište funkci, která přečte vstupní posloupnost přirozených čísel a vrátí seznam obsahující všechna čísla, která nejsou dělitelná 2 ani 3, v pořadí odpovídajícím vstupu.

def vyber_cisla(posloupnost):
    seznam = []
    for x in posloupnost:
        if x % 2 != 0 and x % 3 != 0 :
            seznam.append(x)
    return seznam
    
print(vyber_cisla([1, 2, 3, 4, 5, 7, 4, 3, 2, 1]))

assert vyber_cisla([1, 2, 3, 4, 5, 7, 4, 3, 2, 1]) == [1, 5, 7, 1]

[1, 5, 7, 1]

4. Napište funkci, která vrátí seznam všech dělitelů zadaného přirozeného čísla seřazený od nejmenšího po největší.

def delitele(n):
    ...

assert delitele(24) == [1, 2, 3, 4, 6, 8, 12, 24]

5. Napište funkci, která vrátí seznam prvočísel seřazený od největšího po nejmenší, jejichž součin se rovná vstupnímu přirozenému číslu.

def primes(n):
    ...

assert primes(72) == [3, 3, 2, 2, 2]

6. Napište funkci, která pomocí Eratosthenova síta najde všechna prvočísla menší nebo rovna $n$.

# vytvářím seznam všech čísel od 2 do 11:
s = []
for i in range(2, 11):
    s.append(i)
s

[2, 3, 4, 5, 6, 7, 8, 9, 10]

# vytvářím seznam všech čísel od 2 do 11:
s = list(range(2, 11))
s

[2, 3, 4, 5, 6, 7, 8, 9, 10]

# násobky dvojky
for i in range(2, 11, 2):
    print(i, end = " ")

2 4 6 8 10 

# násobky trojky
for i in range(3, 11, 3):
    print(i, end = " ")

3 6 9 

# násobky čtyřky
for i in range(4, 11, 4):
    print(i, end = " ")

4 8 

# odstrašující příklad:
s = []
s is []

False

# odstrašující příklad: nikdy neměňme strukturu seznamu "pod rukama" během iterace přes prvky
s = [1, 3, 5]
for x in s: # nesmaže všechny prvky!
    s.remove(x)
s

[3]

def eratosthenes(n):
    cisla = list(range(2, n+1))
    prvocisla = []
    while cisla != []:
        p = cisla[0]
        prvocisla.append(p)
        for i in range(p, n+1, p):
            if i in cisla:
                cisla.remove(i)
    return prvocisla 

assert eratosthenes(11) == [2, 3, 5, 7, 11]

7. Napište funkci, která vypíše $n$ řádků Pascalova trojúhelníku. Vytvořte pomocnou funkci, která spočte nový řádek na základě předchozího.

def next_row(row):
    ...
    
def pascal(n):
    ...