01-funkce.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Funkce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def secist(x, y=0):\n",
    "    print(\"x je {}, y je {}\".format(x, y))\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "secist(5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# pojmenované argumenty lze předat v libovolném pořadí\n",
    "secist(y=6, x=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Příklad\n",
    "Napište funkci, která má jako parametry 3 strany trojúhelníku a vrací `True/False` podle toho, jestli je daný trojúhelník reálný (jestli platí trojúhelníhová nerovnost)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if nerovnost(1, 1, 1) == True:\n",
    "    print(\"funguje\")\n",
    "if nerovnost(99, 1, 1) == False:\n",
    "    print(\"funguje\")\n",
    "if nerovnost(10, 1, 1) == False:\n",
    "    print(\"funguje\")\n",
    "if nerovnost(1, 2, 3) == False:\n",
    "    print(\"funguje\")\n",
    "if nerovnost(2, 2, 3) == True:\n",
    "    print(\"funguje\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Příklad\n",
    "\n",
    "Napište funkci, která *vrátí* N-tý člen Fibonacciho řady."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Proměnné počty argumentů\n",
    "\n",
    "Nutno rozlišovat:\n",
    "- poziční = *při volání* záleží na jejich **pořadí**\n",
    "- pojmenované = *při volání* záleží na jejich **pojmenování**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def zpracuj_posledni_soubor(*soubory):  # proměnný počet pozičních\n",
    "    return \"zpracováno: \" + soubory[-1]\n",
    "\n",
    "zpracuj_posledni_soubor('soubor1', 'soubor2', 'soubor3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def vypis_cele_jmeno(**data):  # proměnný počet pojmenovaných\n",
    "\n",
    "    if \"jmeno\" in data and \"prijmeni\" in data:\n",
    "        print(  \"{} {}\".format(data[\"jmeno\"], data[\"prijmeni\"])  )\n",
    "\n",
    "    elif \"prijmeni\" in data:\n",
    "        print(data[\"prijmeni\"])\n",
    "    \n",
    "    elif \"jmeno\" in data:\n",
    "        print(data[\"jmeno\"])\n",
    "    \n",
    "    else:\n",
    "        print(\"(neznámá osoba)\")\n",
    "\n",
    "vypis_cele_jmeno(jmeno=\"Milan\", vyska=180, vek=20, prijmeni=\"Frajer\")\n",
    "vypis_cele_jmeno()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Konvence:**\n",
    "- poziční = `*args`\n",
    "- pojmenované = `**kwargs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# lze použít obojí najednou\n",
    "def vypis_vse(*args, **kwargs):\n",
    "    print(args, kwargs)  # print() vypíše všechny své parametry\n",
    "\n",
    "vypis_vse(1, 2, a=3, b=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Rozbaluju, rozbaluješ, rozbalujeme\n",
    "`*` nebo `**` lze použít při volání funkce k rozbalení N-tic nebo slovníků!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ntice = (1, 2, 3, 4)\n",
    "slovnik = {\"a\": 3, \"b\": 4}\n",
    "\n",
    "vypis_vse(ntice)                 # = vypis_vse((1, 2, 3, 4)) – jeden parametr, N-tice\n",
    "vypis_vse(*ntice)                # = vypis_vse(1, 2, 3, 4) – čtyři parametry\n",
    "vypis_vse(**slovnik)             # = vypis_vse(a=3, b=4) – dva pojmenované parametry\n",
    "vypis_vse(*ntice, **slovnik)     # = vypis_vse(1, 2, 3, 4, a=3, b=4) – mix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mini-příklad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nastav_budik(den, hodina, minuta=0):\n",
    "    print(\"Nastavuji budík na '{}' v '{}' hodin '{}' minut.\".format(den, hodina, minuta))\n",
    "\n",
    "\n",
    "pracovni_den = {\n",
    "    \"den\": \"pondeli\",\n",
    "    \"hodina\": 6\n",
    "}\n",
    "\n",
    "\n",
    "# TODO zavolat nastavení budíku - jak?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Viditelnost proměnných"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# vytvořme globální proměnnou x\n",
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def nastav_x(cislo):\n",
    "    x = cislo  # lokální\n",
    "    print(x)\n",
    "    \n",
    "nastav_x(42)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def nastav_globalni_x(cislo):\n",
    "    global x\n",
    "    print(x)  # lze číst už zde\n",
    "    x = cislo  # globální efekt\n",
    "    print(x)\n",
    "\n",
    "nastav_globalni_x(6)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funkce jako *first class objects*\n",
    "\n",
    "> In short, it means there are no restrictions on the object's use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def secti(a, b):\n",
    "    \"\"\"Sečte dvě čísla.\"\"\"\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# můžeme je volat (wow)\n",
    "print(secti(1, 2))\n",
    "\n",
    "# lze je aliasovat\n",
    "add = secti\n",
    "print(add(2, 5))\n",
    "\n",
    "# lze smazat původní referenci\n",
    "del secti\n",
    "print(add(10, 11))\n",
    "\n",
    "# mají atributy\n",
    "print(add.__doc__)\n",
    "\n",
    "# lze je přepsat jinými hodnotami\n",
    "add = 3\n",
    "print(add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Uzávěry (closures)\n",
    "\n",
    "= Funkce, které si s sebou nesou *kontext*. Fungují tak např. dekorátory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from random import random\n",
    "\n",
    "def vyrob_scitacku(pricitane_cislo):\n",
    "    chyba = random()\n",
    "\n",
    "    # vytvoříme uzávěru\n",
    "    def scitacka(x):\n",
    "        # mám k dispozici:\n",
    "        # - `x` (parametr, dynamický)\n",
    "        # - `chyba` (z kontextu)\n",
    "        # - `pricitane_cislo` (z pohledu uzávěry to samé jako magicke_cislo)\n",
    "        return x + chyba + pricitane_cislo\n",
    "\n",
    "    # `scitacka` je first class object...\n",
    "    return scitacka"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "pricti_5 = vyrob_scitacku(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# stále stejná \"chyba\"\n",
    "print(pricti_5(10))\n",
    "print(pricti_5(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "del vyrob_scitacku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# uzávěra stále drží kontext i po smazání původní funkce\n",
    "pricti_5(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dekorátor\n",
    "= Funkce, která dostane jako parametr jednu funkci a vrátí **libovolnou** funkci, která nahradí tu původní."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def samoucelny_dekorator(puvodni_fce):\n",
    "    return puvodni_fce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@samoucelny_dekorator\n",
    "def vypis_text(text):\n",
    "    print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "vypis_text(\"Ahoj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# co se vlastně stalo:\n",
    "\n",
    "@samoucelny_dekorator\n",
    "def vypis_text(text):\n",
    "    print(text)\n",
    "\n",
    "# ... je ekvivalentní ...\n",
    "\n",
    "def vypis_text(text):\n",
    "    print(text)\n",
    "vypis_text = samoucelny_dekorator(vypis_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### K čemu to lze využít?\n",
    "\n",
    "- nahrazení původní funkce jinou\n",
    "- zapsání do nějaké evidence\n",
    "- přidání chování před/za kód původní funkce\n",
    "- ... fantazii se meze nekladou ;)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# nahrazení původní funkce jinou\n",
    "\n",
    "def nahrad(puvodni_fce):\n",
    "\n",
    "    def podstrcena_fce():\n",
    "        print(\"Je to kampaň, účelovka!\")\n",
    "\n",
    "    return podstrcena_fce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@nahrad\n",
    "def pozdrav():\n",
    "    print(\"Ahoj\")\n",
    "\n",
    "pozdrav()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# zapsání do nějaké evidence\n",
    "\n",
    "zavolat_pri_ukonceni = []\n",
    "\n",
    "def nakonec(fce):\n",
    "    zavolat_pri_ukonceni.append(fce)\n",
    "    return fce\n",
    "\n",
    "def konec_programu():\n",
    "    for fce in zavolat_pri_ukonceni:\n",
    "        fce()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@nakonec\n",
    "def rozluc_se():\n",
    "    print(\"Děkujeme za použití programu!\")\n",
    "\n",
    "@nakonec\n",
    "def uzavri_soubory():\n",
    "    print(\"Uzavírám používané soubory...\")\n",
    "\n",
    "konec_programu()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Příklad\n",
    "\n",
    "Napište dekorátor `stopky`, který změří čas potřebný pro vykonání funkce a vypíše ho.\n",
    "\n",
    "- Vytvořte dekorátor, který nic neměří, ale volá původní funkci (předpokládejte bezparametrickou fci).\n",
    "- Přidejte měření.\n",
    "- Doplňte dekorátor tak, aby zvládal libovolně parametrické funkce.\n",
    "- **Hardcore:** Upravte vše tak, aby *dekorátor byl parametrický*.\n",
    "- **Super-hardcore:** Upravte vše tak, aby fungovala parametrická i neparametrická varianta."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# hardcore varianta\n",
    "\n",
    "@stopky(30)  # automaticky opakuje měření 30x, výsledek průměruje\n",
    "def merena_fce(...):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from time import perf_counter\n",
    "from datetime import timedelta\n",
    "\n",
    "\n",
    "# ukázka měření času\n",
    "\n",
    "start = perf_counter()\n",
    "\n",
    "x = \"hello\"\n",
    "\n",
    "end = perf_counter()\n",
    "diff = timedelta(seconds=end-start)\n",
    "print(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# TODO implementovat stopky\n",
    "\n",
    "\n",
    "# TODO přidat dekorátor\n",
    "def bez_parametru():\n",
    "    \"\"\"Udělá hrozně nefektivní operaci.\"\"\"\n",
    "    x = \"\"\n",
    "    for i in range(1000000):\n",
    "        x += str(i) + \" \"\n",
    "\n",
    "# TODO přidat dekorátor\n",
    "def s_parametrem(kolikrat):\n",
    "    \"\"\"Udělá hrozně nefektivní operaci kolikrát chcete.\"\"\"\n",
    "    x = \"\"\n",
    "    for i in range(kolikrat):\n",
    "        x += str(i) + \" \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "bez_parametru()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "s_parametrem(1000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(bez_parametru.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lambda funkce\n",
    "\n",
    "= Bezejmenné funkce *na jeden řádek*, automatický `return`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "lambda x: x ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Široké použití\n",
    "\n",
    "Uzávěry, `filter`, `map`, řazení, callbacky, ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![kašna lambda](img/kasna-lambda.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Uzávěra pomocí lambdy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# výše uvedené ještě jednou\n",
    "def vyrob_scitacku(pricitane_cislo):\n",
    "    chyba = random()\n",
    "    return (lambda x: x + chyba + pricitane_cislo)\n",
    "\n",
    "base_of_the_universe = vyrob_scitacku(42)\n",
    "base_of_the_universe(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `map`\n",
    "\n",
    "Vrátí novou sekvenci na základě staré, kde *na každý prvek aplikuje funkci*.\n",
    "\n",
    "### `filter`\n",
    "\n",
    "Vrátí novou sekvenci na základě staré, kde na každý prvek aplikuje *funkci, která rozhodne o přítomnosti* prvku v nové sekvenci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "data = [1, 2, 8, 5, 0, 4, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# filtrování bez lambdy\n",
    "def je_sude(x):\n",
    "    return (x % 2) == 0\n",
    "\n",
    "list(filter(je_sude, data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# s lambdou\n",
    "list(filter(lambda x: x % 2 == 0, data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# mapování s lambdou\n",
    "list(map(lambda x: x ** 2, data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `sorted`\n",
    "\n",
    "Vrátí novou sekvenci seřazenou buď výchozím způsobem, nebo podle *výstupu z funkce, která vrací \"řadící klíč\"*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "jmena = [\"Zita\", \"Adam\", \"Dan\"]\n",
    "sorted(jmena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# alternativní řadící klíč\n",
    "def posledni_pismeno(text):\n",
    "    return text[-1]\n",
    "\n",
    "sorted(jmena, key=posledni_pismeno)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# s lambdou mnohem elegantnější\n",
    "sorted(jmena, key=lambda jmeno: jmeno[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anti-patterns – aneb co NEdělat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# NE - vyrábět z lambdy běžnou funkci\n",
    "na_druhou = lambda x: x ** 2\n",
    "na_druhou(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# lepší - pokud vím, že ji budu používat opakovaně\n",
    "def na_druhou(x):\n",
    "    return x ** 2\n",
    "\n",
    "na_druhou(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# NE - vnořené lambdy\n",
    "vzorky = [\n",
    "    (3, 12, 90),\n",
    "    (2, 12, 88),\n",
    "    (2, 11, 97),\n",
    "]\n",
    "sorted(vzorky, key=lambda vzorek: max(filter(lambda x: x % 2 == 0, vzorek)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# lepší (používá definici `je_sude` výše)\n",
    "sorted(vzorky, key=lambda vzorek: max(filter(je_sude, vzorek)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# nejlepší\n",
    "def max_sude(data):\n",
    "    return max(filter(je_sude, data))\n",
    "\n",
    "sorted(vzorky, key=max_sude)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Příklad\n",
    "\n",
    "Napište lambda funkci, která po předání do `sorted` *zamíchá* řazená data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "chceme_zamichat = list(range(20))\n",
    "\n",
    "# TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Zdroje obrázků:\n",
    "- http://plzensky.denik.cz/zpravy_region/zlate-kasny-na-namesti-i-po-sesti-letech-stale-budi-vasne-20160513.html"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}