07_decorators_functools/decorators_functools.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funkce vyššího řádu, dekorátory a modul functools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Už minule jsme si řekli něco málo o funkcích vyššího řádu a ukázali jsme si, jak je možné funkce předávat jiným funkcím jako argumenty.\n",
    "\n",
    "Dnes si ukážeme, jak funkce generovat v rámci jiných funkcí, jak s tím souvisí dekorátory a dojde i na slíbenou poznámku o funkcionálním programování."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opakování"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkce vyššího řádu jsou takové, které:\n",
    "* mohou brát jiné funkce jako své argumenty nebo\n",
    "* mohou vracet nové funkce jako svou návratovou hodnotu.\n",
    "\n",
    "Takto pracovat s funkcemi je možné díky tomu, že funkce je v Pythonu objekt jako každé jiný - jako jakákoli jiná proměnná."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkce jako argument jiné funkce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Minule jsme si ukázali několik funkcí, které jako argument braly jinou funkci a chovaly se podle jejich výsledků - `map`, `reduce` a `filter`.\n",
    "\n",
    "Dnes si na příkladu ukážeme, jak takovou funkci sami napsat.\n",
    "\n",
    "Nejdříve si definujeme dvě obyčejné funkce pro základní matematické operace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def secti(cisla):\n",
    "    \"\"\"Funkce pro sečtení sekvence čísel\"\"\"\n",
    "    vysledek = 0\n",
    "    for cislo in cisla:\n",
    "        vysledek += cislo\n",
    "    return vysledek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vynasob(cisla):\n",
    "    \"\"\"Funkce pro vynásobení sekvence čísel\"\"\"\n",
    "    vysledek = 1\n",
    "    for cislo in cisla:\n",
    "        vysledek = vysledek * cislo\n",
    "    return vysledek"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A teď jednu obecnou funkci, které bude umět provést jakoukoli funkci se zadaným argumentem a vrátit její výsledek:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def proved(funkce, argument):\n",
    "    \"\"\"Funkce volající jinou funkci s jedním argumentem\"\"\"\n",
    "    return funkce(argument)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nezbývá než vyzkoušet, zda je možné použít obyčejné funkce `secti` a `vynasob` jako první argument pro funkci vyššího řádu `proved`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "proved(secti, [1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "proved(vynasob, [1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stále platí, že předáváme-li funkci (např. `secti`) jako argument do jiné funkce (např. `proved`), není třeba ji definovat jako pojmenovanou, ale můžeme využít anonymní funkce. Naše funkce `proved` je natolik obecná, že s ní dokážeme udělat takřka cokoliv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pepa nesl tašku'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "proved(lambda x: \" \".join(x), [\"Pepa\", \"nesl\", \"tašku\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jako první argument jsme definovali anonymní funkci, která jednoduše spojí řetězce pomocí mezery do jednoho. Druhý argument pak obsahuje seznam tří řetězců.\n",
    "\n",
    "Tento koncept už známe z minula. Teď je na čase se na něj podívat z druhé strany."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkce generující jinou funkci"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Protože funkce je objekt jako každý jiný, může být vytvořena v rámci jiné funkce a vrácena jako její návratová hodnota.\n",
    "\n",
    "Nejdříve si to opět ukážeme na jednoduchém příkladu. Chceme si napsat funkci, která nám bude umět definovat a vrátit novou funkci, která k argumentem zadanému číslu bude přičítat nějaké pevně dané číslo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def funkce_pricitani(kolik):\n",
    "    \"\"\"Vnější funkce, která generuje novou funkci uvnitř\"\"\"\n",
    "    \n",
    "    def pricitani(k_cemu):\n",
    "        \"\"\"Vnitřní funkce, která bude definována ve chvíli volání nější funkce a vrácena\"\"\"\n",
    "        return kolik + k_cemu\n",
    "\n",
    "    return pricitani"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkce `funkce_pricitani` bere jeden argument - číslo, které se má při volání nově vygenerované funkce přičíst k zadanému argumentu - a vrátí novou funkci, které přesně takové přičítání bude umět. Nově definovaná funkce pak bere také jeden argument, který zadáme při jejím volání.\n",
    "\n",
    "Nejdříve si takto můžeme generovat funkci, která už bude mít inkrement definován. Například pro pětku a dvacítku."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "pricti_5 = funkce_pricitani(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "pricti_20 = funkce_pricitani(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do proměnných `pricti_5` a `pricti_20` se nám tak uložily dvě různé funkce, které lze volat a jedním argumentem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pricti_5(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pricti_20(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za povšimnutí stojí, že kromě definice se v tomto příkladu nikde nepoužívá originální název vnitřní funkce `pricitani`, který je stejně jako u jakékoli jiné funkce lokální proměnnou a na konci nadřazené funkce se na něj zapomene.\n",
    "\n",
    "Pojďme na trošku realističtější případ použití. Výpočet daně z nemovitosti se řídí cenou za m², celkovou plochou a také koeficientem města či obce. Můžete mít funkci, která tyto argumenty bude potřebovat při každém spuštění, nebo si můžete vytvořit funkci pro typ pozemku v daném městě a do ní už doplnit jen jeho rozlohu. My půjdeme tou druhou cestou."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dan_z_nemovitosti(koeficient, cena_za_m2):\n",
    "    \"\"\"Funkce definuje a vráti funkci pro výpočet daně z nemovitosti v dané obci\"\"\"\n",
    "    \n",
    "    def vypocet_dane(plocha):\n",
    "        \"\"\"Vypočte daň z nemovitosti v dané lokalitě\"\"\"\n",
    "        return plocha * cena_za_m2 * koeficient\n",
    "    \n",
    "    return vypocet_dane"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Díky takto dynamicky definované funkci si následně můžeme vytvořit funkci na výpočet daně z rodinného domu v Ostravě, kde koeficient je 3,5 a cena za m² je 2 Kč."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "dum_ostrava = dan_z_nemovitosti(3.5, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pak už stačí pro každý výpočet daně z rodinného domu v Ostravě použít tuto dynamicky definovanou funkci a jako argument ji zadat jen zastavěnou plochu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "875.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dum_ostrava(125)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pro zastavěnou plochu v Praze, kde koeficient je 4,5 a cena za m² je 20 haléřů, bude vypadat velmi podobně."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "pozemek_praha = dan_z_nemovitosti(4.5, 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "810.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pozemek_praha(900)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Takto je možné si jakkoli vytvářet dynamicky definované funkce třeba i na základě vstupu od uživatele či dat z jiného zdroje."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dekorátory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dekorátory jsou interně velmi podobné dynamicky definovaným funkcím, ale mají přece jen jednu odlišnost: Zatímco v předchozích příkladech jsme definovali jednu funkci uvnitř druhé, u dekorátorů definujeme samotný dekorátor mimo vnitřní funkci v obecnější podobě a jen jej na ni aplikujeme. Ve výsledku to znamená, že můžeme dekorátory použít aniž bychom měnili kód původních funkcí.\n",
    "\n",
    "Opět jeden jednoduchý příklad pro lepší pochopení. Mějme obyčejnou jednoduchou funkci pro sčítání:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def secti(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Její výsledek závisí na tom, jaké argumenty dostane. Pokud budou obě čísla celá, bude i výsledek celé číslo. Pokud ale bude jedno z čísel s desetinnou tečkou, bude i výsledek typu `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "secti(5, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "secti(5.0, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nyní přijde řada na dekorátor, který bude umět manipulovat s výsledkem funkce, na kterou bude aplikován. V našem případě bude umět zajistit, aby výsledek funkce byl vždy typu `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def desetinne_cislo(puvodni_funkce):\n",
    "    \n",
    "    def nova_funkce(*args, **kwargs):\n",
    "        vysledek = puvodni_funkce(*args, **kwargs)\n",
    "        return float(vysledek)\n",
    "\n",
    "    return nova_funkce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dekorátor je sám funkcí, která jako argument bere funkci, nad kterou bude dekorátor postaven. Uvnitř je pak definována nová funkce, která může libovolně pracovat s funkcí původní a obohatit ji tak o jakoukoli funkcionalitu.\n",
    "\n",
    "Uvnitř dekorátoru jsou pro definici nové funkce a volání té původní použity argumenty v obecném tvaru s `*args` a `**kwargs`, což nám zajistí, že dekorátor bude schopen předávat všechny poziční i pojmenované argumenty.\n",
    "\n",
    "Takto definovaný dekorátor je možné použít pomocí znaku `@` nad definicí funkce. Například naše funkce `secti` s dekorátorem zajišťujícím konzistenci výsledků bude vypadat takto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "@desetinne_cislo\n",
    "def secti(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Takto definovaná funkce s použitým dekorátorem bude vždy vracet desetinné číslo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "secti(5.0, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "secti(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Použití dekorátoru nad definicí funkce pomocí `@` není žádná magie. Jedná se jen o tzv. syntaktický cukr, který usnadňuje zápis a umožňuje velmi snadno použít i více dekorátorů. Bez tohoto cukru bychom mohli dekorátor použít i takto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def secti(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "secti_float = desetinne_cislo(secti)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "secti_float(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tento zůsob manuálního použití děkorátoru má tu výhodu, že původní funkce je stále dostupná pod svým originálním jménem.\n",
    "\n",
    "Funkce funguje samozřejmě pouze v případě, že se dá výsledek na desetinné číslo převést. I tato situace by se však dala bez problému v dekorátoru ošetřit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: 'Yetti'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-bb2597dd6e94>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msecti_float\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Yet\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"ti\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-20-3650eddf3d95>\u001b[0m in \u001b[0;36mnova_funkce\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mnova_funkce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m         \u001b[0mvysledek\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpuvodni_funkce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvysledek\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mnova_funkce\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'Yetti'"
     ]
    }
   ],
   "source": [
    "secti_float(\"Yet\", \"ti\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dalším velmi populárním příkladem použití dekorátorů je měření času trvání funkce a také logování jejího volání.\n",
    "\n",
    "Například:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zmer_cas(puvodni_funkce):\n",
    "    \n",
    "    def nova_funkce(*args, **kwargs):\n",
    "        import time\n",
    "        start = time.time()\n",
    "        print(f\"Volám funkci {puvodni_funkce} s argumenty {args}\")\n",
    "        vysledek = puvodni_funkce(*args, **kwargs)\n",
    "        end = time.time()\n",
    "        print(f\"Funkce běžela {end - start} sekund\")\n",
    "        return vysledek\n",
    "\n",
    "    return nova_funkce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Takový dekorátor pak můžeme jednoduše použít na jakoukoli funkci a zjistit, kdy byla volána a jak dlouho její volání trvalo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "@zmer_cas\n",
    "def mocnina_dvojky(mocnitel):\n",
    "    return 2 ** mocnitel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Volám funkci <function mocnina_dvojky at 0x7f84a02284c0> s argumenty (10,)\n",
      "Funkce běžela 0.000118255615234375 sekund\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mocnina_dvojky(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Volám funkci <function mocnina_dvojky at 0x7f84a02284c0> s argumenty (10000000,)\n",
      "Funkce běžela 0.038305044174194336 sekund\n"
     ]
    }
   ],
   "source": [
    "vysledek = mocnina_dvojky(10000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modul functools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dekorátorů je ve standardní knihovně celá řada a jsou hojně využívány i v populárních knihovnách, protože jejich použití může i zdánlivě složité implementace zjednodušit a zpřehlednit.\n",
    "\n",
    "Pojďme lehce nakouknout do obsahu modulu `functools`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### @lru_cache"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dekorátor `@functools.lru_cache` aktivuje paměť volání funkce a jejich výsledků. Hodí se především ve chvíli, kdy zpracování výsledků ve funkci trvá dlouho a je lepší si výsledky automaticky zapamatovat a vrátit je z paměti při dalším volání funkce se stejnými argumenty. To se může hodit například potřebujeme-li získat z internetu vícekrát stejnou informaci.\n",
    "\n",
    "Ukážeme si to na výpočtu čísel z Fibonacciho posloupnosti pomocí rekurze, kdy funkce volá samu sebe, a zapamatování si předchozích výsledků dává smysl."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "@lru_cache(maxsize=None)\n",
    "def fib(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    return fib(n-1) + fib(n-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkci několikrát zavoláme. Interně se navíc provede mnohokrát, protože při vyšších číslech se rekurzivně volá sama."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[fib(n) for n in range(16)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Následně je možné si u takto definované funkce zjistit statistiky paměti a úspěšnost její použití při opakovaných voláních."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CacheInfo(hits=28, misses=16, maxsize=None, currsize=16)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib.cache_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`maxsize` a `currsize` označují maximální a aktuální velikost paměti výsledků, `hits` označuje, kolikrát byl při volání funkce použit výsledek z paměti místo opětovného spuštění funkce a `misses` naopak kolikrát musela být funkce volána, protože výsledek v paměti nebyl k dispozici."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### partial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkce `partial` není dekorátorem, ale funkcí vyššího řádu, která umí předvyplnit argumenty do již existující funkce tak, aby její volání už je nemuselo obsahovat pokaždé všechny.\n",
    "\n",
    "Můžeme si tak jednoduše vytvořit vlastní `print`, který se bude chovat podle našich představ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Léto_je_tady!!!"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "muj_print = partial(print, end=\"!!!\", sep=\"_\")\n",
    "\n",
    "muj_print(\"Léto\", \"je\", \"tady\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkci `partial` předáme jako první argument funkci, ze které chceme vycházet, a jako další argumenty pak poziční a pojmenované argumenty, které se mají do původní funkce automaticky doplnit. Takto vytvořenou funkci pak můžeme jednoduše používat, aniž bychom museli opakující se argumenty neustále opakovat.\n",
    "\n",
    "Ti pozornější z vás si všimnou, že tímto způsobem bychom mohli elegantně vyřešit i naše funkce k výpočtu daní z nemovitosti."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### singledispatch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dekorátor `singledispatch` nám umožní mít definovány různé funkce pod stejným jménem a volat vždy jednu z nich podle typu prvního argumentu, který při volání předáme. Máte jednu funkci, která by se měla chovat jinak pro čísla, jinak pro řetězce a úplně jinak pro seznamy, ale pořád je to jedna funkce a dává smysl, aby měla jen jedno jméno? Pak je `singledispatch` to pravé.\n",
    "\n",
    "Nejdříve si definujeme základní funkci, která se zavolá, nebude-li žádná jiná vhodnější."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import singledispatch\n",
    "\n",
    "@singledispatch\n",
    "def funkce(argument):\n",
    "    print(f\"Zadal jsi {argument}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Další funkce můžeme k původní funkci registrovat pomocí dekorátoru, který nám tímto vznikl. Jméno u dalších funkcí není podstatné, takže se nejčastěji nahrazuje podtržítkem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "@funkce.register(int)\n",
    "def _(argument):\n",
    "    print(f\"Celé číslo děleno dvěma je {argument / 2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A v podobném duchu můžeme definovat další funkce pro další typy proměnných a všechny je schovat pod jedno jméno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "@funkce.register(list)\n",
    "def _(argument):\n",
    "    soucet = sum(argument)\n",
    "    print(f\"Součet prvků v seznamu je {soucet}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pokud pak budeme funkci volat, zavolá se vždy ta správná podle typu prvního argumentu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Celé číslo děleno dvěma je 2.5\n"
     ]
    }
   ],
   "source": [
    "funkce(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Součet prvků v seznamu je 6\n"
     ]
    }
   ],
   "source": [
    "funkce([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zadal jsi Pepa\n"
     ]
    }
   ],
   "source": [
    "funkce(\"Pepa\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "První definovaná funkce se zavolá vždy, když neexistuje žádná jiná, které by typ prvního argumentu odpovídal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zadal jsi {'jméno': 'Karel'}\n"
     ]
    }
   ],
   "source": [
    "funkce({\"jméno\": \"Karel\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobná situace by se dala řešit i podmínkami uvnitř funkce, ale v případě složitější logiky může `@singledispatch` ušetřit několik úrovní odsazení kódu a ubrat na komplexnosti."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkcionální programování"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Teorie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcionální programování je deklarativní programovací technikou, která je založena na funkcích bez vedlejších efektů, které jen produkují výsledky a spolu s výrazy se rekurzivně vyhodnocují až se dojde k výsledku. U funkcionálního programování se neukládá stav programu do proměnných (objektů), se kterým by pak funkce manipulovaly. Čistě funkcionální jazyky také neobsahují cykly ani podmínky (bloky).\n",
    "\n",
    "Definice není moc záživná a tak si za chvíli ukážeme nějaký příklad. Podstatné je ale mít na paměti, že i když nebudete programovat čistě funkcionálně, je dobré se z některých přístupů poučit a klidně je používat i v objektově orientovaném programování.\n",
    "\n",
    "Funkcionální programování se mimo jiné vyznačuje těmito vlastnostmi:\n",
    "* Funkce vrací výsledky a nemají žádné vedlejší efekty (nemění stav programu)\n",
    "* Výsledek funkce je závislý jen a pouze na vstupních argumentech\n",
    "* Nepoužívají se bloky s podmínkami ani cykly\n",
    "* Hojně se využívají rekurze a anonymní funkce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Příklady"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bloků s podmínkami se můžeme zbavit pomocí pravdivostních výrazů."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sude_liche(cislo):\n",
    "    if cislo % 2 == 0:\n",
    "        return \"sudé\"\n",
    "    else:\n",
    "        return \"liché\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkci `sude_liche` je možné přepsat na jednořádkový výraz a případně z něj udělat funkci pomocí lambdy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "sude_liche_2 = lambda x: (x % 2 == 0 and 'sudé') or ('liché')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Výsledky však zůstanou totožné."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'liché'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sude_liche(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'liché'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sude_liche_2(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cyklu `for` se můžeme jednoduše zbavit definicí funkce a její aplikace na všechny prvky sekvence pomocí `map` nebo pomocí list comprehensions.\n",
    "\n",
    "Cyklu `while` se nejsnáze zbavíme pomocí rekurze."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while n < 5:\n",
    "    n += 1\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_n(n=1):\n",
    "    n += 1\n",
    "    print(n)\n",
    "    return n if n >= 5 else get_n(n)\n",
    "\n",
    "get_n()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Příklady jsou jen ukázkou toho, jak se jednotlivé programovací techniky navzájem liší a jak je možné jedním jazykem napsat stejný program několika způsoby. Existují samozřejmě jazyky vyloženě určené pro funkcionální programování, u kterých tolik netrpí čitelnost kódu, ale jejich využití je zase do značné míry omezeno jinde.\n",
    "\n",
    "Další studium nechám na zájemcích."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Úkol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Úkolem po této lekci je:\n",
    "1. Znovu si projít celou lekci a zeptat se na případné nejasnosti\n",
    "2. Implementovat vlastní dekorátor, který najde uplatnění v některé z vašich aplikací nebo bude natolik obecný, že bude užitečný například pro ladění programu\n",
    "\n",
    "Úkoly a případné dotazy očekávám na emailu frenzy.madness@gmail.com"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}