# ---
# jupyter:
#   jupytext:
#     text_representation:
#       extension: .py
#       format_name: light
#       format_version: '1.5'
#       jupytext_version: 1.14.4
#   kernelspec:
#     display_name: Python 3
#     language: python
#     name: python3
# ---

# + [markdown] slideshow={"slide_type": "slide"}
# # Feedback k domácím projektům

# + [markdown] slideshow={"slide_type": "slide"}
# ## Zvířátka
# -

# Najdi chyby, nejasnosti či nepřesnosti v tomto kódu:

# +
zvirata = [ "pes", "kočka", "králík", "had", "ježek"]
znak = "k"

def pismeno(jmeno):
    for i in range(5):
        if znak in jmeno[i][0]:
            print(jmeno[i])
    return

pismeno(zvirata)

# + [markdown] slideshow={"slide_type": "slide"}
# Takto by to mohlo vypadat přehlednější a pochopitelnější

# +
zvirata = [ "pes", "kočka", "králík", "had", "ježek"]

def s_prvnim_pismenem(seznam_zvirat, pismeno):
    for zvire in seznam_zvirat:
        if zvire.startswith(pismeno):
            print(zvire)

s_prvnim_pismenem(zvirata, 'k')


# + [markdown] slideshow={"slide_type": "slide"}
# Další podobná funkce:

# +
def kratke(jmeno = zvirata):
    for i in range(len(jmeno)):
        if len(jmeno[i]) < 5:
            print(jmeno[i])
        else:
            print(end = "")
    return jmeno

kratke(zvirata)


# + [markdown] slideshow={"slide_type": "slide"}
# A její přehlednější varianta:

# +
def kratke(seznam_zvirat):
    for jmeno in seznam_zvirat:
        if len(jmeno) < 5:
            print(jmeno)

kratke(zvirata)


# + [markdown] slideshow={"slide_type": "slide"}
# Je možné tuto funkci zkrátit a zjednodušit?
# -

def overeni(seznam):
    "ověří, zda je zadané slovo v seznamu a vrátí True/False"
    otazka = input("Zadej název zvířete, jež chceš ověřit: ")
    if otazka in seznam:
        return True
    else:
        return False


# + [markdown] slideshow={"slide_type": "slide"}
# Ano, je to možné
# -

def overeni(seznam):
    "ověří, zda je zadané slovo v seznamu a vrátí True/False"
    otazka = input("Zadej název zvířete, jež chceš ověřit: ")
    return otazka in seznam


# + [markdown] slideshow={"slide_type": "slide"}
# ## Básnička

# + [markdown] slideshow={"slide_type": "slide"}
# ### Obrácené pořadí veršů

# +
with open("static/basnicka.txt", encoding="utf-8") as soubor_s_basnickou:
    basnicka = soubor_s_basnickou.read()

seznam_versu = basnicka.split("\n")  # Rozdělí básničku na jednotlivé verše (řádky) [seznam]
seznam_versu.reverse()  # Obrátí pořadí veršů v seznamu
obracena_basnicka = "\n".join(seznam_versu)  # Složí zpět seznam na řetězec a mezi verše vloží \n
print(obracena_basnicka)

# + slideshow={"slide_type": "slide"}
with open("static/basnicka.txt", encoding="utf-8") as soubor_s_basnickou:
    seznam_versu = soubor_s_basnickou.readlines()

for vers in seznam_versu[::-1]:
    print(vers, end="")

# + [markdown] slideshow={"slide_type": "slide"}
# ### Obrácené pořadí slov ve verších

# + slideshow={"slide_type": "slide"}
with open("static/basnicka.txt", encoding="utf-8") as soubor_s_basnickou:
    basnicka = soubor_s_basnickou.read()

seznam_versu = basnicka.split("\n")  # Rozdělí básničku na jednotlivé verše (řádky) [seznam]

nova_basnicka = []  # Seznam pro novou básničku, která obrácením pořadí slov vznikne

for vers in seznam_versu:  # Pro každý verš v originální básničce
    slova = vers.split()  # Rozdělí verš na slova [seznam]
    slova.reverse()  # Obrátí pořádí slov
    novy_vers = " ".join(slova)  # Spojí obrázená slova zpět do řetězce
    nova_basnicka.append(novy_vers)  # Přidá nový verš do nové básničky

obracena_basnicka = "\n".join(nova_basnicka)  # Složí zpět seznam na řetězec a mezi verše vloží \n
print(obracena_basnicka)

# + slideshow={"slide_type": "slide"}
with open("static/basnicka.txt", encoding="utf-8") as soubor_s_basnickou:
    seznam_versu = soubor_s_basnickou.readlines()

for i, vers in enumerate(seznam_versu):
    slova = vers.split()
    slova.reverse()
    seznam_versu[i] = " ".join(slova)

print("\n".join(seznam_versu))

# + [markdown] slideshow={"slide_type": "slide"}
# ### Obrácené pořadí slok

# + slideshow={"slide_type": "slide"}
with open("static/basnicka.txt", encoding="utf-8") as soubor_s_basnickou:
    basnicka = soubor_s_basnickou.read()

seznam_slok = basnicka.split("\n\n")  # Rozdělí básničku na jednotlivé sloky [seznam]
seznam_slok.reverse()
basnicka = "\n".join(seznam_slok)
print(basnicka)

# + [markdown] slideshow={"slide_type": "slide"}
# ### Slova v náhodném pořadí (Mr. Yoda style)

# + slideshow={"slide_type": "slide"}
from random import shuffle

with open("static/basnicka.txt", encoding="utf-8") as soubor_s_basnickou:
    seznam_versu = soubor_s_basnickou.readlines()

for i, vers in enumerate(seznam_versu):
    slova = vers.split()
    shuffle(slova)
    seznam_versu[i] = " ".join(slova)

print("\n".join(seznam_versu))

# + [markdown] slideshow={"slide_type": "slide"}
# ## Funkce jako stavební blok programu
# -

# Takto použitá funkce situaci spíše komplikuje, než aby něčemu pomohla.

# + slideshow={"slide_type": "-"}
zvirata = ['had', 'andulka', 'pes', 'kočka', 'králík']
dvojice = []
vysledek = []

def razeni_had(seznam1, seznam2, seznam3):
    '''seřadí výchozí seznam1 podle abecedy, ale bude ignorovat první písmeno'''
    for slovo in seznam1:
        seznam2.append([slovo[1:], slovo])
    seznam2.sort()
    for item in seznam2:
        seznam3.append(item[1])
    seznam3

razeni_had(zvirata, dvojice, vysledek)
print(vysledek)

# + [markdown] slideshow={"slide_type": "slide"}
# Co se asi stane, když takovou funkci zavoláme vícekrát?

# + slideshow={"slide_type": "-"}
zvirata = ['had', 'andulka', 'pes', 'kočka', 'králík']
dvojice = []
vysledek = []

def razeni_had(seznam1, seznam2, seznam3):
    '''seřadí výchozí seznam1 podle abecedy, ale bude ignorovat první písmeno'''
    for slovo in seznam1:
        seznam2.append([slovo[1:], slovo])
    seznam2.sort()
    for item in seznam2:
        seznam3.append(item[1])
    seznam3

razeni_had(zvirata, dvojice, vysledek)
print(vysledek)
razeni_had(zvirata, dvojice, vysledek)
print(vysledek)


# + [markdown] slideshow={"slide_type": "slide"}
# ## Ověření, že funkce funguje
# -

# Nejsnazší je funkci prostě spustit s různými argumenty a podívat se, zda dělá to, co by dělat měla.

# + slideshow={"slide_type": "slide"}
def absolutni_soucet(a, b):
    if a < 0:
        a = -a
    if b < 0:
        b = -b
    return a + b


# + slideshow={"slide_type": "-"}
print(absolutni_soucet(1, 2))
print(absolutni_soucet(100, 200))
print(absolutni_soucet(-1, -2))
print(absolutni_soucet(-1, 2))
print(absolutni_soucet(100, -2))

# + [markdown] slideshow={"slide_type": "slide"}
# ## List comprehensions
# -

# Jedná se o zápis s Pythonu s jehož pomocí se dají jednoduše vytvářet seznamy.

# + slideshow={"slide_type": "-"}
seznam_mocnin = []

for x in range(10):
    seznam_mocnin.append(x ** 2)

seznam_mocnin

# + slideshow={"slide_type": "slide"}
[x for x in range(10)]

# + slideshow={"slide_type": "slide"}
[x**2 for x in range(10)]

# + slideshow={"slide_type": "slide"}
[x**2 for x in range(10) if x % 2 == 0]

# + slideshow={"slide_type": "slide"}
[(x, x**2) for x in range(10)]

# + slideshow={"slide_type": "slide"}
[[y for y in range(3)] for x in range(10)]


# + [markdown] slideshow={"slide_type": "slide"}
# ## Tabulka s hracím polem

# + [markdown] slideshow={"slide_type": "slide"}
# ### Řešení 1
# -

def vytvor_tabulku():
    zap_tabulka = []

    for rada_x in '.', '.', '.', '.', '.', '.', '.', '.', '.', '.':
        radek = []
        for rada_y in '.', '.', '.', '.', '.', '.', '.', '.', '.', '.':
            radek.append(rada_y)
        zap_tabulka.append(radek)
    return zap_tabulka


# + [markdown] slideshow={"slide_type": "slide"}
# ### Řešení 2
# -

def vytvor_prazdne_herni_pole(r,s):
    seznam_radku = []
    for a in range(r):
        radek = ["."]
        for b in range(s-1):
            radek.append(".")
        seznam_radku.append(radek)
    return seznam_radku


# + [markdown] slideshow={"slide_type": "slide"}
# ### Lepší řešení
# -

def vytvor_tabulku(velikost):
    seznam_radku = []
    for a in range(velikost):
        radek = []
        for b in range(velikost):
            radek.append(".")
        seznam_radku.append(radek)
    return seznam_radku


# + [markdown] slideshow={"slide_type": "slide"}
# ### Lepší a krátké řešení
# -

def vytvor_tabulku(velikost):
    seznam_radku = []
    for a in range(velikost):
        radek = ["."] * velikost
        seznam_radku.append(radek)
    return seznam_radku


# + [markdown] slideshow={"slide_type": "slide"}
# ### Krátké řešení (s pomocí list comprehensions)
# -

def vytvor_tabulku(velikost):
    tabulka = []
    for x in range(velikost):
        radek = ['.' for x in range(velikost)]
        tabulka.append(radek)
    return tabulka


# + [markdown] slideshow={"slide_type": "slide"}
# ### Nejkratší řešení (je nejlepší?)
# -

def vytvor_tabulku(velikost):
    return [list('.' * velikost) for x in range(velikost)]


# + [markdown] slideshow={"slide_type": "slide"}
# ### Je vytvoření kompletní tabulky se všemi hracími políčky vážně potřeba?

# + [markdown] slideshow={"slide_type": "slide"}
# ## Had

# + slideshow={"slide_type": "slide"}
def velikost_hraciho_pole():
    """Zjistí od uživatele rozumnou velikost herního pole"""
    while True:
        odpoved = input('Zadej velikost pole pro hada: ')
        try:
            velikost = int(odpoved)
        except ValueError:
            print('Velikost musí být celé číslo')
        else:
            if velikost > 5:
                break
            else:
                print('Pole musí být rozumně veliké!')

    return velikost


# + slideshow={"slide_type": "slide"}
def vykresli_mapu(velikost, had, ovoce):
    """Vykreslí herní mapu s ovocem a hadem na správných místech"""
    for x in range(velikost):
        for y in range(velikost):
            if (x, y) in had:
                print('X', end=' ')
            elif (x, y) in ovoce:
                print('?', end=' ')
            else:
                print('.', end=' ')
        print()


# + slideshow={"slide_type": "slide"}
def posun(velikost, had, ovoce):
    """Posune hada v určitém směru a zajistí jeho prodloužení při snězení jídla"""
    while True:
        smer = input('Zadej smer posunu [s, j, v, z]: ')
        smer = smer.lower().strip()
        if smer not in ('s', 'j', 'v', 'z'):
            print('Nekorektni smer!')
        else:
            break

    hlava = had[-1]
    x, y = hlava
    if smer == 's':
        nova_hlava = x-1, y
    elif smer == 'j':
        nova_hlava = x+1, y
    elif smer == 'v':
        nova_hlava = x, y+1
    elif smer == 'z':
        nova_hlava = x, y-1

    if nova_hlava in had:
        raise ValueError('GAME OVER! Narazil si sam do sebe')

    x, y = nova_hlava

    if x < 0 or x > velikost-1 or y < 0 or y > velikost-1:
        raise ValueError('GAME OVER! Vyjel si mimo herni pole')

    if nova_hlava in ovoce:
        ovoce.remove(nova_hlava)
    else:
        del had[0]

    had.append(nova_hlava)
    return True


# + slideshow={"slide_type": "slide"}
from random import randrange

def pridej_ovoce(velikost, had, ovoce):
    """Přidá další ovoce na herní plochu mimo souřadnice hada"""
    ovoce.append((randrange(0, velikost), randrange(0, velikost)))
    while ovoce[-1] in had:
        del ovoce[-1]
        ovoce.append((randrange(0, velikost), randrange(0, velikost)))


# + slideshow={"slide_type": "slide"}
def hra():
    """Hlavní části hry spojeny ve finální celek"""
    velikost = velikost_hraciho_pole()

    had = [(0, 0), (0, 1), (0, 2)]
    ovoce = []
    pridej_ovoce(velikost, had, ovoce)

    vykresli_mapu(velikost, had, ovoce)

    while posun(velikost, had, ovoce):
        vykresli_mapu(velikost, had, ovoce)
        if not ovoce:
            pridej_ovoce(velikost, had, ovoce)


# + slideshow={"slide_type": "slide"}
hra()

# + [markdown] slideshow={"slide_type": "slide"}
# ## Rubber duck problem solving
# -

# ![Gumová kačenka](https://raw.githubusercontent.com/RubberDuckDebugging/rubberduckdebugging.github.io/master/images/rubberducky.png)
#
# [rubberduckdebugging.com](https://rubberduckdebugging.com/)

# + [markdown] slideshow={"slide_type": "-"}
# Jde o techniku řešení problému, při které se svůj problém snažíte vysvětlit někomu (nebo v případě gumové kachny něčemu), kdo programování nemusí vůbec rozumět. Když řešenou problematiku a vaše současné řešení popisujete nahlas, uvědomíte si, co váš program aktuálně dělá a co by dělat měl, což zpravidla vede k vyřešení problému.

# + [markdown] slideshow={"slide_type": "slide"}
# ## Obecné rady a poznatky
# -

# ## Snažte se!!!

StarcoderdataJupyterScriptsDedupFiltered