{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cvičení č. 3 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2026/27)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Jak efektivně psát na klávesnici – určitě všichni ovládáme nebo alespoň procvičujeme *psaní všemi deseti* 😃\n",
    "- Jak jsou kódovaná data v paměti počítače\n",
    "- Jak zadávat číselné hodnoty – převod textu získaného pomocí funkce `input` na číslo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkce `input` _vždy vrátí textový objekt_, i když uživatel zadá číslo.\n",
    "Pokud chceme získat _číselný objekt_, musíme použít příslušnou funkci, která získá číselnou hodnotu z textu:\n",
    "\n",
    "- funkce `int` vrátí celé číslo:\n",
    "    ```python\n",
    "    a = int(input(\"Zadej celé číslo:\"))\n",
    "    ```\n",
    "- funkce `float` vrátí \"reálné\" číslo:\n",
    "    ```python\n",
    "    a = float(input(\"Zadej libovolné reálné číslo:\"))\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datové typy a zápis hodnot v Pythonu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V této sekci si ukážeme použití základních aritmetických typů v jazyku Python (`bool`, `int`, `float`, `complex`), podporované operátory a převod mezi různými typy.\n",
    "Naopak práci s textovými řetězci (typ `str`) odložíme na později.\n",
    "\n",
    "![](images/03/standard-type-hierarchy-numbers.svg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 je typu <class 'int'>\n",
      "5.3 je typu <class 'float'>\n",
      "5 je typu <class 'str'>\n",
      "True je typu <class 'bool'>\n",
      "None je typu <class 'NoneType'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# každá hodnota nebo proměnná má nějaký datový typ (např. `bool`, `int`, `float`, `str`)\n",
    "# typ proměnné interpret určí automaticky\n",
    "# abychom zjistili, jakého je nějaká proměnná typu, můžeme použít funkce `type` a `isinstance`\n",
    "a = 5\n",
    "print (a, \"je typu\", type(a))\n",
    "b = 5.3\n",
    "print (b, \"je typu\", type(b))\n",
    "c = \"5\"\n",
    "print (c, \"je typu\", type(c))\n",
    "d = True\n",
    "print (d, \"je typu\", type(d))\n",
    "e = None\n",
    "print (e, \"je typu\", type(e))\n",
    "type(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "zadej hodnotu 45\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# připomenutí: funkce input vrací vždy str:\n",
    "x = input(\"zadej hodnotu\")\n",
    "print(x)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6666666666666667\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# výsledek operace může být jiného typu než operandy:\n",
    "x = 5 / 3\n",
    "print(x)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5 > 3\n",
    "print(x)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typ `bool` a speciální hodnota `None`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typ `bool` je datový typ umožňující reprezentovat pravdivostní hodnoty _pravda_ (_true_) a _nepravda_ (_false_), které se v jazyku Python zapisují pomocí konstant `True` a `False` (pozor na velká písmena!).\n",
    "Dále je možné použít funkci `bool` pro převod jiných datových typů a používat logické operátory `and`, `or`, `not`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# definice proměnné typu bool\n",
    "a = True\n",
    "b = False\n",
    "print(a, b)\n",
    "\n",
    "# operátory and, or, not\n",
    "(a and b) or not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "c = a and (not a or True)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False False False\n",
      "True True True\n",
      "True True True\n"
     ]
    }
   ],
   "source": [
    "# převod hodnot na bool:\n",
    "# na bool mohu převádět jiné datové typy:\n",
    "# 0 nebo 0.0     -> False\n",
    "# nenulové číslo -> True\n",
    "\n",
    "# prázdný string             -> False\n",
    "# jakýkoliv neprázdný string -> True\n",
    "\n",
    "print(bool(0),  bool(0.0),  bool(\"\"))\n",
    "print(bool(13), bool(2.5), bool(\"cokoliv\"))\n",
    "print(bool(-1), bool(-1.0), bool(\"0\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a = True\n",
    "b = 0\n",
    "print(a and not bool(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# pozor!\n",
    "print(bool(\"False\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0.0 False\n",
      "1 1.0 True\n"
     ]
    }
   ],
   "source": [
    "# převod z bool na int, float, str:\n",
    "a = False\n",
    "print(int(a), float(a), str(a))\n",
    "\n",
    "a = True\n",
    "print(int(a), float(a), str(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# operátory porovnání: == , != , < , > , >= , <="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True <class 'bool'>\n",
      "True False True False False True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 4\n",
    "\n",
    "a = x > y\n",
    "print(a, type(a))\n",
    "\n",
    "print(x > y, x < y, x >= y, x <= y, x == y, x != y)\n",
    "\n",
    "print ( (x > y) and not (y < 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__K zamyšlení a vyzkoušení:__ jaké další operátory jsou v Pythonu k dispozici pro hodnoty typu `bool`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V jazyku Python existuje další hodnota reprezentovaná konstantou `None`, která představuje \"prázdnou\" hodnotu.\n",
    "Lze ji použít např. pro inicializaci proměnné, kterou budeme dále v programu potřebovat, ale zatím pro ni nemáme žádnou užitečnou hodnotu.\n",
    "Hodnota `None` také může sloužit k zavedení ternární logiky v programu, ale na rozdíl od hodnot `True` a `False` má svůj vlastní typ (ne `bool` ani `int`, ale `NoneType`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# speciální hodnota None ... pro \"prázdnou\" hodnotu (typu NoneType)\n",
    "x = None\n",
    "print(x)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ahoj\n",
      "None\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# funkce print vrací hodnotu None:\n",
    "x = print(\"ahoj\")\n",
    "print(x)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typ `int`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typ `int` je datový typ pro reprezentaci celých čísel.\n",
    "Přípustné hodnoty jsou např. `0`, `1`, `2`, `3`, ..., a dále `-1`, `-2`, `-3`, ...\n",
    "Celá čísla se ve zdrojovém kódu jazyka Python běžně zadávají v desítkové soustavě, jako např.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123456789 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = 123456789\n",
    "print(a, type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Omezení na zápis celých čísel ve zdrojovém kódu jsou v zásadě dvě: číselný zápis nesmí začínat nulou a mezi číslicemi nesmí být mezery:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers (1225713507.py, line 1)",
     "output_type": "error",
     "traceback": [
      "  \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[42]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31ma = 01\u001b[39m\n        ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers\n"
     ]
    }
   ],
   "source": [
    "a = 01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2267069512.py, line 1)",
     "output_type": "error",
     "traceback": [
      "  \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[43]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31ma = 123 456\u001b[39m\n            ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "a = 123 456"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naopak mezi číslicemi může vystupovat znak `_`, který slouží jako oddělovač pro člověka významných číslic, podobně jako např. mezery v zápisu telefonního čísla.\n",
    "Jakýkoliv výskyt znaku `_` však nezmění číselnou hodnotu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2123456\n",
      "77888899\n"
     ]
    }
   ],
   "source": [
    "print(2_123_456)\n",
    "print(77_888_8_99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zápis čísel v jiných soustavách"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kromě desítkové soustavy lze pro zápis čísel v jazyku Python použít také dvojkovou (binární), osmičkovou nebo šestnáctkovou (hexadecimální) soustavu.\n",
    "Pro odlišení od desítkového zápisu se používají prefixy `0b`, `0o` a `0x`, za kterými následují číslice příslušné soustavy, přičemž první číslice za prefixem může být 0:\n",
    "\n",
    "- dvojková: `0b01`\n",
    "- osmičková: `0o01234567`\n",
    "- šestnáctková: `0x0123456789abcdef`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b101"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V libovolné soustavě také můžeme použít oddělovač číslic `_` pro zlepšení čitelnosti kódu, např.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22699\n"
     ]
    }
   ],
   "source": [
    "print(0b1011000_10101011)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Všimněte si, že rozlišení číselných soustav vystupuje pouze na úrovni zdrojového kódu.\n",
    "Jak bylo řečeno, interně program pracuje vždy se dvojkovou soustavou.\n",
    "Naopak pro výstup jazyk Python používá desítkovou reprezentaci dané hodnoty (pokud mu neřekneme jinak):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "9\n",
      "17\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(11)\n",
    "print(0o11)\n",
    "print(0x11)\n",
    "print(0b11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uměli byste sami převést číslo do desítkové soustavy?\n",
    "0b1101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "58"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0o72"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid digit '9' in octal literal (2723645382.py, line 1)",
     "output_type": "error",
     "traceback": [
      "  \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[21]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31m0o92\u001b[39m\n      ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m invalid digit '9' in octal literal\n"
     ]
    }
   ],
   "source": [
    "# chyba: číslice 9\n",
    "0o92"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0o101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0xF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0x12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "257"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0x101"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "162"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0xA2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pokud chceme vytisknout reprezentaci čísla v jiné soustavě než desítkové, můžeme použít některou z funkcí `bin`, `oct` a `hex`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b1010 0o12 0xa\n"
     ]
    }
   ],
   "source": [
    "print(bin(10), oct(10), hex(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b1011\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pozor, fce bin, oct, dec, vrací textový řetězec, ne číslo\n",
    "s = bin(11)\n",
    "print(s)\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b1011\n",
      "0o21\n",
      "0xf\n"
     ]
    }
   ],
   "source": [
    "print(bin(11))\n",
    "print(oct(0x11))\n",
    "print(hex(0b1111))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Všechny tři funkce však vrací textový řetězec (typ `str`, na který se podrobně podíváme později), ale jako vstup očekávají číslo (typ `int`).\n",
    "Nelze je tedy skládat, např. výrazy jako `hex(bin(1))` nebo `oct(hex(1))` nebudou fungovat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object cannot be interpreted as an integer",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mTypeError\u001b[39m                                 Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[29]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;66;03m# nefunguje:\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[38;5;28;43mhex\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mbin\u001b[39;49m\u001b[43m(\u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[31mTypeError\u001b[39m: 'str' object cannot be interpreted as an integer"
     ]
    }
   ],
   "source": [
    "# nefunguje:\n",
    "hex(bin(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Příklad\n",
    "\n",
    "Napište program, který se uživatele zeptá na celé číslo v desítkové soustavě a vypíše ho v binární, osmičkové a šestnáctkové soustavě"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej cele cislo 45\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "binární:      0b101101\n",
      "osmičková:    0o55\n",
      "šestnáctková: 0x2d\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Zadej cele cislo\")\n",
    "x = int(s)\n",
    "# x = int(input(\"Zadej cele cislo\"))\n",
    "\n",
    "print(\"binární:     \", bin(x))\n",
    "print(\"osmičková:   \", oct(x))\n",
    "print(\"šestnáctková:\", hex(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aritmetické operátory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S číselnými hodnotami můžeme provádět různé aritmetické operace.\n",
    "V Pythonu jsou k dispozici tyto aritmetické operátory:\n",
    "\n",
    "Operace | Výsledek\n",
    "--------|---------\n",
    "`x + y` | součet hodnot $x$ a $y$\n",
    "`x - y` | rozdíl hodnot $x$ a $y$\n",
    "`x * y` | součin hodnot $x$ a $y$\n",
    "`x / y` | podíl hodnot $x$ a $y$\n",
    "`x // y` | celočíselný podíl hodnot $x$ a $y$\n",
    "`x % y` | zbytek po celočíselném dělení hodnot $x$ a $y$\n",
    "`-x` | hodnota $-x$\n",
    "`+x` | hodnota $x$\n",
    "`x ** y` | $x^y$ ($x$ \"na\" $y$)\n",
    "\n",
    "Jak uvidíme na dalších cvičeních, některé z těchto operátorů lze použít i pro hodnoty nečíselných typů, kde ale mají jiný význam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# příklad na unární plus\n",
    "6 * +5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-402"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# příklad na unární minus \n",
    "x = 67\n",
    "6 * -x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# výsledek použití operátoru / je vždy float\n",
    "6 / 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# chci-li int, použiju //\n",
    "6 // 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Příklad\n",
    "\n",
    "**Přesný čas**\n",
    "\n",
    "- Napište program, který zadaný čas ve vteřinách vypíše v hodinách, minutách a vteřinách. Případně i ve dnech a rocích.\n",
    "- Napište program, který zadaný čas ve dnech, hodinách, minutách a vteřinách vypíše ve vteřinách."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 125 vteřin .. 0 hodin, 2 minuty a 5 vteřin\n",
    "# 3723 vteřin -> 1 h, 2 m 3 s  ..... 3723 = 3600 + 120 + 3\n",
    "# nejdrive vteriny -> minuty + zbyle vteriny\n",
    "# // %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej čas ve vteřinách 3723\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cas je 3723 vteřin.\n"
     ]
    }
   ],
   "source": [
    "vteriny = int(input(\"Zadej čas ve vteřinách\"))\n",
    "print(\"Čas je\", vteriny, \"vteřin.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "62\n",
      "Výsledek je 62 minut a 3 vteřin.\n"
     ]
    }
   ],
   "source": [
    "minuty = vteriny // 60\n",
    "print(minuty)\n",
    "zbyle_vteriny = vteriny - minuty * 60\n",
    "print(\"Výsledek je\", minuty, \"minut a\", zbyle_vteriny, \"vteřin.\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Výsledek je 62 minut a 3 vteřin.\n"
     ]
    }
   ],
   "source": [
    "minuty = vteriny // 60\n",
    "zbyle_vteriny = vteriny % 60\n",
    "print(\"Výsledek je\", minuty, \"minut a\", zbyle_vteriny, \"vteřin.\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Výsledek je 1 hodin, 2 minut a 3 vterin.\n"
     ]
    }
   ],
   "source": [
    "minuty = vteriny // 60\n",
    "zbyle_vteriny = vteriny % 60\n",
    "hodiny = minuty // 60\n",
    "zbyle_minuty = minuty % 60\n",
    "print(\"Výsledek je\", hodiny, \"hodin,\", zbyle_minuty, \"minut a\", zbyle_vteriny, \"vterin.\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej počet vteřin 94614548\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Výsledek je 1095 dnů 1 hodin 49 minut a 8 vteřin.\n"
     ]
    }
   ],
   "source": [
    "# 125 vteřin .. 0 hodin, 2 minuty a 5 vteřin\n",
    "celkem_vterin = int(input(\"Zadej počet vteřin\"))\n",
    "\n",
    "celkem_minut = celkem_vterin // 60\n",
    "zbylych_vterin = celkem_vterin % 60\n",
    "\n",
    "celkem_hodin = celkem_minut // 60\n",
    "zbylych_minut = celkem_minut % 60\n",
    "\n",
    "celkem_dnů = celkem_hodin // 24\n",
    "zbylych_hodin = celkem_hodin % 24\n",
    "\n",
    "# obdobně pro roky ... dělím 365\n",
    "\n",
    "print(\"Výsledek je\", celkem_dnů, \"dnů\", zbylych_hodin, \"hodin\", zbylych_minut, \"minut a\",  zbylych_vterin, \"vteřin.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej počet vteřin 8\n",
      "Zadej počet minut 49\n",
      "Zadej počet hodin 1\n",
      "Zadej počet dnů 0\n",
      "Zadej počet roků 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Celkem 94614548 vteřin.\n"
     ]
    }
   ],
   "source": [
    "vteřin = int(input(\"Zadej počet vteřin\"))\n",
    "minut = int(input(\"Zadej počet minut\"))\n",
    "hodin =  int(input(\"Zadej počet hodin\"))\n",
    "dnu =  int(input(\"Zadej počet dnů\"))\n",
    "roku = int(input(\"Zadej počet roků\"))\n",
    "\n",
    "# typické řešení:\n",
    "celkem = vteřin + 60*minut + 60*60*hodin + 60*60*24*dnu + 60*60*24*365*roku \n",
    "print(\"Celkem\", celkem, \"vteřin.\")                      \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typ `float`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typ `float` je datový typ pro reprezentaci \"reálných\" čísel.\n",
    "Tyto hodnoty můžeme ve zdrojovém kódu zapsat pomocí běžného zápisu s desetinnou tečkou, např. `1.5`, `2.0` nebo `2.` (výraz `2.` je ekvivalentní `2.0` a je _různý_ od `2`).\n",
    "Stejně jako v případě celých čísel i pro hodnoty typu `float` můžeme používat oddělovač `_`, a to jak před desetinnou tečkou, tak i za ní:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 2.3\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = .5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5.\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1234.5678\n"
     ]
    }
   ],
   "source": [
    "print(1_234.567_8)   # libovolně mohu prokládat _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kromě zápisu v klasickém tvaru s desetinnou tečkou můžeme pro zápis \"reálných\" čísel použít tzv. _exponentový_ tvar, ve kterém použijeme písmeno `e` nebo `E`, za něž zapíšeme číslo oznamující, kolikátou mocninou deseti se má vynásobit číslo zadané vlevo od znaku `e`, resp. `E`.\n",
    "Python tento tvar používá také v některých případech pro výpis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.123\n",
      "123000.0\n"
     ]
    }
   ],
   "source": [
    "# exponentový tvar: s e/E (číslo násobíme mocninami deseti)\n",
    "print(123e-3)\n",
    "print(123e3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.2345678901234568e+28\n",
      "1e-10\n"
     ]
    }
   ],
   "source": [
    "# exponentový tvar bude i u výpisu:\n",
    "print(123_456_789_0_123_456_789_0_123_456_789.)\n",
    "print(1/10000000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Všimněte si, že při výpisu posledního čísla Python nevypsal všechny číslice, které se vyskytují v zápisu čísla ve zdrojovém kódu.\n",
    "To ale neznamená, že s nimi program nepracuje.\n",
    "Při převodu desetinného čísla do dvojkové soustavy a uložení v paměti počítače sice může dojít k zaokrouhlení, ale k dalšímu zaokrouhlení s ještě menší přesností dochází při výpisu čísla v desítkové soustavě.\n",
    "Toto chování je kvůli pohodlí uživatele. Později si ukážeme, jak ovlivnit přesnost vypisovaných čísel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S hodnotami typu `float` můžeme provádět všechny aritmetické operace stejně jako pro typ `int`, viz [tabulka výše](#Aritmetické-operátory).\n",
    "\n",
    "__K zamyšlení a vyzkoušení:__ jak funguje celočíselné dělení pro necelá čísla?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43.0"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "430. / 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.99999999999999"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# zaokrouhlovací chyba:\n",
    "4.3 / 0.1 #== 43"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.882117688026186"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.5 ** 2.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43.0 2.1000000000000227\n"
     ]
    }
   ],
   "source": [
    "print(432.1 // 10, 432.1 % 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43.0 0.02099999999999949\n"
     ]
    }
   ],
   "source": [
    "print(4.321 // 0.1, 4.321 % 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0 3.4000000000000057\n"
     ]
    }
   ],
   "source": [
    "print(123.4 // 10, 123.4 % 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1233.0 0.09999999999999884\n"
     ]
    }
   ],
   "source": [
    "print(123.4 // 0.1, 123.4 % 0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Číselné hodnoty můžeme v programu převádět z typu `int` na typ `float` a opačně.\n",
    "Explicitní převod typu pro danou hodnotu vyvoláme, pokud `int` nebo `float` použijeme jako funkci:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(int(1.5))\n",
    "print(float(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# k převodu z int na float někdy dojde automaticky při aritmetických operacích:\n",
    "4 / 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.0"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5.0 + 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 4\n",
    "x * 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# k převodu mezi int a float mohu použít funkce `int` a `float`\n",
    "float(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(3.6)   # zaokrouhlí vždy k 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(-3.6)   # zaokrouhlí vždy k 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(-3.6) # zaokrouhlí k nejbližšímu celému číslu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(True) # bool -> float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(\"1.3\") # str -> float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "378.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float('3.78e2')  # str -> float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "K převodu typu může dojít také implicitně, např. pokud sčítáme hodnotu typu `int` s hodnotou typu `float`, přičemž výsledek bude \"většího\" typu `float`.\n",
    "\n",
    "Všimněte si, že funkce `int` zaokrouhluje vždy směrem dolů, tj. odsekne a zahodí desetinnou část daného čísla.\n",
    "Pokud chceme zaokrouhlení směrem k nejbližšímu celému číslu, poslouží nám funkce `round`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2\n"
     ]
    }
   ],
   "source": [
    "print(round(-1.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matematické funkce a konstanty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kromě aritmetických operátorů je často potřeba při práci s číselnými hodnotami použít nějakou matematickou funkci.\n",
    "Nejzákladnější funkce `abs`, `min` a `max` jsou v jazyku Python k dispozici přímo.\n",
    "Poznamenejme, že funkce `min` a `max` mají dva nebo více číselných parametrů a funkce `abs` má jeden číselný parametr."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45.5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-45.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(10, 1.3, 1,  1.2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.4 2.8 2.8\n"
     ]
    }
   ],
   "source": [
    "a = -1.4\n",
    "b = 2.8\n",
    "c = min(a, b)\n",
    "d = max(a, b, c)\n",
    "e = abs(d) \n",
    "print(c, d, e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Další matematické funkce jako např. `sqrt` (odmocnina), `sin` nebo `cos` nejsou k dispozici přímo, ale v tzv. _modulu_.\n",
    "__Moduly__ jsou v jazyku Python ucelené části zdrojového kódu, které obsahují proměnné, funkce a další objekty.\n",
    "V první řadě je potřeba říci, že Python poskytuje širokou _standardní knihovnu_ složenou z mnoha modulů, které programátorům usnadňují život.\n",
    "Jeden z takových modulů je modul `math` obsahující matematické funkce a konstanty.\n",
    "\n",
    "Abychom obsah modulu zpřístupnili, musíme jej nejprve _importovat_ pomocí příkazu `import`.\n",
    "K objektům v modulu se potom dostaneme pomocí tečkové notace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math \n",
    "math.cos(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.cos(math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Číslo π je přibližně 3.141592653589793\n",
      "Hodnota cos(π) je  -1.0\n",
      "Číslo π je přibližně 3.14\n",
      "Hodnota cos(π) je  -0.9999987317275395\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(\"Číslo π je přibližně\", math.pi)\n",
    "print(\"Hodnota cos(π) je \", math.cos(math.pi))\n",
    "\n",
    "pi = 3.14\n",
    "print(\"Číslo π je přibližně\", pi)\n",
    "print(\"Hodnota cos(π) je \", math.cos(pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.085536923187668\n"
     ]
    }
   ],
   "source": [
    "# jakmile provedu import, do restartu Kernelu mohu funkce a jiné objekty z modulu používat\n",
    "print(math.exp(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativním způsobem importování je zápis `from math import ...`, kde místo `...` napíšeme seznam identifikátorů, které chceme importovat, oddělených čárkami.\n",
    "Na rozdíl od předchozího způsobu pak nemusíme používat tečkovou notaci a importované objekty máme k dispozici přímo.\n",
    "Předchozí příklad tedy můžeme přepsat následovně:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Číslo π je přibližně 3.141592653589793\n",
      "Hodnota cos(π) je  -1.0\n"
     ]
    }
   ],
   "source": [
    "from math import pi, cos\n",
    "\n",
    "print(\"Číslo π je přibližně\", pi)\n",
    "print(\"Hodnota cos(π) je \", cos(pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n",
      "3.141592653589793\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "pi = 3.14\n",
    "print(pi)\n",
    "\n",
    "from math import pi\n",
    "print(pi)\n",
    "\n",
    "pi = 3.14\n",
    "print(pi)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ahoj\n",
      "<built-in function cos>\n",
      "1.0\n",
      "ahoj\n"
     ]
    }
   ],
   "source": [
    "cos = \"ahoj\"\n",
    "print(cos)\n",
    "\n",
    "from math import cos\n",
    "print(cos)\n",
    "print(cos(0))\n",
    "\n",
    "cos = \"ahoj\"\n",
    "print(cos)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Místo seznamu identifikátorů můžeme z modulu importovat vše pomocí příkazu `from math import *`.\n",
    "To nám ušetří práci s psaním dlouhého seznamu názvů, ale na druhou stranu se tím zvýší pravděpodobnost kolize mezi názvy importovaných objektů a námi definovaných proměnných a funkcí."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793 2.718281828459045 inf\n"
     ]
    }
   ],
   "source": [
    "from math import * # NEPOUŽÍVAT !!!!\n",
    "\n",
    "print(pi, e, inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "K tématu modulů se během semestru ještě několikrát vrátíme.\n",
    "Naučíme se používat další funkce a třídy dostupné v modulech standardní knihovny a také se naučíme tvořit vlastní moduly pro přehlednější strukturování vlastního programu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Příklady"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Napište program, který se uživatele zeptá na poloměr kruhu a vypíše jeho obvod a obsah."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadejte poloměr kruhu:  5.1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Obvod kruhu je: 32.044245066615886\n",
      "Obsah kruhu je: 81.71282491987051\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "r = float(input(\"Zadejte poloměr kruhu: \"))\n",
    "\n",
    "o = 2 * math.pi * r\n",
    "S = math.pi * r**2\n",
    "\n",
    "print(\"Obvod kruhu je:\", o)\n",
    "print(\"Obsah kruhu je:\", S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. *(Pythagorova věta)* Napište program, který od uživatele zjistí délky dvou kratších stran pravoúhlého trojúhelníka a vypočítá délku jeho nejdelší strany."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej stranu a 3.2\n",
      "Zadej stranu b 2.7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Delka přepony je 4.186884283091665\n"
     ]
    }
   ],
   "source": [
    "a = float(input(\"Zadej stranu a\"))\n",
    "b = float(input(\"Zadej stranu b\"))\n",
    "c = (a ** 2 + b ** 2) ** (1 / 2)\n",
    "print(\"Delka přepony je\", c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Delka přepony je 4.186884283091665\n"
     ]
    }
   ],
   "source": [
    "# alternativně: math.sqrt() \n",
    "c = math.sqrt(a ** 2 + b ** 2) \n",
    "print(\"Delka přepony je\", c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6.123233995736766e-17+1j)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(-1) ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "expected a nonnegative input, got -1.0",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mValueError\u001b[39m                                Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m math.sqrt(-\u001b[32m1\u001b[39m)\n",
      "\u001b[31mValueError\u001b[39m: expected a nonnegative input, got -1.0"
     ]
    }
   ],
   "source": [
    "math.sqrt(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Napište program, který se uživatele zeptá na jeho hmotnost a pomocí průměrné hustoty lidského těla ($1000~kg/m^3$) spočítá jeho objem. Jaký by měl uživatel průměr, pokud by měl tvar koule?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadej svou hmotnost v kg 60\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Objem je 0.06 m^3\n"
     ]
    }
   ],
   "source": [
    "# 1. objem\n",
    "m = float(input(\"Zadej svou hmotnost v kg\"))\n",
    "\n",
    "V = m / 1000\n",
    "\n",
    "print(\"Objem je\", V, \"m^3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Průměr člověka-koule o objemu 0.06 m^3 je 0.4857180126010562 m.\n"
     ]
    }
   ],
   "source": [
    "# 2. průměr\n",
    "import math \n",
    "\n",
    "# koule: V = 4/3 Pi r^3\n",
    "r = (3 / 4 * V / math.pi ) ** (1 / 3)\n",
    "d = 2 * r\n",
    "\n",
    "print(\"Průměr člověka-koule o objemu\", V, \"m^3 je\", d,  \"m.\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  **Objemy a povrchy geometrických těles**\n",
    "    - Napište program, který spočítá objem a povrch koule o průměru $d$, který zadá uživatel.\n",
    "    - Napište program, který spočítá objem a povrch čtyřbokého jehlanu se základnou o straně délky $a$ a výškou délky $v$.\n",
    "    - Napište program, který spočítá obvod a plochu [pravidelného mnohoúhelníku](https://cs.wikipedia.org/wiki/Pravideln%C3%BD_mnoho%C3%BAheln%C3%ADk) o straně délky $a$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nedělali jsme společně"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. **Pravidelné mnohostěny** Napište program, který spočítá objem a povrch pravidelného [čtyřstěnu](https://cs.wikipedia.org/wiki/%C4%8Cty%C5%99st%C4%9Bn), [krychle](https://cs.wikipedia.org/wiki/Krychle), pravidelného [osmistěnu](https://cs.wikipedia.org/wiki/Osmist%C4%9Bn), pravidelného [dvanáctistěnu](https://cs.wikipedia.org/wiki/Dvan%C3%A1ctist%C4%9Bn) a pravidelného [dvacetistěnu](https://cs.wikipedia.org/wiki/Dvacetist%C4%9Bn)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. **Šitý fotbalový míč** Napište program, který spočítá délku švů na fotbalovém míči tvaru [komolého dvacetistěnu](https://cs.wikipedia.org/wiki/Komol%C3%BD_dvacetist%C4%9Bn) o poloměru $r$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Rozšíření nbgrader\n",
    "\n",
    "V prostředí [JupyterHub](https://jupyter.fjfi.cvut.cz/) je nainstalované rozšíření **nbgrader**, které budeme používat pro zadávání a odevzdávání úkolů.\n",
    "Studentský pohled představuje nabídka **Assignment List**, kterou najdete v menu:\n",
    "\n",
    "![](images/03/nbgrader-1.png)\n",
    "\n",
    "Po kliknutí se otevře nová záložka s nabídkou kurzů, ve kterých je přihlášený uživatel studentem.\n",
    "Dokud není zadaný žádný úkol, tento seznam je prázdný:\n",
    "\n",
    "![](images/03/nbgrader-2.png)\n",
    "\n",
    "Také se objeví \"no courses found\", což však není chyba – znamená to, že zatím není zadaný žádný úkol.\n",
    "Po zadání prvního úkolu se v nabídce objeví název kurzu s aktuálním rokem: `zpro2026`.\n",
    "\n",
    "<div style=\"border-left: 5px solid #08c; padding-left: 1em\">\n",
    "<strong>Poznámka:</strong> Následující obrázky jsou z minulého roku, až na jiný obsah je však rozvržení všech prvků stejné.\n",
    "</div>\n",
    "\n",
    "Po zveřejnění nového úkolu se objeví další položka v seznamu \"Released assignments\":\n",
    "\n",
    "![](images/03/nbgrader-3.png)\n",
    "\n",
    "Kliknutím na tlačítko \"Fetch\" se stáhnou soubory pro daný úkol do vašeho domovského adresáře a objeví se příslušná položka v seznamu \"Downloaded assignments\":\n",
    "\n",
    "![](images/03/nbgrader-4.png)\n",
    "\n",
    "Klikněte na název úkolu (viz červený rámeček výše) a poté na název souboru (o řádek níže, viz červený rámeček na dalším obrázku):\n",
    "\n",
    "![](images/03/nbgrader-5.png)\n",
    "\n",
    "Tím se v nové záložce otevře Jupyter notebook se zadáním úkolu, který může vypadat např. takto:\n",
    "\n",
    "![](images/03/nbgrader-6.png)\n",
    "\n",
    "V zadání je typicky několik buněk, které byste neměli měnit.\n",
    "Buňka, ve které je potřeba vypracovat zadaný úkol, je označena komentářem `YOUR CODE HERE`.\n",
    "V tomto ukázkovém příkladu je potřeba nahradit celý obsah buňky, v budoucích úkolech však může být předpřipravený kód, který je potřeba dokončit.\n",
    "\n",
    "<div style=\"border-left: 5px solid #08c; padding-left: 1em\">\n",
    "<strong>Poznámka:</strong> První úkol obsahuje podrobnější <em>návod k použití</em> před samotným zadáním.\n",
    "</div>\n",
    "\n",
    "Při programování úkolu můžete využít tlačítko \"Validate\", kterým se spustí kontrola testů, které byly zveřejněny spolu s úkolem.\n",
    "Dále může úkol obsahovat **skryté testy**, které studenti nevidí, ale provedou se při kontrole úkolu vyučujícím.\n",
    "\n",
    "Jakmile jste dostatečně spokojeni se svým řešením, zkontrolujte, že **notebook s úkolem je uložený** (stiskněte `Ctrl+S`).\n",
    "Poté přejděte zpět na záložku \"Assignments\", pro jistotu znovu použijte tlačítko \"Validate\" a odevzdejte úkol pomocí tlačítka \"Submit\":\n",
    "\n",
    "![](images/03/nbgrader-8.png)\n",
    "![](images/03/nbgrader-9.png)\n",
    "\n",
    "Po odevzdání se objeví nová položka v seznamu \"Submitted assignments\" s časem odevzdání a tlačítko \"Fetch Feedback\", které v této chvíli nemá žádný efekt:\n",
    "\n",
    "![](images/03/nbgrader-10.png)\n",
    "\n",
    "Teprve po zkontrolování úkolu vyučujícím a zveřejnění hodnocení, což může trvat několik dní, tlačítko \"Fetch Feedback\" stáhne report s ohodnoceným úkolem.\n",
    "Kliknutím na odkaz \"view feedback\" se v průzkumníku souborů nalevo zobrazí HTML soubor, který můžete otevřít a podívat se na své hodnocení.\n",
    "\n",
    "![](images/03/nbgrader-11.png)\n",
    "\n",
    "![](images/03/nbgrader-12.png)\n",
    "\n",
    "Report obsahuje bodové ohodnocení buněk na základě vykonání automatických testů a případně také osobní vyjádření vyučujícího.\n",
    "Také se vám zobrazí kód skrytých testů, v této ukázce jsou však zastřeny:\n",
    "\n",
    "![](images/03/nbgrader-13.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Poznámky a omezení\n",
    "\n",
    "- Rozšíření nbgrader ve svém rozhraní neumožňuje studentům zobrazit *deadline* pro daný úkol. Datum tedy budeme ručně psát v textu samotného zadání.\n",
    "- Systém umožňuje opakované odevzdání úkolu. Před oznámkováním a zveřejněním výsledků to můžete využívat, výsledný report pak bude odpovídat poslední odevzdané verzi. Po oznámkování a zveřejnění výsledků se již oprava úkolu nijak neprojeví."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.14.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}