{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cvičení č. 7 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2026/27)\n",
    "### V minulém díle jste viděli..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podmíněný příkaz `if` s volitelnými bloky `elif` a `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "číslo se rovná 0\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "if a > 0:\n",
    "    print(\"číslo je kladné\")\n",
    "elif a == 0:\n",
    "    print(\"číslo se rovná 0\")\n",
    "else:\n",
    "    print(\"číslo není kladné\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podmíněný výraz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -1\n",
    "y = 2\n",
    "z = x if x + y > 0 else y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Příkaz `while`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n <= 4:\n",
    "    print(n)\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Příkazy `break` a `continue` sloužící pro podrobnější kontrolu provádění cyklů."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Příkaz `for` využívající funkci `range` jako zdroj hodnot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "7\n",
      "4\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for n in range(10, 0, -3):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for n in range(5):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strukturování programu: funkce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Funkce__ jsou patrně nejdůležitější prvek programovacích jazyků, který slouží ke strukturování programu.\n",
    "Umožňují totiž _pojmenovat_ určitou skupinu příkazů, které potom lze použít opakovaně s různými vstupními parametry.\n",
    "Pokud tedy programujeme algoritmus pro řešení nějaké úlohy, můžeme jej umístit do samostatné funkce, abychom při opakovaném řešení úlohy s jinými daty nemuseli znovu programovat ten samý algoritmus.\n",
    "Funkce tedy programátorům umožňují dodržovat princip [don't repeat yourself (DRY)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# již známe 2 druhy funkcí: funkce, co mají nějaké parametry a vrací hodnotu \n",
    "# a funkci print pro vypisování\n",
    "x = -3\n",
    "y = abs(x)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ahoj\n"
     ]
    }
   ],
   "source": [
    "y = print(\"ahoj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Příkaz `def` – definice funkce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Příkaz `def` je složený příkaz, který se skládá z _hlavičky_ a _těla funkce_.\n",
    "Hlavička se skládá z klíčového slova `def`, názvu funkce, seznamu parametrů uvnitř kulatých závorek a závěrečné dvojtečky.\n",
    "Tělo funkce následující za dvojtečkou tvoří blok příkazů se správným odsazením dle _univerzálního syntaktického pravidla_.\n",
    "\n",
    "Zápis se nejlépe vysvětlí pomocí příkladů.\n",
    "Následující funkce `print_demo` nemá žádný parametr:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definice funkce: hlavička a tělo\n",
    "# Tato funkce nemá žádný parametr a vrací hodnotu None\n",
    "def print_demo():\n",
    "    print(\"Byla spuštěna funkce 'print_demo'.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkce `print_demo1` má jeden parametr:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definice funkce s jedním parametrem\n",
    "def print_demo1(param):\n",
    "    print(\"Hodnota parametru je\", param)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkce `print_demo2` má dva parametry:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hodnota prvního parametru je 2\n",
      "Hodnota druhého parametru je 3\n"
     ]
    }
   ],
   "source": [
    "# definice funkce se dvěma parametry\n",
    "def print_demo2(param1, param2):\n",
    "    print(\"Hodnota prvního parametru je\", param1)\n",
    "    print(\"Hodnota druhého parametru je\", param2)\n",
    "\n",
    "print_demo2(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Všimněte si, že při spuštění příkazu `def` nedošlo ke spuštění příkazů v těle dané funkce.\n",
    "Při definici funkce dojde pouze k vytvoření objektu, který reprezentuje danou funkci a obsahuje kód definovaný v těle funkce.\n",
    "Odkaz na tento objekt se uloží do proměnné s názvem dané funkce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# příkaz definice funkce je podobný jako příkaz definice proměnné: \n",
    "# také nic nevypíše, ale vytvoří se objekt reprezentující funkci a proměnná \n",
    "# (zde print_demo), která na objekt odkazuje\n",
    "# mrkněte na proměnné v debbugeru\n",
    "x = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "<function print_demo at 0x7f2dd4703740>\n"
     ]
    }
   ],
   "source": [
    "# výpis hodnoty, na kterou odkazuje proměnná 'x': číslo\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Výpis samotného objektu reprezentujícího funkci vypadá takto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# výpis hodnoty, na kterou odkazuje proměnná 'print_demo':\n",
    "# objekt, který reprezentuje funkci\n",
    "print(print_demo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Byla spuštěna funkce 'print_demo'.\n"
     ]
    }
   ],
   "source": [
    "# volání (spuštění) funkce (už známe):\n",
    "print_demo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hodnota parametru je ahoj\n",
      "Hodnota parametru je 12\n"
     ]
    }
   ],
   "source": [
    "# Volání funkce s jedním parametrem, \"ahoj\" je argument pro parametr 'param'\n",
    "print_demo1(\"ahoj\")\n",
    "print_demo1(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pokud chceme funkci použít, musíme ji _zavolat_ pomocí kulatých závorek, přičemž musíme předat správný počet argumentů odpovídající definici funkce, jinak dojde k chybě:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Byla spuštěna funkce 'print_demo'.\n",
      "Hodnota parametru je 10\n",
      "Hodnota prvního parametru je 10\n",
      "Hodnota druhého parametru je 20\n"
     ]
    }
   ],
   "source": [
    "print_demo()        # zde nepředáváme žádný argument\n",
    "print_demo1(10)     # číslo 10 je argument pro parametr 'param'\n",
    "print_demo2(10, 20) # čísla 10 je argument pro parametr 'param1', 20 je argument pro parametr 'param2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "print_demo1() takes 1 positional argument but 2 were given",
     "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[10]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m print_demo1(\u001b[32m10\u001b[39m, \u001b[32m5\u001b[39m)\n",
      "\u001b[31mTypeError\u001b[39m: print_demo1() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "# funkci musíme volat se správným počtem argumentů\n",
    "print_demo1(10, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "print_demo1() missing 1 required positional argument: 'param'",
     "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[11]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m print_demo1()\n",
      "\u001b[31mTypeError\u001b[39m: print_demo1() missing 1 required positional argument: 'param'"
     ]
    }
   ],
   "source": [
    "# funkci musíme volat se správným počtem argumentů\n",
    "print_demo1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Syntaxe příkazu `def` má mnoho různých variant, které souvisí zejména s definicí seznamu parametrů funkce.\n",
    "Zatím se jimi nebudeme zabývat a postupně se k tomuto tématu budeme vracet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Příklad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Napište funkci `say_hello(name)`, která vypíše pozdrav pro uživatele se zadaným jménem. (Anglicky, abychom nemuseli skloňovat...). Funkci několikrát zavolejte, vyzkoušejte různé hodnoty argumentu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jane\n",
      "Hello Tom\n",
      "Hello 0\n",
      "Hello 1\n",
      "Hello 2\n",
      "Hello 3\n",
      "Hello 4\n"
     ]
    }
   ],
   "source": [
    "def say_hello(name):\n",
    "    print(\"Hello\", name)\n",
    "\n",
    "say_hello(\"Jane\")\n",
    "say_hello(\"Tom\")\n",
    "\n",
    "for i in range(5):\n",
    "    say_hello(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Příkaz `return` – vrácení výsledku funkce\n",
    "\n",
    "V matematice se pojmem funkce označuje předpis, který ze vstupní hodnoty (případně vstupních hodnot) počítá nějakou výstupní hodnotu.\n",
    "Předchozí příklady funkcí `print_demo` atd. nemají žádný výsledek.\n",
    "K vrácení výsledné hodnoty zevnitř funkce na místo, kde byla funkce zavolána, slouží příkaz `return`.\n",
    "Volání funkce je výraz, může tedy vystupovat např. napravo od přiřazovacího operátoru:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.25\n"
     ]
    }
   ],
   "source": [
    "# K vrácení výsledné (návratové) hodnoty funkce slouží příkaz return:\n",
    "def polynom(x):\n",
    "    return x ** 2 - 3 * x + 1\n",
    "\n",
    "vysledek = polynom(2.5)\n",
    "print(vysledek)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.25\n",
      "-0.25\n"
     ]
    }
   ],
   "source": [
    "# před příkazem return může být složitější výpočet:\n",
    "def polynom(x):\n",
    "    y = x ** 2 - 3 * x\n",
    "    y += 1\n",
    "    return y \n",
    "\n",
    "# výslednou (návratovou) hodnotu funkce mohu např. vložit do proměnné:\n",
    "vysledek = polynom(2.5)\n",
    "print(vysledek)\n",
    "\n",
    "# nebo rovnou vypsat:\n",
    "print(polynom(2.5))\n",
    "\n",
    "# ukázka: debugger + pytutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.25\n"
     ]
    }
   ],
   "source": [
    "# volání funkcí může být součástí složitějších výrazů\n",
    "vysledek = polynom(2.5) + 3 * abs(polynom(3)) - 4 \n",
    "print(vysledek)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Příkazem `return` končí vykonávání dané funkce a žádné další příkazy z těla funkce se nevykonají.\n",
    "To je důležité zejména pokud funkce obsahuje příkazy `return` uvnitř podmínek nebo cyklů.\n",
    "Pokud funkce neobsahuje žádný příkaz `return` nebo pokud dojde k vykonání prázdného příkazu `return` (tj. ukončení funkce bez vrácení hodnoty), je výsledkem funkce hodnota `None`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "# příkaz return okamžitě ukončí funkci (jako break u cyklu)\n",
    "def polynom(x):\n",
    "    y = x ** 2 - 3 * x\n",
    "    return\n",
    "    y += 1\n",
    "    return y \n",
    "\n",
    "vysledek = polynom(2.5)\n",
    "print(vysledek)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Výsledek je 71\n"
     ]
    }
   ],
   "source": [
    "def polynom(x):\n",
    "    if x < 0:\n",
    "        print(\"Definiční obor této funkce nezahrnuje záporná čísla.\")\n",
    "        return\n",
    "    return x ** 2 - 3 * x + 1\n",
    "\n",
    "vysledek = polynom(10)\n",
    "print(\"Výsledek je\", vysledek)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Definiční obor této funkce nezahrnuje záporná čísla.\n",
      "Výsledek je None\n"
     ]
    }
   ],
   "source": [
    "# pokud funkce neobsahuje za příkazem return hodnotu, je její návratovou hodnotou None:\n",
    "vysledek = polynom(-1)\n",
    "print(\"Výsledek je\", vysledek)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 0 -1 -1\n"
     ]
    }
   ],
   "source": [
    "# ukázka signum: další příklad použití příkazu return v různých větvích výpočtu:\n",
    "def signum(x):\n",
    "    if x > 0:\n",
    "        return 1\n",
    "    if x < 0:\n",
    "        return -1\n",
    "    return 0\n",
    "\n",
    "# Ukázka: pokud chci otestovat funkci, obvykle ji zavolám opakovaně pro různé vstupy\n",
    "# a zkontroluji výsledek (není třeba volat input())\n",
    "print(signum(10), signum(1.5), signum(0), signum(-0.5), signum(-10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Anna\n",
      "Výsledek je None\n"
     ]
    }
   ],
   "source": [
    "# pokud funkce neobsahuje příkaz return, je její návratovou hodnotou None:\n",
    "def say_hello(name):\n",
    "    print(\"Hello\", name)\n",
    "\n",
    "x = say_hello(\"Anna\")\n",
    "print(\"Výsledek je\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Příklad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Napište funkci `je_sudé(n)`, která vrací `True` nebo `False` podle toho, jestli je zadané přirozené číslo `n` sudé nebo není. Funkci zavolejte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def je_sude(n):\n",
    "    if n % 2 == 1:\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "        \n",
    "print(je_sude(56))\n",
    "print(je_sude(5))\n",
    "print(je_sude(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def je_sude(n):\n",
    "    return n % 2 == 0\n",
    "        \n",
    "print(je_sude(56))\n",
    "print(je_sude(5))\n",
    "print(je_sude(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def je_sude(n):\n",
    "    return not n % 2 \n",
    "        \n",
    "print(je_sude(56))\n",
    "print(je_sude(5))\n",
    "print(je_sude(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Analogicky napište funkci `je_liché(n)`. **Využijte při tom předchozí funkci.** Funkci zavolejte."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def je_liche(n):\n",
    "    if je_sude(n):\n",
    "        return False\n",
    "    else:\n",
    "        return True\n",
    "        \n",
    "print(je_liche(56))\n",
    "print(je_liche(5))\n",
    "print(je_liche(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def je_liche(n):\n",
    "    return not je_sude(n)\n",
    "        \n",
    "print(je_liche(56))\n",
    "print(je_liche(5))\n",
    "print(je_liche(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Proměnné a obor platnosti\n",
    "\n",
    "Lokální proměnná je proměnná, která je definovaná uvnitř funkce.\n",
    "Jakmile skončí vykonávání dané funkce, zaniknou i všechny lokální proměnné definované uvnitř dané funkce.\n",
    "\n",
    "Uvnitř funkce máme naopak přístup objektům s širším oborem platnosti, jako jsou např. globální proměnné, ale i globálně importované moduly, jiné funkce definované na stejné úrovni, apod.\n",
    "Názvy definované na vyšší úrovni ale můžeme pouze použít, nemůžeme je změnit – viz následující příklad:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lokalni 11\n",
      "globalni 10\n"
     ]
    }
   ],
   "source": [
    "# původní příklad\n",
    "# globální proměnná\n",
    "globalni = 10\n",
    "\n",
    "def f():\n",
    "    # lokální proměnná\n",
    "    lokalni = 1\n",
    "\n",
    "    # použití globální proměnné\n",
    "    lokalni += globalni\n",
    "\n",
    "    # uvnitř funkce nelze měnit globální proměnné\n",
    "    #globalni += 1\n",
    "\n",
    "    # výpis lokálních proměnných\n",
    "    print(\"lokalni\", lokalni)\n",
    "\n",
    "# použití funkce\n",
    "f()\n",
    "\n",
    "# výpis globálních proměnných\n",
    "print(\"globalni\", globalni)\n",
    "\n",
    "# lokální proměnné definované uvnitř funkce nejsou k dispozici na globální úrovni\n",
    "#print(lokalni)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lokalni 4\n",
      "globalni 10\n",
      "globalni 10\n"
     ]
    }
   ],
   "source": [
    "# Proměnné dělíme na globální (definované na úrovni programu) \n",
    "# a lokální (definované na úrovni funkce)\n",
    "\n",
    "# globální proměnná\n",
    "globalni = 10\n",
    "\n",
    "def f():\n",
    "    # lokální proměnná\n",
    "    lokalni = 1\n",
    "    lokalni += 3\n",
    "\n",
    "    # výpis lokálních proměnných\n",
    "    print(\"lokalni\", lokalni)\n",
    "\n",
    "# použití funkce\n",
    "f()\n",
    "\n",
    "# výpis globálních proměnných\n",
    "print(\"globalni\", globalni)\n",
    "\n",
    "# ukázka pytutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lokalni 11 100\n",
      "globalni 10\n"
     ]
    }
   ],
   "source": [
    "# Parametry funkce jsou také lokální proměnné\n",
    "\n",
    "# globální proměnná\n",
    "globalni = 10\n",
    "\n",
    "# parametry funkce jsou také lok. proměnné\n",
    "def f(parametr):\n",
    "    # lokální proměnná\n",
    "    lokalni = 1\n",
    "    lokalni += parametr\n",
    "    parametr *= 10\n",
    "\n",
    "    # výpis lokálních proměnných\n",
    "    print(\"lokalni\", lokalni, parametr)\n",
    "\n",
    "# použití funkce\n",
    "f(globalni)\n",
    "\n",
    "# výpis globálních proměnných\n",
    "print(\"globalni\", globalni)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lokalni 11 100\n",
      "globalni 10\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'lokalni' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mNameError\u001b[39m                                 Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[31]\u001b[39m\u001b[32m, line 23\u001b[39m\n\u001b[32m     19\u001b[39m \u001b[38;5;66;03m# výpis globálních proměnných\u001b[39;00m\n\u001b[32m     20\u001b[39m print(\u001b[33m\"globalni\"\u001b[39m, globalni)\n\u001b[32m     21\u001b[39m \n\u001b[32m     22\u001b[39m \u001b[38;5;66;03m# lokální proměnné definované uvnitř funkce nejsou k dispozici na globální úrovni\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m23\u001b[39m print(lokalni)\n",
      "\u001b[31mNameError\u001b[39m: name 'lokalni' is not defined"
     ]
    }
   ],
   "source": [
    "# lokální proměnná žije jen uvnitř funkce, když funkce skončí, zanikne:\n",
    "\n",
    "# globální proměnná\n",
    "globalni = 10\n",
    "\n",
    "# parametry funkce jsou také lok. proměnné\n",
    "def f(parametr):\n",
    "    # lokální proměnná\n",
    "    lokalni = 1\n",
    "    lokalni += parametr\n",
    "    parametr *= 10\n",
    "\n",
    "    # výpis lokálních proměnných\n",
    "    print(\"lokalni\", lokalni, parametr)\n",
    "\n",
    "# použití funkce\n",
    "f(globalni)\n",
    "\n",
    "# výpis globálních proměnných\n",
    "print(\"globalni\", globalni)\n",
    "\n",
    "# lokální proměnné definované uvnitř funkce nejsou k dispozici na globální úrovni\n",
    "print(lokalni)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lokalni 11\n",
      "globalni 10\n",
      "globalni 10\n"
     ]
    }
   ],
   "source": [
    "# Globální proměnné mohu uvnitř funkce\n",
    "# používat, ale nemohu je tam měnit\n",
    "\n",
    "# globální proměnná\n",
    "globalni = 10\n",
    "\n",
    "def f():\n",
    "    # lokální proměnná\n",
    "    lokalni = 1\n",
    "\n",
    "    # použití globální proměnné\n",
    "    lokalni += globalni\n",
    "\n",
    "    # uvnitř funkce nelze měnit globální proměnné\n",
    "    # globalni += 1\n",
    "\n",
    "    # výpis lokálních proměnných\n",
    "    print(\"lokalni\", lokalni)\n",
    "\n",
    "    # výpis globálních proměnných\n",
    "    print(\"globalni\", globalni)\n",
    "# použití funkce\n",
    "f()\n",
    "\n",
    "# výpis globálních proměnných\n",
    "print(\"globalni\", globalni)\n",
    "\n",
    "# lokální proměnné definované uvnitř funkce nejsou k dispozici na globální úrovni\n",
    "# print(lokalni)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "cannot access local variable 'globalni' where it is not associated with a value",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mUnboundLocalError\u001b[39m                         Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[36]\u001b[39m\u001b[32m, line 19\u001b[39m\n\u001b[32m     15\u001b[39m     \u001b[38;5;66;03m# výpis lokálních proměnných\u001b[39;00m\n\u001b[32m     16\u001b[39m     print(\u001b[33m\"lokalni\"\u001b[39m, lokalni)\n\u001b[32m     17\u001b[39m \n\u001b[32m     18\u001b[39m \u001b[38;5;66;03m# použití funkce\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m19\u001b[39m f()\n\u001b[32m     20\u001b[39m \n\u001b[32m     21\u001b[39m \u001b[38;5;66;03m# výpis globálních proměnných\u001b[39;00m\n\u001b[32m     22\u001b[39m print(\u001b[33m\"globalni\"\u001b[39m, globalni)\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[36]\u001b[39m\u001b[32m, line 10\u001b[39m, in \u001b[36mf\u001b[39m\u001b[34m()\u001b[39m\n\u001b[32m      6\u001b[39m     \u001b[38;5;66;03m# lokální proměnná\u001b[39;00m\n\u001b[32m      7\u001b[39m     lokalni = \u001b[32m1\u001b[39m\n\u001b[32m      8\u001b[39m \n\u001b[32m      9\u001b[39m     \u001b[38;5;66;03m# použití globální proměnné\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m10\u001b[39m     lokalni += globalni\n\u001b[32m     11\u001b[39m \n\u001b[32m     12\u001b[39m     \u001b[38;5;66;03m# uvnitř funkce nelze měnit globální proměnné\u001b[39;00m\n\u001b[32m     13\u001b[39m     globalni += \u001b[32m1\u001b[39m\n",
      "\u001b[31mUnboundLocalError\u001b[39m: cannot access local variable 'globalni' where it is not associated with a value"
     ]
    }
   ],
   "source": [
    "# Uvnitř funkce nelze měnit globální proměnné\n",
    "# tj. jakmile uvnitř funkce použiju globální proměnnou, již nesmím definovat\n",
    "# lokální proměnnou stejného jména:\n",
    "\n",
    "# globální proměnná\n",
    "globalni = 10\n",
    "\n",
    "def f():\n",
    "    # lokální proměnná\n",
    "    lokalni = 1\n",
    "\n",
    "    # použití globální proměnné\n",
    "    lokalni += globalni\n",
    "\n",
    "    # uvnitř funkce nelze měnit globální proměnné\n",
    "    globalni += 1\n",
    "\n",
    "    # výpis lokálních proměnných\n",
    "    print(\"lokalni\", lokalni)\n",
    "\n",
    "# použití funkce\n",
    "f()\n",
    "\n",
    "# výpis globálních proměnných\n",
    "print(\"globalni\", globalni)\n",
    "\n",
    "# lokální proměnné definované uvnitř funkce nejsou k dispozici na globální úrovni\n",
    "# print(lokalni)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"border-left: 5px solid green; padding-left: 1em\">\n",
    "<p><strong>Tip:</strong>\n",
    "Kliknutím na tlačítko <strong>pytutor</strong> v rozhraní JupyterLab se zobrazí grafická interpretace toho, co se v programu děje.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pokud bychom uvnitř funkce použili přiřazení jako např. `globalni = 1` v následujícím příkladu, není to chyba, ale je důležité si uvědomit, co se v programu děje.\n",
    "Příkaz přiřazení totiž vytváří novou proměnnou, ke které připojí daný název.\n",
    "V tomto případě tedy vzniká nová __lokální proměnná__ s názvem `globalni` a hodnotou `1` a její název na lokální úrovni překryje globální proměnnou se stejným názvem, jde však o dva různé objekty:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hodnota uvnitř funkce: 1\n",
      "hodnota mimo funkci: 10\n"
     ]
    }
   ],
   "source": [
    "# lokální proměnnou mohu pojmenovat stejně jako globální proměnnou\n",
    "# uvnitř funkce lokální proměnná překryje globální proměnnou stejného jména\n",
    "\n",
    "# globální proměnná\n",
    "globalni = 10\n",
    "\n",
    "def f():\n",
    "    # zde dojde k vytvoření lokální proměnné, která překryje proměnnou na globální úrovni\n",
    "    globalni = 1\n",
    "\n",
    "    print(\"hodnota uvnitř funkce:\", globalni)\n",
    "\n",
    "# použití funkce\n",
    "f()\n",
    "\n",
    "# funkce f nezměnila globální proměnnou\n",
    "print(\"hodnota mimo funkci:\", globalni)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "K podobné shodě názvu proměnných může docházet poměrně často, ale není třeba se tohoto chování bát.\n",
    "Vykonávání příkazů dané funkce probíhá ve svém vlastním _lokálním světě_, který s _globálním světem_ komunikuje především pomocí vstupních parametrů a výstupní návratové hodnoty (viz dále).\n",
    "Spíš by bylo nepříjemné, kdyby funkce modifikovala okolní stav nějakým jiným, nepřehledným způsobem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 1.0\n",
      "uvnitř: 14 minimum cosi\n",
      "minimum\n",
      "4 1.0\n"
     ]
    }
   ],
   "source": [
    "# Výhooda: uvnitř funkce si mohu pojmenovávat proměnné, jak chci\n",
    "y = 8\n",
    "from math import cos\n",
    "\n",
    "def f(x, y):\n",
    "    min = \"minimum\"\n",
    "    cos = \"cosi\"\n",
    "    print(\"uvnitř:\", x + y, min, cos)\n",
    "    return min\n",
    "\n",
    "print(min(4, 6), cos(0))\n",
    "y = f(6, y)\n",
    "print(y)\n",
    "print(min(4, 6), cos(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lokalni 90 0.5519263838708299 <built-in function cos>\n",
      "globalni 10\n"
     ]
    }
   ],
   "source": [
    "# uvnitř funkce mohu provést lokální import:\n",
    "a = 10 # globální proměnná\n",
    "\n",
    "def f(x): # parametr ... lokální proměnná\n",
    "    from math import cos\n",
    "    y = 1 + cos(x) # lokální proměnná\n",
    "    print(\"lokalni\", x, y, cos) # výpis lokálních proměnných\n",
    "    \n",
    "f(90) # použití funkce\n",
    "\n",
    "# výpis globálních proměnných\n",
    "print(\"globalni\", a)\n",
    "# y = cos(90) # chyba\n",
    "# ukázka pytutor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uvnitř funkce mohu použít globání import\n",
    "a = 10 # globální proměnná\n",
    "import math\n",
    "\n",
    "def f(x): # parametr ... lokální proměnná\n",
    "    y = 1 + x + math.cos(math.pi) # lokální proměnná\n",
    "    print(\"lokalni\", x, y) # výpis lokálních proměnných\n",
    "    \n",
    "f(90) # použití funkce\n",
    "\n",
    "# výpis globálních proměnných\n",
    "print(\"globalni\", a)\n",
    "# y = cos(90) # chyba\n",
    "# ukázka pytutor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Příklady"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Definujte a zavolejte funkci `je_dělitelné(n, d)`, která vrací `True` nebo `False` podle toho, jestli je zadané přirozené číslo `n` dělitelné číslem `d`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def je_delitelne(n, d):\n",
    "    if d == 0:\n",
    "        return False\n",
    "    if n % d == 0:\n",
    "        return True\n",
    "    return False\n",
    "    \n",
    "print(je_delitelne(15, 3))\n",
    "print(je_delitelne(15, 5))\n",
    "print(je_delitelne(15, 4))\n",
    "print(je_delitelne(15, 15))\n",
    "print(je_delitelne(15, 0))\n",
    "print(je_delitelne(0, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def je_delitelne(n, d):\n",
    "    if d == 0:\n",
    "        return False\n",
    "    return n % d == 0\n",
    "    \n",
    "print(je_delitelne(15, 3))\n",
    "print(je_delitelne(15, 5))\n",
    "print(je_delitelne(15, 4))\n",
    "print(je_delitelne(15, 15))\n",
    "print(je_delitelne(15, 0))\n",
    "print(je_delitelne(0, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  Napište a zavolejte funkci `počet_dělitelů(n)`, která spočítá a vrátí počet dělitelů přirozeného čísla `n`. Využijte funkci naprogramovanou v předchozím příkladu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def pocet_delitelu(n):\n",
    "    pocet = 0\n",
    "    for d in range(1, n + 1):\n",
    "        if je_delitelne(n, d):\n",
    "            pocet += 1\n",
    "    return pocet\n",
    "\n",
    "print(pocet_delitelu(56))\n",
    "print(pocet_delitelu(1))\n",
    "print(pocet_delitelu(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Napište a zavolejte funkci `vypiš_dělitele(n)`, která vypíše všechny dělitele přirozeného čísla `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 4 7 8 14 28 56 \n",
      "1 \n",
      "1 3 5 15 \n"
     ]
    }
   ],
   "source": [
    "def vypis_delitele(n):\n",
    "    for d in range(1, n + 1):\n",
    "        if je_delitelne(n, d):\n",
    "            print(d, end = \" \")\n",
    "    print(\"\")\n",
    "    \n",
    "vypis_delitele(56)\n",
    "vypis_delitele(1)\n",
    "vypis_delitele(15)\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 : \n",
      "1 : 1 \n",
      "2 : 1 2 \n",
      "3 : 1 3 \n",
      "4 : 1 2 4 \n",
      "5 : 1 5 \n",
      "6 : 1 2 3 6 \n",
      "7 : 1 7 \n",
      "8 : 1 2 4 8 \n",
      "9 : 1 3 9 \n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i, \": \", end=\"\")\n",
    "    vypis_delitele(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Napište a zavolejte funkci `bmi(hmotnost, výška)`, která ze zadaných parametrů spočítá index BMI a vrátí výsledek jako číselnou hodnotu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.437499999999996\n",
      "22.1606648199446\n"
     ]
    }
   ],
   "source": [
    "# zadny print uvnitr funkce!\n",
    "def bmi(m, h):\n",
    "    vysledek = m / (h / 100) ** 2\n",
    "    return vysledek\n",
    "\n",
    "hmotnost = 60\n",
    "vyska = 160\n",
    "\n",
    "print(bmi(hmotnost, vyska))\n",
    "print(bmi(80, 190))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Naprogramujte funkci `součet_číslic(n)`, která spočítá součet číslic v desítkovém zápisu přirozeného čísla `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7684 768 4\n"
     ]
    }
   ],
   "source": [
    "n = 7684\n",
    "cislice = n % 10\n",
    "n1 = n // 10\n",
    "print(n, n1, cislice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "n = 7684\n",
    "while n != 0:\n",
    "    cislice = n % 10\n",
    "    n = n // 10\n",
    "    print(cislice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def soucet_cislic(n):\n",
    "    soucet = 0\n",
    "    while n != 0:\n",
    "        cislice = n % 10\n",
    "        n = n // 10\n",
    "        soucet += cislice\n",
    "    return soucet\n",
    "    \n",
    "print(soucet_cislic(7684))\n",
    "print(soucet_cislic(10002))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Naprogramujte funkci `remove(n, digit)`, která z desítkového zápisu zadaného přirozeného čísla `n` odstraní všechny číslice, které se rovnají hodnotě `digit`. Např.:\n",
    "\n",
    "    - `remove(123, 2)` → `13`\n",
    "    - `remove(243132, 3)` → `2412`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n",
      "6\n",
      "7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7684"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 7684\n",
    "\n",
    "nove_cislo = 0\n",
    "nasobek = 1\n",
    "while n != 0:\n",
    "    cislice = n % 10\n",
    "    n = n // 10\n",
    "    print(cislice)\n",
    "    nove_cislo += cislice * nasobek\n",
    "    nasobek = nasobek * 10\n",
    "nove_cislo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n",
      "6\n",
      "7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "784"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 7684\n",
    "digit = 6\n",
    "\n",
    "nove_cislo = 0\n",
    "nasobek = 1\n",
    "while n != 0:\n",
    "    cislice = n % 10\n",
    "    n = n // 10\n",
    "    print(cislice)\n",
    "    if cislice != digit:\n",
    "        nove_cislo += cislice * nasobek\n",
    "        nasobek = nasobek * 10\n",
    "nove_cislo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "768\n",
      "764484\n",
      "64484\n"
     ]
    }
   ],
   "source": [
    "def remove(n, digit):\n",
    "    \n",
    "    nove_cislo = 0\n",
    "    nasobek = 1\n",
    "    while n != 0:\n",
    "        cislice = n % 10\n",
    "        n = n // 10\n",
    "        if cislice != digit:\n",
    "            nove_cislo += cislice * nasobek\n",
    "            nasobek = nasobek * 10\n",
    "    return nove_cislo\n",
    "\n",
    "print(remove(764484, 4))\n",
    "print(remove(764484, 5))\n",
    "print(remove(764484, 7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pro procvičení můžete dále zkusit upravit libovolný příklad z předchozích cvičení a definovat v něm vhodnou funkci."
   ]
  }
 ],
 "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
}