Section_1.2_variables_statements_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.2.0 Zdroje\n",
    "Cílem kurzu je naznačit možnosti využití jazyka Python a vybraných knihoven ve vědecko-technických výpočtech. \n",
    "Vzhledem k velmi omezenému časovému prostoru se můžeme podorbně seznámit jen s velmi omezeným rozsahem nástrojů a postupů, ale pokusím se předložit dostatek literatury a odkazů pro dohledání dalších potřebných detailů. Ostatně vzhledem k velmi rychlému vývoji je nutné být ve střehu a udržovat si přehled průběžně.\n",
    "\n",
    "Bohužel není vůbec pokryta tématika strojového učení, kde je Python hojně používán.\n",
    "\n",
    "Některé níže uvedené knihy je elektronicky možno najít na adrese: \n",
    "\n",
    "`astra.nti.tul.cz (lomeno) ~jan.brezina/vyuka_PAV`\n",
    "\n",
    "Většina kurzu je pokryta knihou (dále citováno jako NP):\n",
    "Robert Johansson: [Numerical Python](https://www.apress.com/gp/book/9781484205549)\n",
    "\n",
    "Ohledně **IPythonu** se můžou hodit některé kapitoly z:\n",
    "Cyrille Rossant: [IPython Interactive Computing ...](https://www.amazon.com/IPython-Interactive-Computing-Visualization-Cookbook/dp/1783284811), [nové vydání 2018](http://ipython-books.github.io/)\n",
    "... kdo se vyleká počtem stránek, tak může použít zkrácenou on-line verzi: [IPython Mini Cookbook](https://github.com/ipython-books/minibook-2nd-code)\n",
    "\n",
    "pro obecnější informace k Jupyteru:\n",
    "Dan Toomey: [Learning Jupiter](https://www.packtpub.com/big-data-and-business-intelligence/learning-jupyter)\n",
    "\n",
    "Pro úvod do jazyka **Python** dobře poslouží:\n",
    "Alen Downey at al. : [Learning with Python](http://www.foo.be/docs-free/thinkCSpy.pdf) \n",
    "pro hlubší studium lze doporučit relativně podrobnou knihu:\n",
    "Mark Lutz: [Learning Python](http://shop.oreilly.com/product/0636920028154.do)\n",
    "\n",
    "Další online zdroje\n",
    "\n",
    "### Další online zdroje\n",
    "[Python data types](http://datasciencefree.com/python.pdf)\n",
    "\n",
    "[numpy](http://datasciencefree.com/numpy.pdf)\n",
    "\n",
    "[numpy cheetsheet](https://medium.com/machine-learning-in-practice/cheat-sheet-of-machine-learning-and-python-and-math-cheat-sheets-a4afe4e791b6)\n",
    "\n",
    "[More Python cheat sheets](https://sinxloud.com/python-cheat-sheet-beginner-advanced/)\n",
    "\n",
    "[PythonForDataScience](https://s3.amazonaws.com/assets.datacamp.com/blog_assets/PythonForDataScience.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.2.1 základní typy a proměnné\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Skalární typy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(a): <class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "# objekt None. Univerzální hodnota pro nic.\n",
    "a = None\n",
    "print(\"type(a):\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(a): <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# Typ bool.\n",
    "a = True\n",
    "a = False\n",
    "print(\"type(a):\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(a): <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Typ int, libovolná velikost\n",
    "a = 1\n",
    "print(\"type(a):\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(a): <class 'float'>\n",
      "1.2246467991473532e-16\n",
      "1.0\n",
      "2.0\n",
      "1.1\n"
     ]
    }
   ],
   "source": [
    "# Typ float.\n",
    "a = 1.0\n",
    "print(\"type(a):\", type(a))\n",
    "\n",
    "# special functions\n",
    "import math\n",
    "print(math.sin(math.pi))\n",
    "print(math.log(math.e))\n",
    "print(math.log10(100))\n",
    "print(abs(-1.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(a): <class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "# Typ complex.\n",
    "a = 1.0 + 2j\n",
    "print(\"type(a):\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(a): <class 'str'> type(b): <class 'str'>\n",
      "\n",
      "Je možno zadávat\n",
      "   i    více řádkové\n",
      "řeťezce\n"
     ]
    }
   ],
   "source": [
    "# Typ string.\n",
    "a = \"1\"\n",
    "b = '1'\n",
    "c = \"\"\"\n",
    "Je možno zadávat\n",
    "   i    více řádkové\n",
    "řeťezce\"\"\"\n",
    "print(\"type(a):\", type(a), \"type(b):\", type(b))\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Konverze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.34\n",
      "134\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(float(\"1.34\"))\n",
    "print(int(\"134\"))\n",
    "print(int(float(\"1.34\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operátory\n",
    "### Aritmetické \n",
    "(pro int, float, complex)\n",
    "\n",
    "`+` (sčítání),  `-` (odčítání),\n",
    "\n",
    "`*` (násobení), `/` (dělení),\n",
    "\n",
    "`%` (modulo - zbytek po dělení), `//` (celočíselné dělení).\n",
    "\n",
    "`**` (umocnění), \n",
    "\n",
    "[Podrobný popis](https://www.tutorialspoint.com/python/python_basic_operators.htm). \n",
    "\n",
    "**Příklady**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.1 // 0.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.1 % 0.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Přiřazovací operátory\n",
    "    \n",
    "`=` přiřazení proměnné,\n",
    "\n",
    "`+=` přičtení `a = a + b`,\n",
    "\n",
    "`-=` odečtení, \n",
    "\n",
    "... \n",
    "\n",
    "### Porovnávací operátory, vracejí 'bool'\n",
    "\n",
    "    ==, !=, <, >, >=, <=\n",
    "    \n",
    "Zde je možno psát zkráceně: \n",
    "    \n",
    "    0 < a <= 1 \n",
    "    \n",
    "místo \n",
    "    \n",
    "    0 < a and a <= 1\n",
    "\n",
    "### bitové operátory \n",
    "\n",
    "    ~ (negace), & (bitový and), | (bitový or), << (rotace vlevo), >> (rotace vpravo)\n",
    "\n",
    "### logické operátory\n",
    "\n",
    "    not, and, or\n",
    "\n",
    "### operátory identity \n",
    "    \n",
    "    is, is not \n",
    "zda dva objekty jsou na stejném místě paměti (identické)\n",
    "    \n",
    "### operátory členství\n",
    "\n",
    "    a in b, a not in b \n",
    "zda  a je prvkem/ není prvkem b (list, set, dictionary, ...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Proměnné \n",
    "\n",
    "- Proměnná je jménem pro objekt (odkaz).\n",
    "- Objekt může mít více jmen.\n",
    "- Pokud objekt nemá žádné jméno, je odstraněn z paměti (Garbage collector).\n",
    "- Některé objekty jsou neměnné (immutable) to jsou objekty typu: int, float, string. Ostaní jsou 'mutable'.\n",
    "\n",
    "Výpis objektů (odkazovaných proměnnými) provedeme pomocí funkce 'print'. IPython také vypíše poslední výraz pokud není přiřazen do proměnné."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a ->  [1]\n",
      "b ->  [1]\n",
      "a ->  [1, 1]\n",
      "b ->  [1, 1]\n"
     ]
    }
   ],
   "source": [
    "# a --> [1]\n",
    "a = [1]\n",
    "# a --> [1] <-- b\n",
    "b = a\n",
    "\n",
    "print(\"a -> \", a)\n",
    "print(\"b -> \", b)\n",
    "\n",
    "# Do pole přidáme prvek.\n",
    "b.append(1)\n",
    "\n",
    "# Přes obě proměnné je dostupné stejné pole, nyní s prvkem '1'.\n",
    "print(\"a -> \", a)\n",
    "print(\"b -> \", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Neměnné objekty (immutable)\n",
    "- tyto objekty nelze změnit, modifikace je provedena na kopii objektu\n",
    "- jsou to skalární typy: `None`, `bool`, `int`, `float`, `complex`, `str`\n",
    "- a typ `tuple` ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a ->  1     b ->  1\n",
      "a ->  2     b ->  1\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = a\n",
    "# a --> 1 <-- b\n",
    "print(\"a -> \", a, \"    b -> \", b)\n",
    "\n",
    "# Zvětšením o jedna neměníme objekt '1', ale přiřadíme proměnné 'a' objekt '2'. \n",
    "a += 1\n",
    "\n",
    "# a --> 2, b --> 1\n",
    "print(\"a -> \", a, \"    b -> \", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Detailnější popis najdete [zde](https://mathieularose.com/python-variables/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Řetězce\n",
    "\n",
    "[podrobný popis](https://www.tutorialspoint.com/python/python_strings.htm) práce s řetězci.\n",
    "\n",
    "[přehled metod](https://docs.python.org/3/library/stdtypes.html#string-methods)\n",
    "\n",
    "[format minilanguage](https://docs.python.org/3/library/string.html#string-formatting) - dokumentace a příklady.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item: 0001 a:   1.23e+04 Plocha: 152415765.28\n",
      "item: 0002 a:   1.23e+00 Plocha:       1.51\n"
     ]
    }
   ],
   "source": [
    "a=1.2345678e4\n",
    "print(\"item: {:04d} a: {:10.2e} Plocha: {:10.2f}\".format(1,a,a**2))\n",
    "# \n",
    "a=1.23\n",
    "print(\"item: {:04d} a: {:10.2e} Plocha: {:10.2f}\".format(2,a,a**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cvičení\n",
    "\n",
    "- spočtěte 2 umocněno na 777\n",
    "- spočtětě odmocninu z -1 v reálných a komplexních číslech\n",
    "- spočtěte $e^i\\pi$\n",
    "- vytiskněte pomocí format: '| 0012 | -45.999    |   8.91-e12 |' pro čísla:\n",
    "  (641, -4 * math.pi, math.exp(-30)), šířky sloupečků: 6, 12, 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1+1.2246467991473532e-16j)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.e ** (1j *math.pi)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.2.2 Příkazy\n",
    "\n",
    "- **Bloky jsou dané odsazením!!**\n",
    "- nepoužívat tab znaky\n",
    "- používat 4 mezery\n",
    "\n",
    "## if\n",
    "\n",
    "    if <condition 1> :\n",
    "        <true block 1>\n",
    "    elif <condition 2> :\n",
    "        <true block 2> :\n",
    "    else:\n",
    "        <false block>\n",
    "        \n",
    "[Podrobný popis podmínek.](https://www.tutorialspoint.com/python/python_decision_making.htm)        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while cyklus\n",
    "\n",
    "    while <condition> :\n",
    "        <block>\n",
    "   \n",
    "Příkzay řízení iterací:\n",
    "\n",
    "`continue` - skočí ihned na další iteraci cyklu\n",
    "`break` - ukončí cyklus a skočí z něj\n",
    "\n",
    "Regulerní ukončení cyklu a ukončení pomocí `break` můžeme rozlišit pomocí bloku `else`:\n",
    "\n",
    "    while <condition> :\n",
    "        <true block>\n",
    "    else:\n",
    "        <end block>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "return: Not found.\n",
      "return: 1000\n"
     ]
    }
   ],
   "source": [
    "# Find first number divisble be N.\n",
    "N=9770\n",
    "start=100\n",
    "end=1000\n",
    "\n",
    "i=start\n",
    "while i<end:\n",
    "    if i%N == 0:\n",
    "        break\n",
    "    i+=1\n",
    "else:\n",
    "    print(\"return: Not found.\")\n",
    "    \n",
    "print(\"return: {}\".format(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkce\n",
    "Definice funkce:\n",
    "    \n",
    "    def func(a, b = None):\n",
    "        <body>\n",
    "        return <expression>\n",
    "        \n",
    "zde má funkce definovány 2 parametry, ale druhý je nepovinný a má výchozí hodnotu None. \n",
    "\n",
    "- Všechny argumenty jsou předávány odkazem (parametry fungují jako ostatní proměnné).\n",
    "- žádný nebo více příkazů `return`; vrátí výsledek výrazu `<expression>`. \n",
    "- Při volání funkce je možno zadávat argumenty pozičně nebo pomocí jména parametru:\n",
    "    \n",
    "      func(2)\n",
    "      func(2, None)\n",
    "      func(b=None, a=2)\n",
    "    \n",
    "  ... jsou ekvivalentní volání. \n",
    "  \n",
    "- Je možno definovat též funkce s proměnným počtem parametrů.\n",
    "- lambda funkce \n",
    "- používejte **docstringy** (viz. příští seance),  Jelikož Python nekontroluje typy, \n",
    "  je naprosto nezbytné v    dokumentaci uvádět nejen co parametry znamenají, ale také jaký mají typ, \n",
    "  pokud to není z kontextu jasné.\n",
    "- [podrobný popis funkcí](https://www.tutorialspoint.com/python/python_functions.htm)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cvičení\n",
    "1. Napište funkci pro výpočet délky/plochy/objemu n-rozměrné krychle/koule\n",
    "    - parametry: rozměr (strana, poloměr), dimenze (1,2,3), tvar ('cube','sphere')\n",
    "    - dimenze bude mit defaultni hodnotu 3, tvar hodnotu 'cube'\n",
    "    - vypíše: 'Míra <jméno tvaru>: <číslo>'\n",
    "    - vrátí výsledek\n",
    "\n",
    "2. Která volání jsou správná a co vrátí, tipujte a pak vyzkoušejte:\n",
    "    \n",
    "        def fce(x, y=1):\n",
    "            return x * y\n",
    "   \n",
    "   1. fce(1, 2)\n",
    "   1. fce(1)\n",
    "   1. fce(y=2)\n",
    "   1. fce(y=0, x=1)\n",
    "   1. fce(x=1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.2.3 Kompozitní typy\n",
    "\n",
    "## List\n",
    "\n",
    "- dynamické pole (lze přidávat a ubírat prvky), $O(1)$ amortizovaná složitost\n",
    "- přístup k prvkům přes souvislou množinu `int` indexů, $O(1)$\n",
    "\n",
    "[Podrobný popis](https://www.tutorialspoint.com/python/python_lists.htm)\n",
    "\n",
    "`len(list)` - délka pole \n",
    "\n",
    "`list.append(x)` - přidání objektu `x` na konec pole\n",
    "\n",
    "`pop(i)` -  odebrání prvku z pole (složitost až $O(n)$), `pop(0)` a `pop(-1)` mají konstantní složitost\n",
    "\n",
    "`list.extend(other_list)` - připojení listu `other_list`\n",
    "\n",
    "`list.sort(...)` - setřídní pole, [popis](https://www.tutorialspoint.com/python/list_sort.htm)\n",
    "\n",
    "`sum(list)`, `min(list)`, `max(list)` - pro pole prvků které lze: sčítat resp. porovnávat \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]  len:  4\n",
      "[1, 1.2, None, [1, 2]]\n",
      "sum:  6\n",
      "min: a\n"
     ]
    }
   ],
   "source": [
    "# Pole lze vytvořit pomocí hranatých závorek.\n",
    "a = [1, 2, 3]\n",
    "# Přidáme prvek.\n",
    "a.append(4)\n",
    "print(a, \" len: \", len(a))\n",
    "\n",
    "# Prvky mohou mít libovolný typ\n",
    "print([1, 1.2, None, [1, 2]])\n",
    "\n",
    "# sum, min\n",
    "print(\"sum: \", sum([1,2,3]))\n",
    "print(\"min:\",min(['b', 'a', 'c']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexování\n",
    "`list[i]` - prvek na pozici `i` (od 0)\n",
    "\n",
    "`list[-i]` - záporné indexy pro indexování od konce (`list[len(list) - i]`)\n",
    "\n",
    "`list[i:j]` - slice, podseznam od pozice `i` (včetně) do pozice `j` (mimo)\n",
    "\n",
    "`list[i:j:k]` - od `i` po `j` s krokem `k`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[-2] =  3\n",
      "a[1:3] =  [2, 3]\n",
      "a[:-2] =  [1, 2]\n"
     ]
    }
   ],
   "source": [
    "# Slicing\n",
    "print(\"a[-2] = \", a[-2])\n",
    "print(\"a[1:3] = \", a[1:3])\n",
    "print(\"a[:-2] = \", a[:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple\n",
    "- 'immutable' varianta listu\n",
    "- funkce vracející více hodnot:\n",
    "\n",
    "        def div(a, b):\n",
    "           \treturn a/b, a%b\n",
    "- zabalení, rozbalení:\n",
    "     \t\n",
    "        fraction, reminder = div(3,2)\n",
    "        \n",
    "- násobná přiřazení:\n",
    "\n",
    "      \tf, g = f**2, f\n",
    "\n",
    "- [Popis.](https://www.tutorialspoint.com/python/python_tuples.htm)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'first')\n",
      "1 first\n"
     ]
    }
   ],
   "source": [
    "# Tuple, vytvoříme pomocí kulatých závorek. Pevná délka i obsah.\n",
    "b = (1, \"first\")\n",
    "print(b)\n",
    "\n",
    "x, y = b\n",
    "print(x, y)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-25-b93ae844cef5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Změna tuplu je chyba:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mb\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# Změna tuplu je chyba:\n",
    "\n",
    "b[1] = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dict\n",
    "\n",
    "- obecné zobrazení klíč --> hodnota\n",
    "- implementace pomocí hashů, přístup k prvkům průměrně v čase $O(1)$\n",
    "- klíčem může být libovolný immutable objekt, nebo objekt s metodu `__hash__()`\n",
    "- přiřazené hodnoty mohou být libovolnho typu\n",
    "- `dict.get(key, default)` vrátí hodnotu klíče `key` pokud existuje, jinak `default`\n",
    "- `dict.setdefault(key, default)` pokud klíč `key` neexistuje nastav na `default` \n",
    "- [Podrobný popis](https://www.tutorialspoint.com/python/python_dictionary.htm)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a['Name'] :  Zara\n",
      "Před smazáním: {'Name': 'Zara', 'Age': 7, 'Weight': 56.67, 'Friends': ['Dita', 'Ema']}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'Age': 7, 'Weight': 56.67, 'Friends': ['Dita', 'Ema'], 'ID': 123}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Vytvoření pomocí složených závorek.\n",
    "a = {'Name': 'Zara', 'Age': 7, 'Weight': 56.67, 'Friends': ['Dita', 'Ema']}\n",
    "\n",
    "# Vytvoření pomocí konstruktoru, méně psaní pro klíče typu string.\n",
    "a = dict(Name='Zara', Age=7, Weight=56.67, Friends=['Dita', 'Ema'])\n",
    "\n",
    "# Přístup přes klíč.\n",
    "print(\"a['Name'] : \", a['Name'])\n",
    "\n",
    "print(\"Před smazáním:\", a)\n",
    "# Smazání klíče a hodnoty.\n",
    "del a['Name']\n",
    "\n",
    "a['ID'] = 123\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "get:  175 7\n",
      "{'Age': 7, 'Weight': 56.67, 'Friends': ['Dita', 'Ema'], 'ID': 123, 'Height': 175}\n",
      "{'Age': 7, 'Weight': 56.67, 'Friends': ['Dita', 'Ema'], 'ID': 123, 'Height': 175}\n"
     ]
    }
   ],
   "source": [
    "print(\"get: \", a.get('Height', 175), a.get('Age', 18))\n",
    "\n",
    "# No change after get\n",
    "print(a)\n",
    "a.setdefault('Age', 18)\n",
    "a.setdefault('Height', 175)\n",
    "\n",
    "# No change to Age, Height set\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set\n",
    "\n",
    "- jako pouze klíče z dict:\n",
    "   \n",
    "      { 3, 5, 7 }\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for cyklus\n",
    "\n",
    "   \n",
    "- Základní syntaxe: `x` potupně nabývá hodnot ze sekvence `seq`.\n",
    "\n",
    "        for x in seq:\n",
    "            <block>\n",
    "        \n",
    "- příkazy `break`, `continue` stejně jako u `while`\n",
    "\n",
    "\n",
    "- `else` konstrukce jako u `while`\n",
    "\n",
    "        for x in set:\n",
    "            <block>\n",
    "        else:\n",
    "            <end block>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  2  3  "
     ]
    }
   ],
   "source": [
    "for i in [1,2,3]:\n",
    "    print(i, \" \", end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sekvence - generátory\n",
    "\n",
    "- `range(start, stop, step)` - iteruje přes posloupnost `int` hodnot\n",
    "- `enumerate(seq)` - iteruje: [(index, hodnota), ...]\n",
    "- `reversed` - iteruje list pozátku\n",
    "- `dict.values` - iteruje přes hodnoty `dict`, neurčené pořadí\n",
    "- `dict.items` - iteruje: `[ (klic, hodnota), ...]\n",
    "- `zip(a, b)` - iteruje: `[ (a hodnota, b hodnota), ...]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2  4  6  8  "
     ]
    }
   ],
   "source": [
    "for i in range(2, 10, 2):\n",
    "    print(i, \" \", end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 3)\n",
      "[0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "# generátor není list:\n",
    "print(range(3))\n",
    "# ale může naplnit list\n",
    "print(list(range(3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 :  Adam\n",
      "1 :  Barbora\n",
      "2 :  Cyril\n"
     ]
    }
   ],
   "source": [
    "for i, name in enumerate(['Adam', 'Barbora', 'Cyril']):\n",
    "    print(i, \": \", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3  2  1  "
     ]
    }
   ],
   "source": [
    "for i in reversed([1,2,3]):\n",
    "    print(i, \" \", end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  2  3  "
     ]
    }
   ],
   "source": [
    "for i in sorted([2, 3, 1]):\n",
    "    print(i, \" \", end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keys: \n",
      "Name  Age  Weight  Friends  \n",
      "\n",
      "Values: \n",
      "Zara  7  56.67  ['Dita', 'Ema']  \n",
      "\n",
      "Items: \n",
      "('Name', 'Zara')('Age', 7)('Weight', 56.67)('Friends', ['Dita', 'Ema'])"
     ]
    }
   ],
   "source": [
    "d = dict(Name='Zara', Age=7, Weight=56.67, Friends=['Dita', 'Ema'])\n",
    "print(\"Keys: \")\n",
    "for key in d:\n",
    "    print(key, \" \", end='')\n",
    "    \n",
    "print(\"\\n\\nValues: \")    \n",
    "for value in d.values():\n",
    "    print(value, \" \",  end='')\n",
    "    \n",
    "print(\"\\n\\nItems: \")        \n",
    "for key, value in d.items():\n",
    "    print((key, value), end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "# zip generátor\n",
    "A = [1, 2, 3]\n",
    "B = [4, 5, 6]\n",
    "C = []\n",
    "for a, b in zip(A, B):\n",
    "    C.append(a + b)\n",
    "\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 4), (2, 5), (3, 6)]\n",
      "(1, 2, 3)\n",
      "(4, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "# zip lze použít i inverzně\n",
    "C = list(zip(A, B))\n",
    "print(C)\n",
    "X, Y = zip(*C)\n",
    "print(X)\n",
    "print(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehensions\n",
    "Efektivní zápis filtrování a transformací listů, množin a adresářů.\n",
    "Pro tvorbu listů:\n",
    "\n",
    "    [ <expression> for x in seq if <condition> ]\n",
    "    \n",
    "Pro každý prvek `x` v sekvenci `seq` který splňuje `<condition>` se vyhodnotí `<expression>` a přidá se do nového pole. Podobně lze tvořit množiny a dictionary. \n",
    "[Podrobný popis a příklady.](http://python-3-patterns-idioms-test.readthedocs.io/en/latest/Comprehensions.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 9, 25}\n"
     ]
    }
   ],
   "source": [
    "# Druhé mocniny lichých čísel.\n",
    "print({ i**2 for i in range(7) if i%2 == 1 })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_sequence( a, b, step=1, power = 1):\n",
    "    \"\"\"\n",
    "    Make a sequence a**p, ..., b**p.\n",
    "    :param a: float, first value base\n",
    "    :param b: float, end value base (last base is less then b)\n",
    "    :param step: float, step of base values\n",
    "    :param power: float, common power of resulting values\n",
    "    :return ...\n",
    "    \"\"\"\n",
    "    x = a\n",
    "    sequence = []\n",
    "    while x < b:\n",
    "        sequence.append(x**power)\n",
    "        x += step\n",
    "    return sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.1, 2.1, 3.1]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_sequence(1.1, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.1, 3.1, 5.1, 7.1, 9.1]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_sequence(1.1, 10, step = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 9, 25, 49, 81]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_sequence(1, 10, step = 2, power=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Čtení a zápis souborů\n",
    "\n",
    "Čtení všech řádek ze souboru:\n",
    "\n",
    "    with open(\"file.txt\", \"r\") as f:\n",
    "        all_lines = f.readlines()\n",
    "\n",
    "`with` je tzv. kontext manager a v tomto případě zajisí uzavření souboru. Je to ekvivalentní:\n",
    "\n",
    "    f = open(\"file.txt\", \"r\") # otevření souboru pro čtení\n",
    "    all_lines = f.readlines()\n",
    "    f.close()\n",
    "\n",
    "Postupné zpracování všech řádek souboru:\n",
    "    \n",
    "    with open(\"file.txt\", \"r\") as f:    \n",
    "        for line in f:\n",
    "            process_line(line)\n",
    "            \n",
    "Zápis do souboru:\n",
    "\n",
    "        with open(\"file.txt\", \"w\") as f: # otevření souboru pro zápis\n",
    "            f.write(\"Jedna řádka\\n\")\n",
    "            \n",
    "[Podrobný popis](https://www.tutorialspoint.com/python/python_files_io.htm)\n",
    "zahrnuje: další příznaky při otevírání souboru, nastavování pozice v souboru, práci s adresáři\n",
    "\n",
    "Načítání a ukládání ve formátu JSON:\n",
    "   - import json\n",
    "   - data = json.load(f)\n",
    "   - json.dump(f, data)\n",
    "   - podobně pro formát YAML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/jb/Vyuka/PAV_course/PythonForAll\n",
      "{'1': 34, '2': ['list'], '3': None}\n"
     ]
    }
   ],
   "source": [
    "!pwd\n",
    "import json\n",
    "with open('file.json', 'r') as f:\n",
    "    data = json.load(f)\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cvičení\n",
    "\n",
    "## Struktury\n",
    "- zkuste najít jak lze provést spojení dvou listů do nového, a jak připojit jeden list k druhému\n",
    "- zkuste co nemůže být klíčem v dictionary, najděte alespoň 3 příklady objektů různého typu\n",
    "- opravte následující kód"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}\n",
    "empty = []\n",
    "for i in range(10):\n",
    "    key = i % 3\n",
    "    d.setdefault(key, empty)\n",
    "    d[key].append(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "- napište funkci, která sečte dva stejně dlouhé listy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## Faktoriály\n",
    "- napište funkci, která spočte faktoriál čísla $n$\n",
    "- vypište faktoriály pro $n<30$, které začínají cifrou 5\n",
    "- vypište faktoriály, které začínají cifrou 5\n",
    "\n",
    "## Zpracování dat\n",
    "- načtěte data ze souboru [MOCK_DATA.json](./MOCK_DATA.json)\n",
    "- data mají strukturu: list of dicts; vypište si prvních 5 položek seznamu\n",
    "- napište funkci, která pro řeťezec IP adresy převede na tuple 4 intů, najděte si `str.split`\n",
    "- vypište záznamy jejichž IP začíná 147 nebo 22\n",
    "\n",
    "## Other\n",
    "1. Napište funkci, která vrátí list obsahující prvky Fibonačiho posloupnosti menší než $n$. \n",
    "Napište funkci, která vrátí list obsahující prvky Fibonačiho posloupnosti menší než $n$. \n",
    "Napište funkci pro zápis přirozeného čísla v římské notaci.\n",
    "2. \n",
    "3. Napište funkci, která pro dva seznamy vrátí True pokud obsahují alespoň jeden společný prvek.\n",
    "3. Napište funkci která načte data ze souboru . Zjistěte jaká je struktura dat.\n",
    "4. Napište funkci `row_format`, která pro dict jednoho záznamu a tuple `width` tří intů zformátuje řetězec obsahující: \n",
    "   email, id zapsáno   římsky, ip_address. Příslušné podřetězce `s1`, `s2`, `s3` jsou doplněné zleva mezerami, tak aby\n",
    "   řetězec $s_i$ měl šířku `width[i]`. Viz. metody `ljust`, `rjust`.\n",
    "5. Z načtených dat vyberte ty záznamy, jejichž IP adresa (složená ze 4 čísel) obsahuje nějaké Fibonachiho číslo.\n",
    "6. Pro vybrané záznamy vystupte email, id a ip_address do souboru \"output.txt\" ve formě tabulky, tak aby každý ze tří\n",
    "   sloupců byl zarovnaný vpravo. K tomu použijete funkci `row_format`. Nejprve projděte všechny řádky, pro každý \n",
    "   určete šířky tří vystupovaných položek bez doplňování mezerami, pro každý sloupec určíte maximální šířku. Tyto\n",
    "   maximální šířky použijete jako parametr `width` funkce `row_format` při druhém průchodu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       " 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n",
       " 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {}\n",
    "l = []\n",
    "for i in range(10):\n",
    "    key = i % 3\n",
    "    d.setdefault(key, l)\n",
    "    d[key].append(i)\n",
    "d"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}