{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"collapsed_sections":["iyUkzSByvo24","5xe6Ycr-9E94","hTVohxEXpM3O","InPyJY4sOBMA","R_auDw212drK","tl34SHQIAQGH","M1Wme-aoCJgQ"],"toc_visible":true,"authorship_tag":"ABX9TyPB8sb+ycx56MfxUwy6KKVv"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","source":["# Python s KISKem\n","---\n","Tento interaktivní workbook slouží jako berličky pro tento víkend plný Pythonu. Každý máte vlastní kopii a lze si do ní dělat poznámky. Do workbooku se zapisuje pomocí Markdownu. Základní ovládání si ukážeme. Stejné věci platí i u druhého workbooku s cvičeními.\n","\n","Cvičení jsou ryze dobrovolná, ale doporučuji si je vypracovat všechna. Pokud nestiháte, nic se neděje, můžete si je dopracovat doma. Po skončení vám nasdílím i workbook se všemi vypracovanými věcmi, ale berte to jako inspiraci nebo berličky, když už opravdu nebudete vědět. Opisováním přijdete o veškerou srandu i strasti při řešení.\n","\n","Nebojte se googlit, když se zaseknete. Já to dělám v práci dnes a denně. Programátor, který říká, že negooglí, lže. Všichni to děláme, i na banální věci. 😊\n","\n","Pamatujte, žádná otázka není hloupá, pouze ta, která není položena.\n","---\n","\n","### Obsah (Co si za víkend projdeme)\n","- Co je Python\n","- Proč Python\n","- Google Colab\n","- Základy Pythonu\n","  - Základní pojmy\n","  - Proměnné\n","  - Vypisování hodnot v Pythonu\n","  - Datové typy\n","  - Aritmetické operace\n","  - Logické operace\n","- Základní konstrukty v Pythonu\n","  - Podmínky\n","  - Cykly\n","  - Práce s řetězci\n","  - Funkce\n","  - Základní datové struktury\n","- **Bonus**: Knihovny\n","  - Numpy\n","  - Pandas\n","  - Grafy\n","\n","---\n","\n","### Užitečné odkazy\n","\n","Dokumentace Python | https://docs.python.org/\n","\n","Pokročilé používání argumentů u funkcí | https://realpython.com/python-kwargs-and-args/\n","\n","Python s W3Schools (mají i tutoriál na Pandas, Numpy, MatPlotLib) | https://www.w3schools.com/python/default.asp\n","\n","Předmět CS50P na Harvardu (videa z roku 2022) | https://www.youtube.com/c/cs50/videos\n","\n","Google | https://www.google.com/search?q=how+to+python\n","\n","StackOverflow | https://stackoverflow.com/\n","\n","RealPython | https://realpython.com/\n","\n","Pandas User Guide | https://pandas.pydata.org/docs/user_guide/index.html\n","\n","Numpy Docs | https://numpy.org/doc/stable/\n"],"metadata":{"id":"DftG2-Uvun1q"}},{"cell_type":"markdown","source":["# Co je Python?\n","\n","Python je interpretovaný programovací jazyk. Interpretovaný jazyk zjednodušeně znamená, že řádky jsou zpracovávány jeden po druhém. Toto se liší od jazyků kompilovaných, kde se programy zpracovávají celé najednou (například C, C++).\n","Současná verze Pythonu je už tak schopná, že se v Pythonu dá naprogramovat téměř všechno.\n","\n","\n","> ### Základní užití Pythonu:\n",">- data science\n",">- webový vývoj\n",">- systémové skriptování\n",">- matematické výpočty\n",">\n","> ### Další využití Pythonu\n",">- hry\n",">- vývoj softwaru, aj.\n","\n","---\n","\n","\n","# Proč Python\n","Jeden z důvodů je, že Python je používaný téměř všude, v menší či větší míře. Dále také proto, že jeho syntaxe, ke které se dostaneme později, je velmi podobná angličtině. Jazyk jako takový je velmi flexibilní a umožňuje programování v různých paradigmatech, ale tím my se zabývat nebudeme. Další velkou výhodou je, že Python běží na všech platformách.\n","\n","# Google Colaboratory\n","S Pythonem je možné pracovat různými způsoby. Je možné psát kód přímo v příkazové řádce pomocí interaktivní konzole. Také můžeme používat komplexní vývojová prostředí jako PyCharm, Visual Studio Code aj., ale díky tomu, že je jazyk interpretovaný, existují nástroje jako Jupyter Notebook nebo prostředí, ve kterém se nacházíme právě teď.\n","\n","Není potřeba nic instalovat a nastavovat, stačí si vytvořit nový sešit (projekt) a můžeme psát po blocích Python kód, který je možné rovnou spustit. Spouštět bloky můžeme jeden po druhém, všechny naráz, nebo jen jeden.\n","\n","Bloky si umí předávat data mezi sebou, ale pouze od shora dolů. To znamená, že data z bloku 1 můžeme použít v bloku 2 a níže, ale ne naopak."],"metadata":{"id":"iyUkzSByvo24"}},{"cell_type":"markdown","source":["# Základní pojmy\n","\n","### Skript nebo program\n","Soubor příkazů, které vykonávají nějakou logiku. Například zpracování dat ze souboru, ale také jen jednořádkové příkazy.\n","\n","### Proměnné\n","Základní stavební kámen programů v Pythonu. Slouží na uložení hodnoty v paměti, se kterou je možné později pracovat.\n","\n","### Datový typ\n","Určuje, jaká data jsou uložena v proměnné. Základní datové typy v Pythonu jsou\n","- String – řetězec znaků\n","- Numeric – celá čísla (int), desetinná čísla (float)\n","- Boolean – pravda/nepravda – true/false\n","- Sequence – seznam (list), rozsah (range)\n","\n","Typů je více, ale toto jsou ty základní, se kterými budeme pracovat většinu času.\n","\n","I když je Python dynamický ohledně datových typů, zápis proměnných je pro jednotlivé datové typy různý. Viz další spustitelný blok.\n","\n"],"metadata":{"id":"_49__gQs3pye"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"L753lKmdujAu"},"outputs":[],"source":["retezec = \"Ahoj\"\n","cele_cislo = -12\n","desetinne_cislo = 1.2\n","stav = False\n","seznam = [1, 2, 3, 4]\n","rozsah = range(1, 10)\n","\n","# Vypis typu\n","print(f\"Typ je: {type(retezec)}\")\n","print(f\"Typ je: {type(cele_cislo)}\")\n","print(f\"Typ je: {type(desetinne_cislo)}\")\n","print(f\"Typ je: {type(stav)}\")\n","print(f\"Typ je: {type(seznam)}\")\n","print(f\"Typ je: {type(rozsah)}\")\n"]},{"cell_type":"code","source":["for i in range(1,10):\n","  print(i)"],"metadata":{"id":"N6VEw78VnPlf"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Pravidla pro psaní kódu\n","Při programování existují předepsané způsoby, jak by se měl kód zapisovat, a je dobré je dodržovat. Poté totiž bude kódu rozumět každý, nebo pro to budete mít velký předpoklad. Dodržování těchto pravidel ale pomáhá i vám, protože když přijdete ke kódu po delší době, budete vědět, co jste tím mysleli.\n","\n","Pro tento Bootcamp budeme používat tato pravidla:\n","\n","### Názvy proměnných, funkcí, parametrů\n","V Pythonu se používá zápis nazývaný *snake_case*, a to z důvodu, že se vše píše malými písmeny a slova jsou oddělená podtržítkem.\n","Dají se samozřejmě používat i jiné formáty zápisu; záleží, jak se domluví lidé v týmu. Tento Bootcamp ale vychází z pravidel, která se nazývají PEP. Ne doslovně, protože to je šikana i pro samotné vývojáře, ale čerpám z nich základní pravidla.\n","\n","```python\n","# ✅\n","promenna = True\n","promenna_na_vice_slov = True\n","\n","# ❌\n","promenna-na-vice-slov = False\n","promenna na vice slov = False\n","...\n","```\n","\n","Výjimkou jsou proměnné, u kterých se nemá měnit jejich hodnota – nazýváme je konstanty. Ty píšeme velkými písmeny a slova oddělujeme podtržítkem. Google Colab nám bohužel nehlídá, že se takovou proměnnou snažíme někde v programu přepsat. Komplexní vývojářské nástroje toto umožňují.\n","\n","```python\n","# ✅\n","KONSTANTA = 3.14\n","\n","# ❌\n","Konstanta = 3.14\n","```\n","\n","Funkce jsou takové speciální, mají totiž v definici závorky a nějaké proměnné v nich. Tyto proměnné nazýváme parametry, ale pravidly se řídí oboje: jak název funkce, tak názvy parametrů.\n","\n","\n","\n","```python\n","# ✅\n","def moje_funkce():\n","  pass\n","\n","def moje_funkce_s_parametry(parametr_jedna, parametr_dva):\n","  pass\n","\n","# ❌\n","def moje funkce():\n","  pass\n","\n","def moje-funkce():\n","  pass\n","```\n","\n","### Odsazování kódu\n","Toto je základní pravidlo Pythonu, a proto si jej prosím pečlivě zapamatujte.\n","V Pythonu odsazení kódu funguje jako členění bloků kódu a špatné odsazení může způsobit v lepším případě špatnou funkcionalitu, v tom horším a pravděpodobnějším se skript nepustí.\n","\n","Pro odsazování používáme tabulátor – tolikrát, kolikrát potřebujeme blok odsadit. Dostatečně si to osaháme během praktických příkladů, ale tady je krátký přehled, jak to funguje. Dají se používat i mezery, ale to se uklikáte.\n","\n","\n","\n","```python\n","# deklarace proměnných\n","x = 10                                      # bez odsazení\n","y = 5                                       # bez odsazení\n","\n","# odsazení při definici funkce\n","def secti_dve_cisla(cislo1, cislo2):        # bez odsazení  \n","  return cislo1 + cislo2                    # jeden tabulátor\n","\n","# vnořené odsazení\n","print(\"Toto bude cyklus\")                   # bez odsazení\n","\n","for cislo in range(10):\n","  if cislo == 1:                            # jeden tabulátor\n","    print(\"Hele, to je jednička, jako ty!\") # dva tabulátory\n","  else:                                     # jeden tabulátor\n","    print(cislo)                            # dva tabulátory\n","\n","print(\"Tady už cyklus skončil\")             # bez odsazení\n","```\n","\n","### Angličtina v kódu\n","Prozatím jsem pro prezentaci základů používal češtinu, ale od teď všechny názvy budeme psát a pojmenovávat v angličtině. Procvičíme si slovíčka, ale při zápisu některých bloků kódu taky uvidíme jednoduchou syntax, která vychází z angličtiny.\n","\n","Další blok kódu je spustitelný, abyste viděli, jak vypadá zápis programu, který vypíše čísla od 1 do 10. Jen upozornění: range funguje jako interval od-po.\n","\n",">`range(1, 10)` => *v rozsahu od 1 (včetně) po 10 (mimo 10). K indexům se dostaneme později.* 😊\n"],"metadata":{"id":"XuZqGgzS8Luw"}},{"cell_type":"code","source":["for number in range(1,10):\n","  print(number)\n","\n","# Lze přeložit jako:\n","# For number in range from 1 to 10 excluding, print the number."],"metadata":{"id":"NyH6dL_HDwLO"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["for cislo in range(10):\n","  if cislo == 1:                            # jeden tabulátor\n","    print(\"Hele, to je jednička, jako ty!\") # dva tabulátory\n","  else:                                     # jeden tabulátor\n","    print(cislo)                            # dva tabulátory\n","\n","print(\"Tady už cyklus skončil\") "],"metadata":{"id":"ecLS06Dvrgd7"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Proměnné\n","\n","Jak už bylo napsáno, proměnná je místo v paměti, kam si uložíme hodnotu. Představme si to jako kousek papírku, na který si napíšeme poznámku, a tu si vložíme do šuplíku ve stole.\n","\n","Proměnná musí být nějak pojmenovaná a vzpomeňte si, jak by pojmenování mělo vypadat. V Pythonu je potřeba při založení (dále inicializaci) proměnné přiřadit hodnotu. Do proměnné se dá uložit jakýkoliv datový typ, deklarace funkce je svým způsobem také inicializace proměnné.\n","\n","Pozor ale na datové typy. Při inicializaci musíme znát, jak se který typ zapisuje. Pokud se podíváte kousek výš, kde byly ukázány datové typy, tak je vidět, jak taková inicializace probíhá.\n","\n","Důležité je zmínit, že každý jazyk, nejen Python, má svoje rezervovaná slova, která by se pro názvy proměnných neměla používat. Například: `int`, `float`, `set`, `def`. Těmto výrazům se říká klíčová slova `keywords` a při zvýrazňění syntaxe jsou vždy označeny jinou barvou než základní barva kódu (pro nás bílá).\n","\n","### Cvičení 1\n","Zadání najdete v sešitu **Příklady_pro_bootcamp.ipynb**\n","\n"],"metadata":{"id":"VpkBJVE1SL_y"}},{"cell_type":"markdown","source":[],"metadata":{"id":"pNEDJUXpeCii"}},{"cell_type":"markdown","source":["# Vypisování hodnot v Pythonu\n","\n","Určitě jste postřehli používání příkazu `print( něco uvnitř )`\n","\n","Pomocí příkazu `print()` můžeme vypsat hodnotu proměnné, logické nebo aritmetické operace, anebo výsledek funkce s návratovou hodnotou (k tomu se dostaneme).\n","\n","Ze začátku pomocí příkazu `print()` budeme vypisovat pouze řetězce nebo hodnoty proměnných. Používání `print()` je jednoduché:\n","\n","Pokud chceme vypsat jen nějaký informativní řetězec, nemusíme jej ukládat do samostatné proměnné, prostě jej vepíšeme jako parametr do příkazu `print()`.\n","\n","\n","\n","```python\n","print(\"toto je nějaká věta, která bude vypsána z Python kódu\")\n","```\n","\n","Pokud budeme chtít vypsat hodnotu proměnné, tak místo řetězce do parametru předáme danou proměnnou. Předání znamená, že tam napíšeme její název a Python se postará o zbytek.\n","\n","\n","```python\n","my_variable = 12\n","\n","# předám svoji proměnnou do funkce print jako parametr\n","print(my_variable)\n","\n","# ve výstupu programu bude: 12\n","```\n","\n","Také můžeme vypsat více proměnných zároveň.\n","\n","```python\n","a = 5\n","b = 6\n","c = 8\n","\n","# jako parametry uvedeme jednotlivé proměnné a oddělíme je čárkou\n","print(a, b, c)\n","\n","# ve výstupu programu bude: 5 6 8\n","# Pozor, ve výpisu nebudou čárky!\n","```\n"],"metadata":{"id":"IYvkYbeQW4jl"}},{"cell_type":"markdown","source":["## Formátované výpisy\n","\n","Naprosto úžasná věc Pythonu je možnost výpis formátovat. Je to jednoduché a účinné. Dejme tomu, že máme tři proměnné:\n","- name – Patrik\n","- age – 27\n","- nickname – Koník\n","\n","A chceme z těchto tří proměnných poskládat větu.\n","> Ahoj, jmenuji se Patrik, je mi 27 let a kamarádi mi dali přezdívku Koník.\n","\n","\n","Ve formátovaném stringu je možné dělat jednořádkové operace (např. aritmetické) nebo můžeme dokonce zavolat funkci, která vrací hodnotu, a tu rovnou vepsat do stringu. "],"metadata":{"id":"olyT-styrZZi"}},{"cell_type":"code","source":["name = \"Patrik\"\n","age = 29\n","nickname = \"Koník\"\n","\n","# Můžeme použít prastarý zápis, ale můžeme takto spojovat pouze řetězce, \n","# a tak musíme všechy číselné hodnoty převést na řetězec atd.\n","print(\"Ahoj, jmenuji se \" + name + \", je mi \" + str(age) + \n","      \" let a kamarádi mi dali přezdívku \" + nickname)\n","\n","# Nebo pomocí formátovaného zápisu\n","print(f\"Ahoj, jmenuji se {name}, je mi {age} let a kamarádi mi dali přezdívku {nickname}\")\n","\n","# Jen pro info, funguje to i pro víceřádkové řetězce, ke kterým se dostaneme\n","print(f\"\"\"\n","  Ahoj, jmenuji se {name},\n","  je mi {age} let,\n","  a kamarádi mi dali přezdívku {nickname}\n","\"\"\")\n","\n","\n","# Ve formátovaném zápisu můžeme volat i funkce\n","def add(a, b):\n","  return a + b\n","\n","print(f\"součet čísel 2 a 5 je: {7 + 5}\")\n","print(\"součet čísel 2 a 5 je: \" + str(7 + 5))"],"metadata":{"id":"QynnEp3ws1Ob"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Funkce\n","\n","Funkce je blok kódu, který můžeme použít na více místech. Slučuje nám logiku několika příkazů do jednoho. Předtím, než můžeme vlastní fuknci použít, musíme ji nadefinovat. K tomu slouží klíčové slovo `def`, následuje název funkce, pak kulaté závorky a mezi nimi můžou a nemusí být parametry. Jeden, dva nebo deset. Záleží, kolik jich pro danou funkci potřebujeme. A nakonec dvojtečka. Na novém řádku a s patřičným odsazením začínáme definovat tělo funkce.\n","\n","```python\n","# Definice funkce s adekvátním názvem\n","def sum_and_print(x, y):\n","  print(x + y)\n","\n","# Volání funkce\n","sum_and_print(2, 5)\n","```\n","Zde jsme si nadefinovali funkci `sum_and_print`, která vypíše výsledek pomocí příkazu `print`. Když s výsledkem funkce chceme pracovat dál, využijeme ve funkci klíčové slovo `return`. Tomuto se říká návratová hodnota.\n","\n","```python\n","# Definice funkce s návratovou hodnotou\n","def sum(x, y):\n","  return x + y\n","\n","# Následně si můžeme hodnotu, kterou nám fuknce vrátí, uložit do proměnné result\n","\n","result = sum(2, 5)\n","\n","print(result)\n","```\n","\n","Je to o něco delší, ale můžeme pak výsledek používat na více místech a nemusíme funkci volat pokaždé, když ten výsledek potřebujeme. V připadě, že z funkce pouze **vypisujeme** hodnotu, nemůžeme tuto hodnotu dále v programu používat. Takové funkce se snažte definovat co nejméně. "],"metadata":{"id":"pdjtxk29zGLu"}},{"cell_type":"code","source":["def my_sum(x,y):\n","  result = x + y\n","  return result\n","\n","my_result = my_sum(2, 5)\n","\n","print(my_sum(2, 5))\n","\n","print(my_result)\n","\n","words = [\"Kolo\", \"jAblko\"]\n","\n","def my_to_lowercase(string):\n","  return str.lower(string)\n","\n","for w in words:\n","  print(my_to_lowercase(w))\n","\n","def greet():\n","  print(\"Hello, welcome......\")\n","\n","\n","greet()"],"metadata":{"id":"AY1DbPvL2iDN"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Platnost proměnných aneb `scope`\n","\n","Abychom v kódu měli pořádek, mají některé proměnné pouze omezenou platnost. V programování se tomu říká `scope`. Pokud například v naší fuknci nadefinujeme proměnnou jméno, tak s ní můžeme pracovat pouze v dané funkci. Mimo ni nám to fungovat nebude.\n","\n","```python\n","def greet()\n","  name = \"Patrik\"\n","  print(name)\n","\n","# pokus použít proměnnou z funkce mimo ni\n","print(name)    # NameError: name 'name' is not defined\n","```\n","\n","To stejné platí i pro cykly, podmínky a jiné. **Pozor**, v podmínkách toto neplatí. Napříč `if` a `else` částmi je stejný scope.\n","\n","> Google Colab nám proměnnou podtrhne, ale hodnota je v ní správná. Jsem zmaten... viz blok kódu níže."],"metadata":{"id":"WUBvMsbv_bN1"}},{"cell_type":"code","source":["name = \"Jan\"\n","\n","if name == \"Patrik\":\n","  surname = \"Procházka\"\n","else:\n","  print(surname)"],"metadata":{"id":"Jwa8tLmyl2Gh"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["To znamená, že můžeme v různých úrovních používat stejné pojmenovaní proměnných.\n","\n","```python\n","name = \"Patrik\"\n","\n","def greet():\n","  name = \"Jan\"\n","  print(f\"Jméno ve funkci je {name}\")\n","\n","# zavoláme funkci greet, která incializuje vlastní proměnnou name, ale nezmění tu v globálním scopu\n","greet()\n","\n","# Můžeme vidět, že proměnná name v globálním scopu se nezměnila\n","print(f\"Jméno mimo funkci je {name}\")\n","\n","# Výstup v konzoli bude:\n","# Jméno ve funkci je Jan\n","# Jméno mimo funkci je Patrik\n","\n","```"],"metadata":{"id":"nhlcUCgOoxmR"}},{"cell_type":"code","source":["name = \"Patrik\"\n","\n","def greet():\n","  name = \"Jan\"\n","  print(f\"Jméno ve funkci je {name}\")\n","\n","greet()\n","\n","print(f\"Jméno mimo funkci je {name}\")"],"metadata":{"id":"0lQbCkf6pQXC"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Vstup uživatele do programu\n","\n","Protože Python funguje v konzoli, je možné naprogramovat interakci s uživatelem. Oproti jiným jazykům je toto v Pythonu opravdu jednoduché. Python nabízí funkci `input()`, která zastaví program a čeká na vstup uživatele, který musí být potvrzen entrem. Funkce `input` nám vrací to, co zadal uživatel, a když si to uložíme do proměnné, můžeme s tím nadále v našem programu pracovat.\n","\n","Funkci `input` můžeme zadat řetězec znaků jako parametr a tento řetězec se poté ukáže na řádku, který čeká na vstup od uživatele. Můžeme tak uživatele informovat o tom, co od něj očekáváme. \n","\n","```python\n","name = input(\"Jak se jmenuješ?: \")\n","\n","print(f\"Uživatel se údajně jmenuje: {name}\")\n","```"],"metadata":{"id":"ujgldVgoqN1I"}},{"cell_type":"code","source":["input_numbers = input(\"Zadej dvě čísla, já ti vrátím součet: \")\n","\n","numbers = input_numbers.split(\" \")\n","\n","print(f\"součet je {numbers}\")"],"metadata":{"id":"5av2UvVR8lKM"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Datové typy\n","\n","Datových typů jsme se již dotkli, ale teď se na ně podíváme podrobněji, protože v práci s daty jsou nedílnou součástí. Například při používání knihovny `pandas` můžete ušetřit spoustu paměti a času, pokud pro dataset, se kterým pracujete, určíte typy pro jednotlivé sloupce.\n","\n","Datové typy dělíme na primitivní a komplexní. Komplexní datový typ je většinou složen z více primitivních anebo jeho obsah je více hodnot stejného i rozdílného primitivního typu.\n"],"metadata":{"id":"ypgyaqXlaLHa"}},{"cell_type":"markdown","source":["### Primitivní datové typy\n","- **string** – řetězec znaků, při deklaraci hodnoty používáme `\"\"`, můžeme použít i `''`, ale standard jsou dvojité uvozovky\n","\n","- **int** – celočíselná hodnota jako například `12`\n","\n","- **float** – desetinné číslo `1.2` – POZOR: desetinná čísla píšeme VŽDY s tečkou\n","\n","- **boolean** – logická hodnota (v informatice bráno jako 1 nebo 0) – v Pythonu `True` nebo `False`\n","\n","```python\n","string = \"Řetězec znaků\"\n","integer = 12\n","decimal = 1.2\n","boolean = True\n","```"],"metadata":{"id":"5xe6Ycr-9E94"}},{"cell_type":"markdown","source":["### Komplexní datové typy\n","*Python obsahuje minimálně 9 komplexních datových typů. Ukážeme prozatím jen dva, u dalších jen zmíním jejich význam a některé jsou vynechané úplně*.\n","\n","- **list** – seznam různých hodnot, které se mohou lišit datovým typem. Mixování vícero datových typů v jednom listu je ale tzv. anti-pattern. Není doporučeno to používat, program je pak nepředvídatelný.\n","\n","- **range** – speciální druh listu hodnot, které nám generuje Python v zadaném rozmezí. Je to trochu matoucí, protože `range()` je zároveň funkce, ale i datový typ.\n","\n","- **set** – další speciální druh listu, který ale obsahuje pouze unikátní hodnoty. Set lze vytvořit z listu, k tomu se ale dostaneme.\n","\n","- **dict** – slovník, v informatice též jako dictionary, je datová struktura, která data ukládá ve formátu `klíč-hodnota`, v informatice jako `key-value pair`.\n","\n","- **tuple** – také list, ale je `immutable`. To znamená, že po jeho inicializaci nemůžeme měnit hodnoty uvnitř.\n","\n","\n","\n","```python\n","my_list = [1, 1, 2, 2, 3, 3]\n","my_range = range(1, 10)\n","my_set = {1, 2, 3}\n","my_dict = { \"name\": \"Patrik\", \"age\": 30 }\n","my_tuple = (1, 1, 2, 2, 3, 3)\n","```\n"],"metadata":{"id":"StBJ0NP-9IAP"}},{"cell_type":"markdown","source":["# Mezitypové převádění\n","\n","Mezitypové převádění je často používané, protože občas můžeme mít číslo zapsané jako `string`. Už u logických hodnot jsme si ukázali, jak můžeme jiné datové typy převést na typ `boolean`, a to pomocí funkce `bool()`, kdy jako parametr předáme hodnotu nebo proměnnou, kterou chceme na daný datový typ převést.\n","\n","Na mezitypové převody existují tyto funkce:\n","- `int()` – pro převod na celé číslo\n","- `float()` – pro převod na desetinné číslo\n","- `str()` – pro převod na řetězec\n","- `bool()` – pro převod na logickou hodnotu"],"metadata":{"id":"4gT02E-vpunc"}},{"cell_type":"code","source":["bool(1123)\n"],"metadata":{"id":"MHAC552OWucH"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["string = \"Ahoj\"\n","string_number = \"10\"\n","integer = 12\n","decimal = 1.2\n","\n","# převod čísel na string je jednoduchý, jde to vždy\n","print(str(integer))\n","print(str(decimal))\n","\n","# při převodu stringu na číslo ale musíme vědět, zda string obsahuje hodnotu, kterou můžeme na číslo převést.\n","print(int(string_number))\n","print(float(string_number))\n","\n","# error\n","print(int(string))"],"metadata":{"id":"pBFgNVUNCUK-"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# String aka řetězec znaků\n","\n","V Pythonu je řetězec považován za primitivní datový typ, ale je tomu opravdu tak? Python umožňuje s řetezci dělat psí kusy. Můžeme například řetězce sčítat, chcete-li spojovat. To ale není všechno, my v Pythonu můžeme řetězce i násobit 😅. Dále pomocí cyklu můžeme vypsat jednotlivé znaky v řetězci.\n","\n","Důležitý je tu pojem znak – jedno písmeno – protože string v Pythonu není nic jiného než seznam jednotlivých znaků. To znamená, že řetězec můžeme vnímat i jako `list`."],"metadata":{"id":"Bu2GPiEyigOY"}},{"cell_type":"code","source":["# Harakiri s řetězci\n","\n","my_string = \"Ahoj\"\n","\n","# Výpis jednotlivých znaků z řetezce 🧨\n","for letter in my_string:\n","  print(letter)\n","\n","my_second_string = \"světe\"\n","\n","# Sčítání řetězců? Není problém 🤷🏼‍♂️\n","print(my_string + my_second_string)\n","\n","# Násobení řetězců 🚀\n","print(\"Čus \" * 3)"],"metadata":{"id":"JeaTQfukj9Zx"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["print(\"Hello\" in \"hello world\")"],"metadata":{"id":"jWHyYJAWX00k"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Víceřádkové řetězce\n","Někdy je potřeba do proměnné uložit delší řetězec, který je třeba vizuálně oddělený prázdným řádkem. V Pythonu není problém, jen musíme při deklaraci používat dvojité uvozovky troje místo jedněch. Poté co v Python kódu zadáme do těchto trojitých uvozovek bude i na výstupu."],"metadata":{"id":"7LfkMRBylvIR"}},{"cell_type":"code","source":["long_and_formatted_string = \"\"\"Ahoj světe,\n","\n","snažím se učit Python a myslím, že mi to jde.\n","\n","Díky!\"\"\"\n","\n","# Formátování je stejné, jako jsme to napsali při deklaraci.\n","print(long_and_formatted_string)"],"metadata":{"id":"0M3-2vzRmLYO"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Zjištění délky řetězce\n","\n","Dále se velmi často může hodit délka řetezce. Jak už asi tušíte, v Pythonu to není žádný problém. Máme na to pomocnou funkci `len()`, která nám řekne, jak je daný řetězec dlouhý. A nejen řetězec, `len()` lze použít třeba i na list, a že si toho užijeme.\n","\n","```python\n","my_string = \"Ahoj!\"\n","print(len(my_string))     # 5\n","```\n"],"metadata":{"id":"FbLF0n_Mmj9q"}},{"cell_type":"code","source":["my_string = \"Ahoj!\"\n","print(len(my_string))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"g2WRS-LGYvum","executionInfo":{"status":"ok","timestamp":1652528751885,"user_tz":-120,"elapsed":203,"user":{"displayName":"Patrik Procházka","userId":"17231667953311031119"}},"outputId":"079cc91a-e2e8-42e9-f3ed-84149ef69eeb"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["5\n"]}]},{"cell_type":"markdown","source":["### Ověření, zda je znak nebo jiný řetězec obsažen v jiném\n","Další operace, kterou lze na řetězci dělat je \"vyhledávání v nich\". V uvozovkách je kvůli nadsázce, není to totiž jako vyhledávání na Googlu. Tuto operaci lze dělat v podmínkách, ke kterým se pomale dostáváme, ale také i ve funkci `print()` na které si to ukážeme.\n","\n","Tuto operaci můžeme i negovat pomoci klíčového slova `not`\n","\n","```python\n","substring = \"Ahoj\"\n","\n","long_string = \"Ahoj světe, učím se Python\"\n","another_string = \"Zatím to jde ok...\"\n","\n","print(substring in long_string)        # True\n","print(substring in another_string)     # False  \n","\n","# Můžeme operaci znegovat pomocí klíčového slova `not`\n","print(substring not in another_string)  # True \n","```\n","\n"],"metadata":{"id":"KjrL_XBJ87O1"}},{"cell_type":"code","source":["substring = \"Ahoj\"\n","\n","long_string = \"Ahoj světe, učím se Python\"\n","another_string = \"Zatím to jde ok...\"\n","\n","print(substring in long_string)        # True\n","print(substring in another_string)     # False  \n","\n","# Můžeme operaci znegovat pomocí klíčového slova `not`\n","print(substring not in another_string)  # True "],"metadata":{"id":"nOgyirhOZjm8"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Numerické datové typy\n","\n","Opakování je matka moudrosti, a proto znovu opakuji, že máme tři numerické datové typy v Pythonu. My budeme používat pouze dva, a to:\n","\n","`int` – celočíselné hodnoty\n","\n","`float` – desetinná čísla\n","\n","Čísla jsou ve většině programovacích jazycích jednoduché a přímočaré. V Pythonu můžeme převádět mezi typy `int` a `float`, jak se nám zlíbí (ukážeme si později). Je však potřeba dávat pozor na to, že když desetinné číslo převedeme na celé číslo, nefunguje tam žádné zaokrouhlování a hodnota za desetinnou tečkou se odmaže.\n","\n","\n","\n","```python\n","my_decimal = 12.67\n","\n","print(int(my_decimal))          # 12\n","```\n","\n"],"metadata":{"id":"hTVohxEXpM3O"}},{"cell_type":"markdown","source":["# Logická hodnota – Boolean\n","\n","Další jednoduchý datový typ a tentokrát napříč programovacími jazyky. Výsledky logických operací jsou typu `boolean` a logické výrazy vždy končí ve stavu `True` nebo `False`.\n","\n","Menší trik, který se používá s hodnotami boolean v programovacích jazycích, je vyhodnocování, jestli proměnná primitivního typu obsahuje hodnotu. Dost často se toto používá, pokud potřebujete pracovat s proměnnou, ve které je nějaká hodnota. K praktickému používání se dostaneme u podmínek.\n","\n","\n","```python\n","print(bool(\"Ahoj\"))          # True\n","print(bool(1))               # True\n","\n","# Zatímco\n","print(bool(\"\"))              # False\n","print(bool(0))               # False\n","\n","# A platí to i u komplexních datových typů\n","print(bool(()))              # False\n","print(bool([]))              # False\n","print(bool({}))              # False\n","```\n","\n"],"metadata":{"id":"BGZQkU_4pjvc"}},{"cell_type":"code","source":["response = {}\n","\n","if bool(response):\n","  pass"],"metadata":{"id":"UBv6mtZyanE8"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Aritmetické operace\n","\n","V Python kódu je možné počítat jak jednoduché operace pomocí příkazů, tak i složitější matematické úlohy většinou za pomoci knihoven třetích stran.\n","\n","My si ukážeme ty jednoduché. Mezi ně řadíme:\n","- sčítání (`+`)\n","- odčítání (`-`)\n","- násobení (`*`)\n","- dělení (`/`)\n","- modulo (zbytek po celočíselném dělení) (`%`)\n","- mocniny (`**`)\n","- celočíselné dělení (`//`)\n","\n","\n","\n","```python\n","a = 10\n","b = 4\n","\n","print(a+b)    # 14\n","print(a-b)    # 6\n","print(a*b)    # 40\n","print(a/b)    # 2.5\n","print(a%b)    # 2\n","print(a**b)   # 10000\n","print(a//b)   # 2\n","```\n","\n","Pěkně přímočaré, není potřeba nic navíc. Pokud chceme například do proměnné `x`, která má hodnotu `5`, při inicializaci příčíst hodnotu proměnné `y`, tak to uděláme takto:\n","\n","```python\n","x = 5\n","y = 4\n","\n","x = x + y        # po tomto příkazu bude hodnota uložená v x 9 \n","```\n","\n","Můžeme vidět, že zápis tak jednoduché věci je docela zdlouhavý, a proto existují i zkrácené zapisy pro aritmetické operace.\n","\n","`x = x + y` lze zapsat i jako `x += y`. Platí to pro všechny operace, které jsme si teď ukázali.\n","\n","Je také možné si všimnout, že výsledek dělení je vždy typu decimal (float).\n","\n"],"metadata":{"id":"vwrDmP5wqGwQ"}},{"cell_type":"code","source":["x = 5\n","y = 4\n","\n","x = x + y\n","x += y\n","print(x)"],"metadata":{"id":"id-bmMWBb6rn"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Logické operace a jiné operátory\n","\n","Programování jako takové je nabité logikou, a proto snad v každém programovacím jazyku existují logické operátory. Logické operátory mají využití v podmínkách, které nás čekají níže.\n","\n","Nebudeme se zaobírat správnými pojmenováními, abychom se z toho nezbláznili.\n","\n","Základními operátory jsou větší, menší, rovná se, a jejich kombinace. Pokud takovou operaci napíšeme v kódu, výsledkem takové operace je vždy hodnota `boolean`, tedy `True` nebo `False`. Pokud z této operace dostanete něco jiného, tak je někde chyba.\n","\n","```python\n","x = 5\n","y = 4\n","\n","print(x < y)       # False\n","print(x > y)       # True\n","print(x == y)      # False\n","print(x <= y)      # False\n","print(x >= y)      # True\n","print(x != y)      # True\n","```\n"],"metadata":{"id":"SUIz0f0EqI9C"}},{"cell_type":"markdown","source":["### Logické operace\n","Logické operace jsou věda sama o sobě. Pamatujete si výrokovou logiku?\n","\n","V Pythonu se nachází 3 logické operátory\n","- logické \"a\" (`and`)\n","- logické \"nebo\" (`or`)\n","- logická negace (`not`)\n","\n","Zapomoci logických operací můžeme řetězit podmínky v našem programu. V matematice jsme například určovali hodnotu čísla v podmínách nějak takto:\n","`0 < x < 10` toto ale nemůže v pythonu napsat, protože by se nám program nesputil a vyhodil nám chybu. Jsou to dvě podmínky v jednom. Když chceme takovou podmínku napsat v Pythonu, musíme obě podmínky spojit logickým \"ano\" `and`.\n","\n","Když si podmínku `0 < x < 10` můžeme rozložit na dvě podmínky:\n","- `x` musí být větší než `0`\n","- A ZÁROVEŇ je `x` menší jak `10`\n","\n","Obě tyto podmínky už umíme zapsat v Pythonu a jen je spojíme logickým \"a\" `and`.\n","\n","```python\n","x = 9\n","\n","print( x > 0 and x < 10 )    # True\n","```\n","\n","Pokud podmínky řetězíme, tak je potřeba brát v potaz tyto pravidla:\n","\n","> Abychom dostali `True` za pomoci `and` , tak musí být všechny podmínky spojené logickými operátory `True`.\n","`True and True and True` je výsledně `True`, zatím co `True and False and True` je výsledně `False`\n","\n","> Při používání logické operace `or` nám stačí pro výsledné `True`, aby byla alespoň jedna podmínka ze všech s výsledkem `True`. `True or False or False` je výsledně `True`, zatím co `False or False or False` je výsledně `False`.\n"],"metadata":{"id":"InPyJY4sOBMA"}},{"cell_type":"markdown","source":["### Operátory `is` a `in`\n","\n","Tyto dva operátory s sebou přináší trochu zamotání všeho, co jsme se doteď naučili. Respektive jeden z nich a to `is`.\n","Operátor `is` porovnává dva objekty, jestli jsou stejné.\n","\n","```python\n","x = 5\n","y = 5\n","print(x is y)    # True\n","\n","i = [1, 2, 3]\n","j = [1, 2, 3]\n","print(i is j)    # False ?!\n","\n","a = \"ahoj\"\n","b = \"ahoj\"\n","print(a is b)    # True ?!\n","```\n","\n","Jednoduché datové typy lze porovnávat pomoci operátu `is` ale **NEDOPORUČUJI TO!** Je to proti konvencím a operátor `is` je velmi specifický a jeho použití také. U komplexních datových typů se porovnává místo v paměti ne hodnoty jako takové.\n","\n","Zatím co operátor `in` se vám bude hodit a používá se v Pythonu často. Lze s jaho pomocí vyhledávat v řetězcích i komplexních datových typek.\n","\n","```python\n","x = {1,2,3}     # Set\n","print(1 in x)   # True\n","\n","x = [1,2,3]     # List\n","print(1 in x)   # True\n","\n","x = (1,2,3)     # Tuple\n","print(1 in x)   # True\n","```\n","\n","Operátor `in` se dá používat i pro práci se slovníky (`dict`), ale k tomu možná později.\n","\n","Operátory `is` nebo `in` lze kombinovat a otáčet podmínku pomoci `not`.\n","- není - `is not`\n","- není v - `not in`\n","\n","Krásně to reflektuje angličtinu, ale dělá binec v syntaxi programovacího jazyka 🙃"],"metadata":{"id":"TKn9kdO4OA7x"}},{"cell_type":"code","source":["x = 5\n","y = 5\n","print(x is y)    # True\n","\n","i = [1, 2, 3]\n","j = [1, 2, 3]\n","print(i is j)    # False ?!\n","\n","j = i\n","i.append(5)\n","j.append([1, 2, 3 , 4])\n","print(j)\n","\n","\n","a = \"ahoj\"\n","b = \"ahoj\"\n","print(a is b) \n","\n","def add(a, b):\n","  return a + b\n","\n"],"metadata":{"id":"ZScu5eV8fbbz"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Podmínky\n","\n","Podmínky jsou nedílnou součástí programování. Slouží k větvení programů podle zadaných podmínek, které jsme si ukazovali. Podmínku definujeme pomocí klíčového slova `if` a následuje podmínka, která musí ve výsledku dát hodnotu `boolean`. V jádru jsou podmínky velmi jednoduché, jako když položíte otázku, na kterou se odpovídá ano či ne.\n","\n","Po podmínce následuje dvojtečka, stejně jako u definice funkce. Prvně píšeme blok kódu, který se vykoná, když je podmínka vyhodnocena pozitivně. Může, ale nemusí následovat blok `else`, který zachytí ostatní případy vyhodnocení podmínky. A opět blok kódu, který se má v tomto případě vykonat. **POZOR!** Bloky kódu v obou větvích podmínky musí být řádně odsazeny, jinak se nám Python kód nespustí!\n","\n","```python\n","i_love_kisk = True\n","\n","# Definice podmínky a \"otázky\", na kterou se dá odpovědět ano či ne\n","if i_love_kisk == True:\n","  # Blok kódu, pokud je odpověď kladná\n","  print(\"Tak se vidíme na KISK párty!\")\n","else:\n","  # Klíčové slovo else se vykoná ve všech ostatních případech\n","  print(\"Přijď na KISK párty a změníš názor 🚀\")\n","```"],"metadata":{"id":"gaLdBhIQTNTu"}},{"cell_type":"markdown","source":["## Více podmínek aneb `if...else if...else`\n","\n","Python nám také umožňuje spojit více podmínke dohromady, když potřebuje vyhodnotit více stavů. Za první `if` blok přidáme blok s další podmínkou za pomoci klíčového slova `elif`. Toto je jedna z mála věcí, která je na Python syntaxi divná, většina programovacích jazyků má klauzuli `else if`, ale Python chtěl být speciální 🙃.\n","\n","```python\n","my_age = 18\n","\n","if my_age < 18:\n","  print(\"Alkohol by mi prodat neměli\")\n","elif my_age == 18:\n","  print(\"Je to těsný, ale můžu si v klidu kupovat\")\n","else:\n","  print(\"Naprostá pohodička\")\n","```\n","\n","Když skládáte více podmínek, musíte si dávat pozor na to, jak je skládáte. Protože se můžete i u tak jednoduchého příkladu dostat do bodu, že nebudete mít ošetřeny všechny stavy.\n","\n","```python\n","brand = \"Peugeot\"\n","year = 2000\n","\n","if brand == \"Peugeot\":\n","  print(\"Francouz... ale aspoň je pohodlnej\")\n","# Tato podmínka nikdy nenastane, protože všechny Peugoty zachytí podmínka první.\n","elif brand == \"Peugeot\" and year < 2000:\n","  print(\"Kámo, čas na změnu\")\n","elif year < 2012 and brand is not \"Peugeot\":\n","  print(\"Hmmm...\")\n","else:\n","  print(\"Užívej moderní káru\")\n","```\n","\n","Říka se tomu problém největší specifity. To znamená, že podmínka, která je nejvíce specifická by měla být první, respektive měly by podmínky být poskládány od nejsložitějších po nejjednodušší."],"metadata":{"id":"e0HVyC391jxe"}},{"cell_type":"code","source":["brand = \"BMW\"\n","year = 2000\n","\n","if year < 2012 and brand != \"Peugeot\":\n","  print(\"Hmmm...\")\n","elif brand == \"Peugeot\" and year < 2001:\n","  print(\"Kámo, čas na změnu\")\n","elif brand == \"Peugeot\":\n","  print(\"Francouz... ale aspoň je pohodlnej\")\n","else:\n","  print(\"Užívej moderní káru\")"],"metadata":{"id":"36Ln59tF4put"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Ternární operátory\n","\n","Ternární operátor je zkrácený zápis podmínek na jeden řádek (většinou). Toto zase musím v Pythonu pochválit. Ze syntaktického hlediska je to zase jako věta v angličtině. Vezměme v potaz úvodní příklad ohledně náklonosti ke KISKu.\n","\n","```python\n","i_love_kisk = True\n","\n","if i_love_kist == True:\n","  print(\"Tak se vidíme na KISK párty!\")\n","else:\n","  print(\"Přijď na KISK párty a změníš názor 🚀\")\n","```\n","\n","Takovou jednoduchou podmínku, která má pouze `if else` skladbu můžeme zapsat i pomoci ternárního operátoru.\n","\n","```python\n","print(\"Tak se vidíme na KISK párty!\") if i_love_kist == True else print(\"Přijď na KISK párty a změníš názor 🚀\")\n","```\n","\n","Možná je to trochu nepřehledná, ale v podstatě je to poskládané takto:\n","\n",">`Příkaz, co se má provést, POKUD je tento výrok pravdivý NEBO se provede tento příkaz`"],"metadata":{"id":"nFJich8K52k-"}},{"cell_type":"code","source":["i_love_kisk = \"\"\n","\n","if i_love_kisk:\n","  print(\"Tak se vidíme na KISK párty!\")\n","else:\n","  print(\"Přijď na KISK párty a změníš názor 🚀\")\n","\n","\n","if i_love_kisk:\n","  pass\n","\n","print(\"Tak se vidíme na KISK párty!\") if i_love_kisk else print(\"Přijď na KISK párty a změníš názor 🚀\")"],"metadata":{"id":"zJofkwdYn6mg"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Cykly\n","\n","Cyklus nám může posloužit, když potřebujeme něco udělat několikrát. Máme dva druhy cyklu – `for` a `while`. Mějme na paměti, že cyklus se nemusí vždy opakovat tolikrát, kolikrát bylo zamýšleno. Můžeme v cyklu mít podmínku, která nám například najde nějaký prvek, a poté zavolat příkaz `break`, který cyklus ukončí, a následuje další příkaz po cyklu. "],"metadata":{"id":"QAwrw_5ITKEU"}},{"cell_type":"code","source":["fruits = [\"apple\", \"kiwi\", \"banana\"]\n","\n","for fruit in fruits:\n","  print(fruit)\n","\n","print(\"Konec cyklu\")\n","\n","for x in range(2, 6):\n","  print(x)\n","\n","\n"],"metadata":{"id":"jVDvEqTZw-Bz"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Cyklus `for`\n","\n","Tento cyklus slouží k iterování v daném rozmezí opakování. Můžeme použít range, nebo pomoci cyklu `for` procházet datové struktury jako `list`, `tuple`, nebo `set`.\n","\n","Syntaxe definice cyklu `for` je zase podobná angličtině. Například pokud chceme iterovat nad listem, tak definici v anglické věte víceméně přepíšeme do Pythonu.\n","\n","> `for fruit in fruit_basket do something`\n","\n","```python\n","fruit_basket = [\"apple\", \"orange\", \"banana\", \"watermelon\"]\n","\n","for fruit in fruit_basket:\n","  print(fruit)\n","```\n","\n","Za klíčovým slovem `for` definujeme proměnnou, která se bude používat v bloku kódu, který se vykonává při každé iteraci cyklu. Můžeme si ji pojmenovat jak chceme, ale mějte na paměti, že pojmenováváme proměnné smysluplně.\n","\n","Pomoci cyklu můžeme i procházet řetězce písmeno po písmenu.\n","\n","```python\n","my_string = \"Patrik\"\n","\n","for char in my_string:\n","  print(char)\n","```\n","\n","Specialita cyklu `for` je, že ho můžeme vnořovat do sebe. Můžeme tedy mít cyklus v cyklu.\n","\n","```python\n","adjectives = [\"red\", \"big\", \"tasty\"]\n","fruits = [\"apple\", \"banana\", \"cherry\"]\n","\n","# Pro jednu interakci vnějšího cyklu musí být ukončeno vše uvnitř cyklu\n","for adj in adjectives:\n","  for fruit in fruits:\n","    print(adj, fruit)\n","```\n","\n","Stejně jako u fukncí a podmínek, ani cykly nemohou být inicializovány s prázdným tělem. Opět ale můžeme využít klíčové slovo `pass`.\n","\n","```python\n","for i in range(1, 10):\n","  pass\n","```"],"metadata":{"id":"js0CrLQw50Zp"}},{"cell_type":"code","source":["adjectives = [\"red\", \"big\", \"tasty\"]\n","fruits = [\"apple\", \"banana\", \"cherry\"]\n","\n","for adj in adjectives:\n","  for fruit in fruits:\n","    print(adj, fruit)\n","  print(\"Fiha\")\n","\n","print(\"Tadaaa\")"],"metadata":{"id":"_2NZhpkbzEM4"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Cyklus `while`\n","\n","Tento cyklus má v inicializaci podmínku, která vyhodnocuje, zda se má kód v těle cyklu ještě provádět. Většinu případů dokáže, kdy potřebuje cyklus, dokáže zastát cyklus `for`, ale někdy je z logiky věci lepší použít cyklus `while`.\n","\n","```python\n","fruits = [\"apple\", \"banana\", \"kiwi\", \"watermelon\"]\n","\n","index = 0\n","\n","while index < len(fruits):\n","  if fruits[i] == \"kiwi\":\n","    print(\"Aaaaa, kyselý!!\")\n","    break\n","  else:\n","    print(\"Mňam\")\n","\n","  index += 1\n","\n","print(\"Mám rád sladké, no\")\n","```\n","\n","Pokud u cyklu while používáme v incializační podmínce index, musíme ho vždy ručně modifikovat, jinak by se nám mohlo stát, že se nám spustí nekonečná smyčka.\n","\n","`while` cyklus je dobrý například pokud potřebujeme souvisle zpracovávat vstup od uživatele a pouze některé interakce by měly program ukončit.\n","\n","```python\n","# Takový programátorský hack, kdy udržet while cyklus bežet donekonečna\n","while True:\n","  # načteme vstup uživatele\n","  user_input = input(\"Tak co?: \")\n","\n","  # vyhodnotíme, zda uživatel nezadal nějaké exit slovo\n","  if str.lower(user_input) in [\"konec\", \"q\", \"pryč\"]:\n","    print(\"Tak čau!!\")\n","    # ukončíme while cyklus\n","    break\n","\n","  # Provokujeme dál...\n","  print(f\"{user_input}... Aha, a dál?\")\n","```"],"metadata":{"id":"AOmEZCkx_pyc"}},{"cell_type":"code","source":["while True:\n","  user_input = input(\"Tak co?: \")\n","\n","  if str.lower(user_input) in [\"konec\", \"q\", \"pryč\"]:\n","    print(\"Tak čau!!\")\n","    break\n","\n","  print(f\"{user_input}... Aha, a dál?\")"],"metadata":{"id":"HJwBvhGTk2ws"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["fruits = [\"apple\", \"banana\", \"kiwi\", \"watermelon\"]\n","\n","index = 0\n","\n","while index < len(fruits):\n","  if fruits[index] == \"kiwi\":\n","    print(\"Aaaaa, kyselý!!\")\n","    break\n","  else:\n","    print(\"Mňam\")\n","\n","  index += 1\n","\n","print(\"Mám rád sladké, no\")"],"metadata":{"id":"K2F6Qw6d9wgy"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Specialitou `while` cyklu je možnost za něj navázet `else`, protože při inicializaci cyklu zadáváme podmínku\n","\n","```python\n","number = 1\n","while number < 10:\n","  print(number)\n","  number += 1\n","else:\n","  print(f\"{number} už není méně než 10\")\n","```"],"metadata":{"id":"CPIz9blrokKw"}},{"cell_type":"code","source":["number = 1\n","while number < 10:\n","  print(number)\n","  number += 1\n","else:\n","  print(f\"\\n{number} už není méně než 10\")"],"metadata":{"id":"k5VDVDb2-FjI"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["my_variable = \"neco\"\n","my_number = 234\n","\n","str()\n","float()\n","bool()\n","int(12.78)\n","\n","# < > <= >= != == is in not \n","\n","if (my_variable == \"KISK\" or my_variable == \"FF\") and my_variable == \"FF\":\n","  print(\"KISK je super\")\n","elif my_variable == \"FF\":\n","  print(\"Doufam, ze aspon KISK\")\n","else:\n","  print(\"Skoda\")\n","\n","# user_input = input(\"Jak se dneska mas? \") \n","\n","import datetime\n","print(datetime.datetime.now())\n","\n","def my_function(param1, param2):\n","  return param1 + param2\n","\n","result = my_function(10, 10)\n","\n","print(result)\n","\n","for x in range(50, 61):\n","  if x % 10 == 0:\n","    print(\"neco\")\n","  else:\n","    print(x, end=\" \")\n","\n","i = 0\n","while i < 10:\n","  print(i)\n","\n","  i += 1"],"metadata":{"id":"5Nk8xOx_ilmm"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Datové struktury\n","\n","nebo také komplexní datové typy. Narozdíl od jednoduchých datových typů jsou ty komplexní uloženy v paměti rozdílně.\n","\n","Když inicializujeme list pomocí příkazu `x = [1, 2, 3]`, tak se nám do `x` uloží **odkaz do paměti**, kde je uloženo pole. Z toho důvodu jsme dostávali `False`, když jsme zkoušeli porovnávat dvě zdánlivě identická pole pomocí operátoru `is`. Každé pole ukazovalo do jiného kousku paměti, a to nám porovnával operátor `is`.\n","\n","Na toto je potřeba si dávat pozor, když budeme s datovými strukturami pracovat. S tím, co jsme se zatím naučili, víme, že můžeme z proměnné `a` kopírovat hodnotu do proměnné `b` tím, že napíšeme `a = b`, ale co se stane, když zkusíme to stejné u nějaké datové struktury?\n","\n","```python\n","a = [1, 2, 3]        # Incializujeme list\n","b = a                # \"Zkopírujeme\" list a do proměnné b\n","\n","a[0] = 5             # Změníme první prvek listu a na číslo 5\n","\n","print(b)             # Co se nám vypíše?\n","print(a is b)        # True\n","```\n","\n","Vypíše se nám `[5, 2, 3]`. A proč? Protože když jsme zkoušeli zkopírovat list z `a` do `b`, tak jsme proměnné `b` nepředali hodnoty z listu, ale pouze adresu na místo v paměti, kde je uložen list `a`. To znamená, že jsme v tu chvíli měli v proměnných `a` i `b` uloženou stejnou adresu, a proto nám vyjde porovnání `a is b` jako `True`.\n","\n","S tímto chováním přichází spousta věcí, které si musíme hlídat, když chceme s takovými strukturami pracovat, a proto programovací jazyky nabízí spoustu fukcí, které nám práci s těmito strukturami ulehčí. Představíme si ty základní funkce, které můžeme používat, a k čemu slouží.\n"],"metadata":{"id":"7vpyJtoLpnLb"}},{"cell_type":"markdown","source":["## Společné znaky datových struktur\n","\n","Mějme list `[1, 2, 3, 4, 5]`. Už jsme si řekli, že datové struktury nám umožní ukládat více hodnot do jedné proměnné, které spolu mohou, ale nemusí souviset. Ale co když z takového listu chceme přečíst pouze jednu hodnotu, nebo ji změnit? Od toho existuje `index`. Index je ukazatel na pozici v listu. Index nabývá hodnot od 0 do ..., to záleží na velikosti listu, ale z pravidla je to `počet prvků v listu - 1`. Mínus jedna protože začínáme od hodnoty 0, ale délka je `1` pokud je v listu pouze jeden prvek, který se nachází na `indexu` **0**.\n","\n","> V Pythonu můžeme zadat i zápornou hodnotu indexu a tato funkcionalita se může hodnit -> na indexu `-1` najdeme poslední položku seznamu atd. \n","\n","`[1, 2, 3, 4, 5, 6]` List\n","\n","`_0__1__2__3__4__5_` Indexy prvků\n","\n","V Pythonu i jiných programovacích jazycích se používá k přístupu k hodnotám v listu pomoci hranatých závorek `[]`, které jsou hned za názvem proměnné. Do hranatých závorek uvádíme hodnotu `indexu`, na který chceme přistoupit.\n","\n","```python\n","my_list = [1, 2, 3, 4, 5, 6]\n","\n","# ✅\n","my_list[3]    \n","\n","# ❌\n","my_list [3]\n","\n","\n","# NEGATIVNÍ INDEX\n","\n","# Když chceme přistoupit na poslední položku v seznamu,\n","# tak máme dvě možnosti:\n","my_list[len(my_list) - 1]       # 🤷🏼‍♂️ moc dlouhé\n","\n","my_list[-1]                     # 👍🏼\n","```\n","\n","Tento přístup platí i pro `Tuple` a `Dictionary`. Ale aby to nebylo jednoduché, tak u `Dictionary` je to trochu jiné, ale k tomu se dostaneme. **U struktury typu `Set` takto k hodnotám přistupovat nemůžeme!**\n","\n","Samozřejmě do sebe můžeme jednotlivé jednotlivé listy zanořovat. I u těchto vnořených listů můžeme přistupovat pomoci indexu k jednotlivým prvkům. Začínáme vždy s indexem vnějšího a pokračujeme dál.\n","\n","```python\n","my_class = [[\"Pepa\", \"Jan\", \"Patrik\"], [\"Jana\", \"Anna\", \"Lenka\"]]\n","\n","# ✅\n","my_class[0][2]              # Patrik\n","\n","# ❌\n","my_class[0,2]               # Error\n","```\n","\n","Přistupování k hodnototám v zadanám rozsahu indexu.\n","Stejně jako u `range()` platí, že první číslo platí a druhé určuje hranici, ale už je vynecháno.\n","\n","```python\n","# indexy   0  1  2  3  4  5  6  7  8\n","my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n","# vypíšeme _____[3, 4, 5]____________\n","my_list[2:5]\n","```\n","\n","\n","\n","\n"],"metadata":{"id":"e-08TiSQfOnk"}},{"cell_type":"code","source":["# my_list = [1, 2, 3, 4, 5, \"Apple\"]\n","\n","# my_list[3] = \"Apple\"\n","\n","# print(my_list.index(\"Apple\"))\n","\n","# my_list.append([1, 2, 3])\n","\n","# def greet():\n","#   print(\"Hello\")\n","\n","# greet()\n","\n","# greet\n","\n","# print(greet)\n","\n","# my_list.append(greet)\n","\n","\n","# print(my_list[3].lower())\n","\n","# print(my_list)\n","# my_list[-1]()\n","\n","\n","def plus(a, b):\n","  print(a + b)\n","\n","def minus(a, b):\n","  print(a - b)\n","\n","def krat(a, b):\n","  print(a * b)\n","\n","def deleno(a, b):\n","  if b == 0:\n","    print(\"Delit nulou nelze\")\n","    return\n","\n","  return a / b\n","\n","operations = {\n","    \"+\": plus,\n","    \"-\": minus,\n","    \"/\": deleno,\n","    \"*\": krat\n","}\n","a = 5\n","b = 4\n","\n","operation = input(\"zadej operaci: \")\n","if operation not in [\"*\", \"+\", \"-\", \"/\"]:\n","  print(\"Tato operace neni podporovana\")\n","else:\n","  vysledek = operations[operation](a, b)\n","\n","\n","\n","\n","\n","\n","\n","# if operation == \"+\":\n","#   result = plus(a, b);\n","# elif operation == \"-\":\n","#   result = minus(a, b)\n","# elif operation == \"*\":\n","#   krat(a, b)\n","# elif operation == \"/\":\n","#   deleno(a, b)\n","# else:\n","#   print(\"Toto neni spravna operace\")"],"metadata":{"id":"1IkIj1g0w8jC"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## List\n","\n","List je často používaná datová struktura a nabízí spoustu metod pro práci s ním.\n","\n"],"metadata":{"id":"iWaZ_gzDSl7F"}},{"cell_type":"markdown","source":["### Přídání prvku do listu\n","##### Metoda `append()`\n","Append je jedna z metod, pomoci které můžeme přidávat prvky do listu. Metoda `append()` má jeden parametr. V tomto parametru předáme objekt, který chceme do listu přidat. Objekt, protože pomoci metody `append` můžeme přidat primitivní hodnotu, ale i další list, či jinou datovou strukturu.\n","\n","```python\n","# Přidání nového prvku do listu\n","girls = [\"Jana\", \"Anna\"]\n","girls.append(\"Lenka\")\n","\n","my_class = [[\"Pepa\", \"Jan\", \"Patrik\"]]\n","my_class.append(girls)\n","\n","# Přídání další ho listu do listu listů 😅\n","my_class.append([1, 2, 3])\n","\n","# Výsledný list\n","[['Pepa', 'Jan', 'Patrik'], ['Jana', 'Anna', 'Lenka'], [1, 2, 3]]\n","```\n","\n","------\n","##### Metoda `insert()`\n","Metoda insert přijímá dva parametry, první parametr je index, na který chceme do listu něco vložit a druhý je objekt, co chceme vložit.\n","\n","Je možné vkládat i datové struktury, ale pokud třeba chcete spojit dvě pole, bude se hodit další metoda `extend`.\n","\n","```python\n","# indexy  _0, 1, 2, 3, 4, 5, 6, 7, 8_\n","my_list = [1, 2, 3, 5, 6, 7, 8, 9, 0]\n","my_list.insert(3, 4)\n","\n","# Výsledný list\n","[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n","```\n","\n","----\n","##### Metoda `extend`\n","Extend slouží na slučování nejen listů. Umožňuje totiž sloučit list s tuplem nebo list se setem. Používat ji nebudeme, ale hodit se může.\n","\n","```python\n","numbers = [1, 2, 3, 4, 5]\n","more_numbers = [6, 7, 8, 9, 0]\n","\n","numbers.extend(more_numbers)\n","\n","# Výsledný list\n","[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n","```"],"metadata":{"id":"Qrj9r4jO0E5P"}},{"cell_type":"code","source":["my_list = [1, 2, 3, 5, 6, 7, 8, 9, 0]\n","my_list.insert(3, 4)\n","\n","numbers = [1, 2, 3, 4, 5]\n","more_numbers = [6, 7, 8, 9, 0]\n","\n","var = numbers + more_numbers"],"metadata":{"id":"-U_0ZmEp_F8i"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Mazání prvků z listu\n","\n","##### Metoda `pop` a `remove`\n","Pro mazání z listů v Pythonu existují dvě metody, a to `pop` a `remove`. Obě metody příjimají jeden parametr, ale chování je rozdílné.\n","\n","`pop` nám odstraní prvek ze zadaného indexu. Je možné parametr nezadat a tím neurčit index na kterého chceme odstranit položku. Výchozí chování způsobí, že bude smazána poslední položka v listu.\n","\n","```python\n","numbers = [1, 2, 3, 4]\n","numbers.pop()\n","\n","# stav listu\n","[1, 2, 3]\n","\n","numbers.pop(1)\n","\n","# konečný stav listu\n","[1, 3]\n","```\n","\n","\n","Zatím co `remove` odstraní z pole prvek, který má stejnou hodnotu jako parametr. **POZOR!**, odstraňuje **pouze** první prvek, na který narazí.\n","\n","```python\n","fruits = [\"banana\", \"apple\", \"kiwi\", \"watermelon\", \"banana\"]\n","fruits.remove(\"banana\")\n","\n","# Výsledný list - všimněte si, že byla odstraněna\n","# pouze první hodnota, která je shodná s parametrem.\n","[\"apple\", \"kiwi\", \"watermelon\", \"banana\"]\n","```\n","\n","----\n","\n","##### Metoda `clear`\n","Jak už název napovídá, tak tato metoda smaže všechny prvky v listu.\n","\n","```python\n","my_list = [1, 2, 3, 4, 5, 6]\n","my_list.clear()\n","\n","# Výsledek\n","[]\n","```\n"],"metadata":{"id":"EOvtZ6II0lGO"}},{"cell_type":"code","source":["def filter_list(users_list, subject_to_remove):\n","  result_list = []\n","  for item in users_list:\n","    if item != subject_to_remove:\n","      result_list.append(item)\n","  return result_list\n","\n","fruits = [\"banana\", \"apple\", \"kiwi\", \"watermelon\", \"banana\"]\n","\n","# print(filter_list(fruits, \"banana\"))\n","def sort(a, b):\n","  if a > b:\n","    return 1\n","  elif a < b:\n","    return -1\n","  else:\n","    return 0\n","\n","\n","\n","print(fruits.sort())"],"metadata":{"id":"j8itIXjmAc-w"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Další užitečné metody pro list\n","\n","##### Metoda `sort`\n","Seřadí pole vzestupně, pokud chceme sestupně, tak musíme nastavit parametr `reverse` na `True`.\n","\n","```python\n","my_numbers = [9, 0, 1, 6, 2, 3, 6, 5, 4]\n","my_numbers.sort()\n","\n","# Výsledek\n","[0, 1, 2, 3, 4, 5, 6, 6, 9]\n","\n","# Řazení sestupně pomoci parametru reverse\n","my_numbers.sort(reverse=True)\n","\n","# Výsledek\n","[9, 6, 6, 5, 4, 3, 2, 1, 0]\n","```\n","\n","----\n","##### Metoda `reverse`\n","Tato metoda jednoduše přehází hodnoty v listu do opačného pořadí.\n","\n","```python\n","numbers = [1, 2 ,3]\n","numbers.reverse()\n","\n","# Výsledek\n","[3, 2, 1]\n","```\n","\n","----\n","##### Metoda `count`\n","Tato metoda spočítá kolikrát se hodnota zadaná jako parametr objevuje v listu. Tento počet výskytů je jako návratová hodnota a proto ji musíme uložit do nějaké proměnné, jinak o výsledek této funkce přijdeme.\n","\n","```python\n","fruits = [\"banana\", \"apple\", \"kiwi\", \"banana\", \"watermelon\"]\n","\n","number_of_bananas = fruits.count(\"banana\")\n","\n","print(number_of_bananas)     #  2\n","```"],"metadata":{"id":"R_auDw212drK"}},{"cell_type":"markdown","source":["## Set\n","\n","Jak už bylo řečeno, tak `set` je datová struktura, která obsahuje pouze unitkátní hodnoty. Práce se setem ale není tak jednoduchá jako s listem. Set také nedispunuje takovým množstvím metod jako list. Na ukázku jich tu máme jen pár. Další zádrhel setu je, že nemůže přistupovat k prvkům jako u listu přes hranaté závorky a index, na který chceme přistoupit. Musíme buď projít celý set pomoci cyklu a nebo použijeme podmínku pro zjištění, zda se prvek, který chceme, nachází v setu.\n","\n","K čemu je tedy takový set dobrý? Dost často potřebuje získat pouze unikátní hodnoty v datech (například z listu) a než abychom si museli psát složitou fuknci, tak si z listu jednoduše vytvoříme `set`.\n","\n","Set se nedá seřadit ani upravovat nějak napřímo. Pro jeho editaci musíme striktně pracovat jen s metodami.\n","\n","```python\n","billion_numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]\n","\n","distinct_values = set(billion_numbers)\n","\n","print(distinct_values)\n","\n","# Unikátní hodnoty všechny pohromadě\n","{1, 2, 3, 4, 5}\n","\n","# Výpis hodnot ze setu po jedné\n","for value in distinct_values:\n","  print(value)\n","\n","# Nebo si můžeme pomoci operátoru in zjistit, zda se hodnota v setu nachází\n","print(6 in distinct_values)   # False\n","\n","```\n","\n","Jak můžeme vidět, pokud si vypíšeme `set` pomoci funkce `print`, tak hodnoty jsou ve složených závorkách a ne v hranatých. **Pozor** ale když si chcete vytvořit pouze prázdný set a hodnoty do něj přidat později, tak ho vytvoříme pomoci tzv. `constructoru`.\n","\n","```python\n","# Správně ✅\n","my_empty_set = set()\n","\n","# Špatně ❌\n","my_empty_set = {}\n","```\n","\n","`{}` tento zápis nám vytvoří prázdný `dictionary`, k tomu se dostaneme následně."],"metadata":{"id":"YTq7SBUPSlir"}},{"cell_type":"code","source":["my_set = {1, 2, 3, 4}\n","\n","print(my_set[1])"],"metadata":{"id":"K5XQ8adED0oP"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Přídávání hodnot do setu\n","\n","Pro přidání do setu nám poslouží dvě metody - `add` a `update`.\n","\n","Rozdíl mezi nimi je, že `add` nám přidá novou hodnotu, **jednu**. `update` dokáže přidat do setu hodnoty z dalšího pole a rovnou z nich vybere pouze unikátní hodnoty.\n","\n","\n","```python\n","my_healthy_food = set([\"banana\", \"apple\"])\n","\n","my_healthy_food.add(\"kiwi\")\n","\n","# Výsledek\n","{'apple', 'kiwi', 'banana'}\n","\n","# Přidání listu pomoci metody update\n","vegetables = [\"carrot\", \"carrot\", \"potatoe\", \"tomatoe\"]\n","\n","my_healthy_food.update(vegetables)\n","\n","# Výsledek\n","{'carrot', 'tomatoe', 'potatoe', 'apple', 'kiwi', 'banana'}\n","```"],"metadata":{"id":"tl34SHQIAQGH"}},{"cell_type":"markdown","source":["### Mazání hodnot ze setu\n","\n","Stejně jako `list`, tak i `set` má metodu `remove`, která funguje naprosto stejně.\n","\n","Stejně tak metoda `clear`, která smaže hodnoty ze setu."],"metadata":{"id":"M1Wme-aoCJgQ"}},{"cell_type":"markdown","source":["## Tuple"],"metadata":{"id":"tJRPlRVfSlKQ"}},{"cell_type":"markdown","source":["Tuplem se úplně zabývat nebude, je to specifická datová struktura podobná listu. Můžeme na položky přistupovat pomoci hranatých závorek. Položky se v tuplu nachází v pořadí v jakém byly inicializovány, ale narozdíl od listu je modifikace tuplu složitá a ze správnosti věci by se dít neměla. `Tuple` nám může sloužit například jako konstantní výčet hodnot."],"metadata":{"id":"FNjQmA_JGaav"}},{"cell_type":"markdown","source":["## Dictionary\n","\n","Datová struktura, která obsauje objekty ve formátu `klíč: hodnota`, respektive `key-value pair`. Co to znamená? Rychlé přistupování k objektům pomoci klíče. Můžeme iterovat nad klíči nebo můžeme iterovat nad hodnotami. `Dictionary` je mocná datová struktura, která se používá hojně ve všech programovacích jazycích.\n","\n","Jeho zápis a práce s ním je ale složitější než například s listem, protože je o něco komplexnější než `list`, `set` nebo `tuple`.\n","\n","Jak již bylo zmíněno, `dictionary` inicializuje pomoci složených závorek.\n","\n","```python\n","my_car = {\n","  # následně vytvoříme key-value pair\n","  \"brand\": \"Peugeot\",  # jednotlivé key-value pairy od sebe oddělujeme čárkou\n","  \"year\": 2000,\n","  \"is_electric\": False,\n","  \"defects\": [\"old\", \"rusty\", \"slow\"]\n","}\n","```\n","\n","Jak můžeme vidět, do hodnot můžeme v rámci jednoho objektu ukládat různé datové typy, i ty komplexní. Co se týče klíčů, tak ty mohou být `string` nebo `integer` (celé číslo).\n","\n","Přistupování k hodnotám `dictionary` je možné pomoci hranatých závorek, do kterých zadáme klíč, pro který chceme znát jeho hodnotu. Proto `key-value pair`. Každý klíč má přiřazenou hodnotu. Klíče nemůže existovat bez hodnoty a naopak.\n","\n","```python\n","print(my_car[\"brand\"]) # Peugeot\n","\n","# Lze také použít metodu get\n","print(my_car.get(\"brand\")) # Peugeot\n","```\n","\n","Pomoci stejného zápisu můžeme měni hodnoty pro zadaný klíč\n","\n","```python\n","my_car[\"year\"] = 2001\n","\n","# Lze využít metodu update\n","my_car.update({\"year\": 2001})\n","```\n","\n","Pokud potřebujeme z `dictionary` dostat data, máme několik způsobů.\n","\n","##### Metoda `keys`\n","Pokud chceme dostat z `dictionary` jeho klíče, můžeme na objektu zavolat metodu `keys()`.\n","\n","```python\n","print(my_car.keys())\n","\n","# Výstup\n","dict_keys(['brand', 'model', 'year'])\n","```\n","\n","##### Metoda `values`\n","Pokud ale chceme z `dictionary` dostat všechny jeho hodnoty, tak se nám bude hodit metoda `values()`\n","\n","```python\n","print(my_car.value())\n","\n","# Výstup\n","dict_values(['Peugeot', 2000, False, ['old', 'rusty', 'slow']])\n","```\n","\n","#### Metoda `items`\n","Tato metoda je trochu specifická, vrací nám list tuplů, kde první hodnota je klíč, druhá hodnota je příslušná hodnota. Díky tomu, že je to tuple, tak se `key-value pairy` nedají editovat.\n","\n","```python\n","print(my_car.items())\n","\n","# Výstup\n","dict_items([('brand', 'Peugeot'), ('year', 2000), ('is_electric', False), ('defects', ['old', 'rusty', 'slow'])])\n","```\n","\n","Tyto tři metody mají specifickou vlastnost. Můžete si všimnout, že to není obyčejný list, ale `dict_keys`, `dict_values` a `dict_items`. Tyto tři speciální \"struktury\" slouží jako pohled, ajťácky `view`, na list hodnot. Nad těmito strukturami se dá normálně iterovat pomoci cyklů, ale nejde k nim přistupovat pomoci hrantých závorek a indexu, jak je tomu u listů.\n","\n","```python\n","# Procházení jednotlivých klíču v cyklu ✅\n","for key in my_car.keys():\n","  print(key)\n","\n","# Nefunguje ❌\n","print(my_car.keys()[1])      # error\n","```\n","\n","Magie těchto struktur ale přichází, pokud udělám v objektu změnu, nebo přidáme nový `key-value pair`. Viz spustitelný blok kódu níže."],"metadata":{"id":"ciWK0XYmSrcp"}},{"cell_type":"code","source":["my_car = {\n","  \"brand\": \"Peugeot\",\n","  \"year\": 2000,\n","  \"is_electric\": False,\n","  \"defects\": [\"old\", \"rusty\", \"slow\"]\n","}\n","\n","print(my_car.keys())\n","print(my_car.values())\n","print(my_car.items())\n","\n","my_car[\"color\"] = \"silver\"\n","\n","print(my_car.keys())\n","print(my_car.values())\n","print(my_car.items())"],"metadata":{"id":"7OkVV479Khnc"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["## Kombinování datových struktur dohromady\n","\n","Ano, aby to bylo jednoduché, tak můžeme jednotlivé struktury kombinovat do sebe.\n","\n","List v listu už jsme viděli, ale také můžeme mít list objektů (`dictionaries`), list tuplů atd. Některé kombinace například nedávají smysl.\n","\n","Za nejčastěji používané bych považoval list objektů a vnořené objekty.\n","\n","```python\n","# list objektů\n","my_family = [\n","    { \"name\": \"Jana\", \"role\": \"wife\" },\n","    { \"name\": \"Viktor\", \"role\": \"brother\"},\n","  ]\n","\n","print(my_family)\n","# [{'name': 'Jana', 'role': 'wife'}, {'name': 'Viktor', 'role': 'brother'}]\n","\n","# Zanořené objekty do sebe\n","my_device = {\n","  \"name\": \"Macbook Pro\"\n","  \"display\": {\n","    \"size\": 13,\n","    \"unit_of_measure\": \"inch\",\n","    \"is_retina\": True,\n","    \"resolution\": {\n","      \"width\": 2560,\n","      \"height\": 1600\n","    }\n","  }\n","}\n","\n","# Jak vypíšeme hodnotu z vlastnosti display, rozlišení, výška?\n","\n","print(my_device[\"display\"][\"resolution\"][\"height\"]) # 1600\n","```"],"metadata":{"id":"LB4I3msLjnJR"}},{"cell_type":"code","source":["my_device = {\n","  \"name\": \"Macbook Pro\",\n","  \"display\": {\n","    \"size\": 13,\n","    \"unit_of_measure\": \"inch\",\n","    \"is_retina\": True,\n","    \"resolution\": {\n","      \"width\": 2560,\n","      \"height\": 1600\n","    }\n","  }\n","}\n","\n","display = my_device[\"display\"][\"resolution\"]\n","\n","\n","print(display)"],"metadata":{"id":"yY8-RqGMHrMn"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["# Knihovny aneb `modules`\n","\n","Python jako takový nabízí funkcionalitu, ale můžeme používat i vestavěné moduly, které nám například pomohou s matematickými výpočty – modul `math`. Také existuje modul, který nám pomáhá s výběrem náhodných čísel – `random`. Pak je tu modul `collections`, který si představovat nebudeme, ale pro informaci nabízí práci s datovými strukturami na steroidech.\n","\n","I `pandas`, `numpy` nebo `matplotlib` jsou moduly. Tyto tři už jsou mnohem rozsáhlejší než výše zmiňované dva.\n","\n","Jak se s moduly pracuje? Jejich import by měl být vždy na začátku kódu. K připojení modulu do kódu slouží klíčové slovo `import`, případně `from` specifický `import`.\n","\n","```python\n","import random\n","\n","print(random.randint(1, 10))    # Vypíše náhodné číslo od 1 do 10\n","```\n","\n","Můžeme vidět, že se používá tečka pro přístup k metodě modulu. Jedná se o \"tečkovou notaci\" (`dot notation`).\n","\n","Pokud víme, že potřebujeme jen jednu metodu z celého modulu, můžeme import optimalizovat.\n","\n","```python\n","from random import randint\n","\n","print(randint(1, 10))    # Vypíše náhodné číslo od 1 do 10\n","```\n","\n","Ve všech možných příkladech si můžeme všimnout, že `pandas` se referencuje jako `pd`. Každému importovanému modulu můžeme přiřadit alias pomocí klíčového slova `as`.\n","\n","```python\n","# nastavíme alias pomocí klíčového slova \"as\"\n","import pandas as pd\n","\n","# všude v kódu poté používáme alias \"pd\"\n","pd.DataFrame()\n","```"],"metadata":{"id":"vEAZHPWvBP1-"}}]}