02-oop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Objektově orientované programování"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![OOP](img/oop.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objekt\n",
    "\n",
    "= Všechno v Pythonu. K vnitřnostem objektu můžeme přistupovat pomocí tečky. Často představuje věci z reálného světa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "objekt = \"Iron Maiden\"\n",
    "objekt.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# i samotné číslo je objekt\n",
    "(4).__gt__(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# hierarchická struktura - předkem všeho je objekt\n",
    "issubclass(int, object), issubclass(float, object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Třída\n",
    "\n",
    "= *Obecný* předpis pro vytvoření objektu. Obsahuje:\n",
    "\n",
    "- **Atributy** = proměnné zabalené v objektu.  \n",
    "- **Metody** = funkce zabalené v objektu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Pes(object):\n",
    "\n",
    "    # metoda\n",
    "    def stekni(self):\n",
    "        print(\"haf\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Instance\n",
    "\n",
    "= Vytvořený objekt, *ten jeden konkrétní*.\n",
    "\n",
    "![Psiska](img/oop_trieda_vs_objekt.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# vytvoření instance třídy Pes\n",
    "alik = Pes()\n",
    "alik.jmeno = \"Alík\"  # <= atribut\n",
    "alik.stekni()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# jiná instance téže třídy\n",
    "mazlik = Pes()\n",
    "mazlik.jmeno = \"Mazlík\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# navzájem se neovlivňují\n",
    "print(alik.jmeno)\n",
    "print(mazlik.jmeno)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# avšak mají společné chování (definované v třídě Pes)\n",
    "alik.stekni()\n",
    "mazlik.stekni()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## OOP v Pythonu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### `self`\n",
    "\n",
    "= První argument u všech metod. **Automaticky** ukazuje na aktuální instanci"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### `__init__`\n",
    "\n",
    "= Konstruktor = metoda **automagicky** volaná ihned při vytvoření instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Pes(object):\n",
    "\n",
    "    # konstruktor\n",
    "    def __init__(self):\n",
    "        import random\n",
    "        self.jmeno = random.choice([\"Fík\", \"Alík\", \"Mazlík\"])\n",
    "\n",
    "    # při štěkání se představím\n",
    "    def stekni(self):\n",
    "        print(self.jmeno, \"-\", \"haf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "pes1 = Pes()\n",
    "pes2 = Pes()\n",
    "\n",
    "pes1.stekni()\n",
    "pes2.stekni()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Pes(object):\n",
    "\n",
    "    # konstruktor s parametrem\n",
    "    def __init__(self, xxx):\n",
    "        self.jmeno = xxx\n",
    "\n",
    "    def stekni(self):\n",
    "        print(self.jmeno, \"-\", \"haf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "pes1 = Pes(\"Rex\")\n",
    "pes2 = Pes(\"T-Rex\")\n",
    "\n",
    "pes1.stekni()\n",
    "pes2.stekni()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Pivní příklad\n",
    "\n",
    "- Vytvořte třídu `SudPiva`.\n",
    "- Vytvořte konstruktor, pomocí kterého nastavíte *značku piva* (proměnná) a *objem sudu* (vždy 50L).\n",
    "- Vytvořte metodu `natoc_pivo(objem_sklenice)`, která vypíše: *Točím pivo XXX do sklenice YYY, v sudu zbývá ZZZ.*\n",
    "- Ošetřete, pokud v sudu už není dostatek piva.\n",
    "\n",
    "**Použití:**\n",
    "- Naplňte výčep sudy piva různých značek.\n",
    "- V cyklu natočte 30 náhodných půllitrů piva (použijte [`random.choice`](https://docs.python.org/3/library/random.html#random.choice))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# TODO napsat třídu SudPiva\n",
    "\n",
    "vycep = []\n",
    "# TODO naplnit výčep\n",
    "# TODO 30x natočit náhodné pivo z výčepu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dědičnost\n",
    "\n",
    "= Vyjadřuje hierarchii tříd. Jedná se o *specializaci* objektů."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class DopravniProstredek(object):\n",
    "    \n",
    "    def __init__(self, rychlost):\n",
    "        self.rychlost = rychlost\n",
    "\n",
    "    def cestuj(self, odkud, kam):\n",
    "        print(\"cestuji rychlostí\", self.rychlost, \"km/h z\", odkud, \"do\", kam)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "neco = DopravniProstredek(100000)\n",
    "neco.cestuj(\"obýváku\", \"nekonečno a ještě dál\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Auto(DopravniProstredek):\n",
    "\n",
    "    def nastartuj(self):\n",
    "        print(\"startuji motor\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "skodovka = Auto(130)\n",
    "skodovka.nastartuj()\n",
    "skodovka.cestuj(\"Praha\", \"Plzeň\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Polymorfismus\n",
    "\n",
    "= Používám více *různých* objektů *stejným* způsobem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# více různých objektů\n",
    "trabant = Auto(90)\n",
    "porsche = Auto(300)\n",
    "kolobezka = DopravniProstredek(15)\n",
    "\n",
    "# využití stejným způsobem\n",
    "trabant.cestuj(\"Praha\", \"Brno\")\n",
    "porsche.cestuj(\"Praha\", \"Brno\")\n",
    "kolobezka.cestuj(\"Praha\", \"Brno\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Skládání\n",
    "\n",
    "= Objekty obsahují jiné objekty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Garaz(object):\n",
    "    pass\n",
    "\n",
    "class Kolo(DopravniProstredek):\n",
    "    pass\n",
    "\n",
    "g = Garaz()\n",
    "g.prvni_misto = Auto(130)\n",
    "g.druhe_misto = Kolo(30)\n",
    "\n",
    "# řetězení tečkové notace\n",
    "g.prvni_misto.cestuj(\"garáž\", \"práce\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Skládání nebo dědičnost?\n",
    "\n",
    "Typicky obojí dohromady.\n",
    "\n",
    "- **Dědičnost** - \"Co objekt *je*? Čeho je objekt *specializací*?\"\n",
    "- **Skládání** - \"Z jakých *komplexních částí* je objekt složen?\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Třídní / instanční (atributy a metody)\n",
    "\n",
    "- **Instanční** = `self`\n",
    "- **Třídní** = `cls` nebo *jméno třídy*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Clovek(object):\n",
    "    \n",
    "    # třídní\n",
    "    pocet_lidi = 0\n",
    "\n",
    "    # instanční\n",
    "    def __init__(self, jmeno):\n",
    "        self.jmeno = jmeno  # instanční\n",
    "        Clovek.pocet_lidi += 1  # třídní\n",
    "\n",
    "    # třídní\n",
    "    @classmethod\n",
    "    def je_svet_prelidneny(cls):\n",
    "        return cls.pocet_lidi >= 3  # třídní"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "d = Clovek(\"David\")\n",
    "print(Clovek.je_svet_prelidneny())\n",
    "\n",
    "m = Clovek(\"Martina\")\n",
    "print(Clovek.je_svet_prelidneny())\n",
    "\n",
    "j = Clovek(\"Jana\")\n",
    "print(Clovek.je_svet_prelidneny())\n",
    "\n",
    "print(Clovek.pocet_lidi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Zapouzdření\n",
    "\n",
    "= Objekt poskytuje veřejné rozhraní, na zbytek *zvenku nesahat*. Jedná se pouze o *konveci*, privátní atributy nebo metody v Pythonu neexistují."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Smartphone(object):\n",
    "    \n",
    "    def __init__(self, oznaceni):\n",
    "        casti = oznaceni.split()\n",
    "        # privátní atributy\n",
    "        self._vyrobce = casti[0]\n",
    "        self._model = casti[1:]\n",
    "        \n",
    "    # privátní metoda\n",
    "    def _update_systemu(self):\n",
    "        print(\"updatuji system\")\n",
    "        \n",
    "    def vypis_model(self):\n",
    "        print(\" \".join(self._model))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "mobil = Smartphone(\"Huňavej BŽ 10000\")\n",
    "    \n",
    "# NE - tohle nikdy\n",
    "print(mobil._model)\n",
    "\n",
    "# správně\n",
    "mobil.vypis_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![Magic!](img/harry-python.png)\n",
    "\n",
    "# Magické metody\n",
    "\n",
    "= Metody pojmenované `__nazev__` mají nějakou speciální funkci. [Perfektní přehled těchto metod](http://web.archive.org/web/20161022174026/http://www.rafekettler.com/magicmethods.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Zebrik(object):\n",
    "\n",
    "    # konstruktor je magická metoda!\n",
    "    def __init__(self, delka):\n",
    "        self.delka = delka  # metry\n",
    "    \n",
    "    # volá se při použití operátoru `<` (lower than)\n",
    "    def __lt__(self, other):\n",
    "        return self.delka < other.delka\n",
    "    \n",
    "    # volá se při pokusu vypsat objekt\n",
    "    def __str__(self):\n",
    "        return \"#\" * self.delka"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "dlouhy = Zebrik(3)\n",
    "kratky = Zebrik(1)\n",
    "\n",
    "# použití __lt__\n",
    "print(dlouhy < kratky)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# řazení bez použití parametru `key` - interní použití __lt__\n",
    "pozarni_sklad = sorted([Zebrik(2), Zebrik(18), Zebrik(6)])\n",
    "\n",
    "# použití __str__\n",
    "print(pozarni_sklad[0])\n",
    "print(pozarni_sklad[1])\n",
    "print(pozarni_sklad[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Příklad\n",
    "\n",
    "- Vytvořte třídu `KusTextu`, která umožní postupně sestavovat kusy textu.\n",
    "- Uvnitř třídy vytvořte metodu `pridej(\"text\")`.\n",
    "- Jakmile bude přidaný text obsahovat tečku, inkremetujte **celkový počet vět** (použijte třídní atribut).\n",
    "- Zajistěte, aby bylo možné kus textu vypsat pomocí běžného `print()`.\n",
    "- Zajistěte možnost řetězení: `pridej(\"x\").pridej(\"y\").pridej(\"z\")...`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO napsat třídu KusTextu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# následující kód by měl ve finále fungovat\n",
    "\n",
    "# xx = KusTextu()\n",
    "# yy = KusTextu()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# xx.pridej(\"Jak na Nový rok,\")\n",
    "# yy.pridej(\"Kdo jinému jámu kopá,\")\n",
    "\n",
    "# xx.pridej(\" tak po celý rok.\")\n",
    "# yy.pridej(\" sám do ní spadne.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# print(KusTextu.celkovy_pocet_vet)  # = 2\n",
    "# print(xx)  # = Jak na Nový rok, tak po celý rok.\n",
    "# print(yy)  # = Kdo jinému jámu kopá, sám do ní spadne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# zz = KusTextu()\n",
    "# zz.pridej(\"Starého psa\").pridej(\" novým\").pridej(\" kouskům nenaučíš.\")\n",
    "# print(zz)  # = Starého psa novým kouskům nenaučíš."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Kontextové manažery\n",
    "\n",
    "= Původne určtěny k eliminaci `try-except` bloků ([PEP 343](https://www.python.org/dev/peps/pep-0343/)). Nicméně dají se hezky zneužít na spoustu věcí..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```python\n",
    "with neco as x:\n",
    "    print(\"libovolný blok kódu\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Python automaticky volá `neco.__enter__()` a `neco.__exit__()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class zvyraznovac(object):\n",
    "    \n",
    "    def __enter__(self):\n",
    "        print(\"=\" * 80)\n",
    "    \n",
    "    def __exit__(self, *exception_info):\n",
    "        print(\"=\" * 80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with zvyraznovac():\n",
    "    print(\"Ahoj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# parametry v konstruktoru\n",
    "\n",
    "class zvyraznovac_2(object):\n",
    "    \n",
    "    def __init__(self, znak, delka):\n",
    "        self.znak = znak\n",
    "        self.delka = delka\n",
    "    \n",
    "    def __enter__(self):\n",
    "        print(self.znak * self.delka)\n",
    "    \n",
    "    def __exit__(self, *exception_info):\n",
    "        print(self.znak * self.delka)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with zvyraznovac_2(\"-\", 10):\n",
    "    print(\"Ahoj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# vracíme FUNKCI z __enter__\n",
    "\n",
    "class ramecek(object):\n",
    "    \n",
    "    def vypis_oramovany_radek(self, text):\n",
    "        print(\"| {:76s} |\".format(text))\n",
    "    \n",
    "    def __enter__(self):\n",
    "        print(\"-\" * 80)\n",
    "        return self.vypis_oramovany_radek\n",
    "    \n",
    "    def __exit__(self, *exception_info):\n",
    "        print(\"-\" * 80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with ramecek() as oramovany_print:\n",
    "    oramovany_print(\"Ahoj\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# vracíme True (=ignoruj chyby) z __exit__\n",
    "\n",
    "class ignoruj_chyby(object):\n",
    "    \n",
    "    def __enter__(self):\n",
    "        pass\n",
    "    \n",
    "    def __exit__(self, exception_type, exception_value, traceback):\n",
    "        return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with ignoruj_chyby():\n",
    "    nedefinovana_promenna"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Příklad\n",
    "- Vytvořte kontextový manažer `USB`, který vypíše informace o připojení a odpojení zařízení.\n",
    "- Přidejte možnost specifikovat port v konstruktoru.\n",
    "- Přidejte metodu `precti()`, která vrátí \"xxx\", a metodu `zapis(data)`, která vypíše \"zapisuji 'data'\".\n",
    "- Pokud při práci s USB nastane výjimka, vypište info o špatném odpojení (výjimku nepotlačujte).\n",
    "- **Bonus:** Zkuste si napsat to samé bez metod `precti()` a `zapis()` s pomocí [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# TODO implementace kontextového manažeru USB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# následující kód by měl ve finále fungovat\n",
    "\n",
    "# with USB(\"/dev/sdb1\") as flash_disk:  # = připojuji USB zařízení '/dev/sdb1'\n",
    "#     print(flash_disk.precti())        # = xxx\n",
    "#     flash_disk.zapis(\"xxx\")           # = zapisuji 'xxx'\n",
    "#     1 / 0                             # = ŠPATNÉ ODPOJENÍ - odpojuji USB zařízení (+ Error...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Enumy\n",
    "= Seskupené konstanty (Python 3.4+)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from enum import Enum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Barva(Enum):\n",
    "    CERVENA = \"#FF0000\"\n",
    "    ZELENA = \"#00FF00\"\n",
    "    MODRA = \"#0000FF\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(Barva.CERVENA)\n",
    "print(Barva.CERVENA is Barva.CERVENA)\n",
    "print(Barva.CERVENA.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(Barva.CERVENA == \"#FF0000\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(Barva(\"#FF0000\"))\n",
    "print(Barva['CERVENA'])\n",
    "# Barva('xxx')  # ValueError: 'xxx' is not a valid Barva"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Abstraktní třídy\n",
    "= Nelze přímo instancovat. Jejich potomci musí povinně implementovat nějaké metody."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from abc import ABCMeta, abstractmethod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Cizinec(metaclass=ABCMeta):\n",
    "    \n",
    "    def zamavej(self):\n",
    "        print(\"👋\")\n",
    "\n",
    "    @abstractmethod\n",
    "    def pozdrav(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Francouz(Cizinec):\n",
    "\n",
    "    def pozdrav(self):\n",
    "        print(\"Allô.\")\n",
    "\n",
    "\n",
    "class Anglican(Cizinec):\n",
    "\n",
    "    def pozdrav(self):\n",
    "        print(\"Hello.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Cizinec()  # nelze, vyhodí chybu\n",
    "\n",
    "Francouz().pozdrav()\n",
    "Francouz().zamavej()\n",
    "\n",
    "Anglican().pozdrav()\n",
    "Anglican().zamavej()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Mixiny\n",
    "= Přidávají libovolné chování třídě."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Kniha(object):\n",
    "\n",
    "    def polej(self):\n",
    "        print(\"Ajee\")\n",
    "\n",
    "    \n",
    "class HarryPotter(Kniha):\n",
    "    pass\n",
    "\n",
    "\n",
    "hp = HarryPotter()\n",
    "hp.polej()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import uuid\n",
    "\n",
    "class UUIDMixin(object):\n",
    "\n",
    "    def get_uuid(self):\n",
    "        if not hasattr(self, \"_uuid\"):\n",
    "            self._uuid = uuid.uuid4()\n",
    "        return self._uuid\n",
    "\n",
    "# celkem univerzální implementace ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class HarryPotter(Kniha, UUIDMixin):\n",
    "    pass\n",
    "\n",
    "\n",
    "hp = HarryPotter()\n",
    "hp.polej()\n",
    "print(hp.get_uuid())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Příklad\n",
    "\n",
    "- Vytvořte abstraktní třídu `Nabytek` s abstraktní metodou `popis()`.\n",
    "- Vytvořte třídy `Stul`, `Zidle` jako potomky `Nabytek`.\n",
    "- Vytvořte enum `Stav`, který obsahuje hodnoty `NOVY` a `STARY`.\n",
    "- Vytvořte mixin `StavMixin`, který obsahuje metody `zestarni()`, `renovuj()` a `aktualni_stav()`.\n",
    "- Přidejte *pouze židlím* možnost nastavovat a zjišťovat stáří pomocí vytvořeného mixinu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO split úkoly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# následující kód by měl ve finále fungovat\n",
    "\n",
    "# print(Stul().popis())\n",
    "# print(Zidle().popis())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# zdl = Zidle()\n",
    "# print(zdl.popis())\n",
    "# zdl.zestarni()\n",
    "# assert zdl.aktualni_stav() == Stav.STARY, \"Stav po volání zestarni() by měl být Stav.STARY\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Zdroje obrázků:\n",
    "\n",
    "- https://twitter.com/philwinkle/status/688441014160355328\n",
    "- http://www.zajtra.sk/programovanie/165/objektovo-orientovane-programovanie-v-normalnej-ludskej-reci\n",
    "- https://www.reddit.com/r/funny/comments/2hu6x0/harry_speaks_python/"
   ]
  }
 ],
 "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
}