p1/dodatna predavanja/05 dekoratorji.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dekoratorji\n",
    "\n",
    "Tale tema bo za mnoge naporna miselna vaja. Vendar koristna.\n",
    "\n",
    "Najprej ponovimo nekaj, kar smo se naučili prejšnji teden.\n",
    "\n",
    "### Funkcija, ki vrača funkcijo\n",
    "\n",
    "Tole je funkcija, ki predstavlja polinom $2 x^2 + 4 x + 3$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def poly243(x):\n",
    "    return 2 * x ** 2 + 4 * x + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trivialno. Pokličimo jo, samo za poskus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly243(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj pa bi rad naredil funkcijo, ki sestavlja takšne polinome. Torej: funkcija `create_poly(a, b, c)` bo kot argumente dobila koeficiente polinoma ter sestavila (in vrnila) polinom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_poly(a, b, c):\n",
    "    def poly(x):\n",
    "        return a * x ** 2 + b * x + c\n",
    "    \n",
    "    return poly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S to funkcijo lahko sestavimo gornjo funkcijo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "poly243 = create_poly(2, 4, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če razmislimo, kaj se zgodi - očitno se zgodi praktično isto kot prej: ko pokličemo `create_poly(2, 4, 3)` se zgodi definicija funkcije `poly` (s koeficienti 2, 4, 3), ki prejme le en argument `x`. Funkcija `create_poly` vrne to funkcijo in to funkcijo priredimo imenu `poly243`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly243(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pakiranje in razpakiranje argumentov\n",
    "\n",
    "Ali: funkcije s poljubnim številom argumentov. In klicanje z neznanim številom argumentov.\n",
    "\n",
    "Nadaljujmo kar s polinomom. Obstajajo tudi polinomi, ki niso druge stopnje. Obstajajo tudi takšni tretje, ali celo četrte. Naša funkcija `create_poly` pa dela le polinome druge stopnje. Posplošimo jo.\n",
    "\n",
    "Najprej razmislimo, kako izračunati polinom poljubne stopnje, če imamo seznam (ali terko) koeficientov, recimo `coefs = [c3, c2, c1, c0]` in vrednost `x`. Napisali bomo funkcijo, ki kot argument dobi koeficiente in vrednost x - kar očitno ni isto kot funkcija, ki smo jo pisali zgoraj; v zgornjo so koeficienti že vdelani.\n",
    "\n",
    "En način je:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def poly_x(x, coefs):\n",
    "    y = 0\n",
    "    for i in range(len(coefs)):\n",
    "        y += coefs[i] * x ** (len(coefs) - i - 1)\n",
    "    return y\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Upam, da sem vam tega že izbil iz glave, saj lahko uporabimo `enumerate`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def poly_x(x, coefs):\n",
    "    y = 0\n",
    "    for i, coef in enumerate(coefs):\n",
    "        y += coef * x ** (len(coefs) - i - 1)\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tudi to je sicer dokaj neprivlačno; osnovni problem je, da so koeficienti našteti od višjih potenc proti nižjim, vendar je tako prav: tudi polinome vedno pišemo v takem vrstnem redu.\n",
    "\n",
    "Uporabimo malo osnovnošolske matematike: $c_3x^3 + c_2x^2 + c_1x^1 + c_0x^0$ je isto kot $(((c_3 x + c_2) x + c_1) x + c_0$. (Ta reč ima celo ime: Hornerjevo pravilo. Če boste imeli kdaj kakšen predmet v slogu numeričnih metod, vas bodo učili celo, da je ta oblika boljša, ker je numerično stabilnejša, to je, vodi v manjše zaokrožitvene napake.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def poly_x(x, coefs):\n",
    "    y = 0\n",
    "    for coef in coefs:\n",
    "        y = x * y + coef\n",
    "    return y\n",
    "\n",
    "x = 4\n",
    "poly_x(x, [2, 4, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luštno bi bilo, če bi lahko podali številke kar kot argumente, na primer `poly_x(x, 2, 4, 3)`. Funkcija, ki prejme poljubno število argumentov, kot vemo od prejšnjega tedna, deklarira argument, katerega ime se začne z `*` in ta argument bo terka z vsemi dodatnimi argumenti - torej našimi koeficienti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def poly_x(x, *coefs):\n",
    "    y = 0\n",
    "    for coef in coefs:\n",
    "        y = x * y + coef\n",
    "    return y\n",
    "\n",
    "x = 4\n",
    "poly_x(x, 2, 4, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spremenilo se je samo to, da smo dodali zvezdico.\n",
    "\n",
    "Ta funkcija prejme `x` in koeficiente. Radi bi takšno, ki prejme le `x`, koeficiente pa že ima. Torej, želeli bi `create_poly`, ki bo ustvarila `poly`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_poly(*coefs):\n",
    "    def poly(x):\n",
    "        y = 0\n",
    "        for coef in coefs:\n",
    "            y = x * y + coef\n",
    "        return y\n",
    "        \n",
    "    return poly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly324 = create_poly(2, 4, 3)\n",
    "poly324(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkcija, ki ovije funkcijo\n",
    "\n",
    "Recimo, da bi hoteli iz nekega neumnega razloga želeli, da `sqrt`, `sin` in `cos` vračajo zaokrožajo rezultate na tri decimalke. Lahko napišemo nove funkcije, ki povozijo stare."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def rounded_sqrt(x):\n",
    "    y = math.sqrt(x)\n",
    "    return round(y, 3)\n",
    "    \n",
    "def rounded_sin(x):\n",
    "    y = math.sin(x)\n",
    "    return round(y, 3)\n",
    "    \n",
    "def rounded_cos(x):\n",
    "    y = math.cos(x)\n",
    "    return round(y, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.236"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rounded_sqrt(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lahko pa napišemo funkcijo, ki sestavlja takšne funkcije. Prej smo napisali funkcijo, ki definira in vrne funkcijo, ki računa polinome. Zdaj pa bomo napisali funkcijo, ki definira funkcijo, ki pokliče neko funkcijo (`math.sqrt`, `math.sin`, `math.cos`...) in vrne njen rezultat zaokrožen na tri decimalke. Tako kot je bila `poly` prej funkcija znotraj `create_poly`, bo zdaj funkcija, kot so zgornje, znotraj funkcije ... no, imenujmo jo `rounder`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rounder(f):\n",
    "    def rounded_f(x):  # funkcija, ekvivalentna gornjim rounded_sqrt, rounded_sin...\n",
    "        y = f(x)\n",
    "        return round(y, 3)\n",
    "    \n",
    "    return rounded_f\n",
    "\n",
    "rounded_sqrt = rounder(math.sqrt)\n",
    "rounded_sin = rounder(math.sin)\n",
    "rounded_cos = rounder(math.cos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seveda lahko na podoben način ovijamo tudi svoje funkcije."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi\n",
    "\n",
    "def circumf(r):\n",
    "    return 2 * pi * r\n",
    "\n",
    "rounded_circumf = rounder(circumf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`rounder` je imenitna in gotovo izjemno uporabna funkcija (no, to pač ne), še imenitnejša pa bo, če ne bo pričakovala, da ovita funkcija (`rounded_f`) vedno prejme samo en argument. Takole jo popravimo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rounder(f):\n",
    "    def rounded_f(*args):  # funkcija, ekvivalentna gornjim rounded_sqrt, rounded_sin...\n",
    "        y = f(*args)\n",
    "        return round(y, 3)\n",
    "    \n",
    "    return rounded_f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podobno kot smo se učili zgoraj, tudi tu pridemo do poljubnega števila argumentov tako, da uporabimo zvezdico; za takšne argumente navadno uporabimo ime `args`. Zgoraj pa nismo ponovili (pač pa smo prejšnji teden vseeno videli), kako pokličemo funkcijo, če imamo argumente v terki: spet tako, da damo pred terko zvezdico, torej `y = f(*args)`.\n",
    "\n",
    "## Vohun\n",
    "\n",
    "Zdaj pa naredimo nekaj, kar bi bilo morda lahko celo uporabno: funkcijo, ki, podobno kot `rounder`, ovije funkcijo, vendar pusti rezultat pri miru. Pač pa ob vsakem klicu funkcije izpiše argumente in rezultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spied(f):\n",
    "    def spied_f(*args):\n",
    "        y = f(*args)\n",
    "        print(\"Function\", f.__name__, \"called with\", args, \", returned\", y)\n",
    "        return y\n",
    "    \n",
    "    return spied_f\n",
    "\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "add = spied(add)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Function add called with (42, 0) , returned 42\n",
      "Function add called with (42, 1) , returned 43\n",
      "Function add called with (42, 2) , returned 44\n",
      "Function add called with (42, 3) , returned 45\n",
      "Function add called with (42, 4) , returned 46\n"
     ]
    }
   ],
   "source": [
    "v = []\n",
    "for x in range(5):\n",
    "    v.append(add(42, x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spet, na podoben način bi lahko ovili tudi Pythonove funkcije."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Function sqrt called with (0,) , returned 0.0\n",
      "Function sqrt called with (1,) , returned 1.0\n",
      "Function sqrt called with (2,) , returned 1.4142135623730951\n",
      "Function sqrt called with (3,) , returned 1.7320508075688772\n",
      "Function sqrt called with (4,) , returned 2.0\n"
     ]
    }
   ],
   "source": [
    "sqrt = spied(math.sqrt)\n",
    "\n",
    "v = []\n",
    "for x in range(5):\n",
    "    v.append(sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dekoratorji\n",
    "\n",
    "Takšnih funkcij bomo, za vajo, napisali še nekaj. Zdaj pa se naučimo drugačnega načina za njihovo rabo. Omogočil nam bo, da se izognemo temu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "add = spied(add)\n",
    "\n",
    "def sub(a, b):\n",
    "    return a - b\n",
    "\n",
    "sub = spied(sub)\n",
    "\n",
    "def circumf(r):\n",
    "    return 2 * pi * r\n",
    "\n",
    "circumf = rounder(circumf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vzorec je povsod isti: imamo funkcijo, ki jo hočemo oviti v neko drugo funkcijo, tako da uporabimo funkcijo za ovijanje. `rounder` je funkcije, ki ovije `circumf` v neko lokalno funkcijo (ki kliče originalno). Ker je to še kar pogosta zadeva, obstaja krajši, preglednejši način: dekoratorji. Namesto zgornjega lahko pišemo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "@spied\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "@spied\n",
    "def sub(a, b):\n",
    "    return a - b\n",
    "\n",
    "@rounder\n",
    "def circumf(r):\n",
    "    return 2 * pi * r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z\n",
    "\n",
    "```python\n",
    "@decorator\n",
    "def f(...):\n",
    "    ...\n",
    "```\n",
    "\n",
    "definiramo neko funkcijo `f`, jo podamo funkciji `decorator` in \"pravi\" `f` bo tisto, kar vrne `decorator`. Kot v gornjih primerih.\n",
    "\n",
    "## Dekorator, ki šteje klice funkcije\n",
    "\n",
    "Napišimo dekorator, ki bo štel, kolikokrat je funkcija poklicana.\n",
    "\n",
    "Najprej moramo izvedeti tole: Pythonove funkcije so objekti in imajo lahko tudi atribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    return 2 * x\n",
    "\n",
    "f.foo = 42\n",
    "\n",
    "print(f.foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcija bi lahko štela, kolikokrat smo jo poklicali."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    f.called += 1\n",
    "    return 2 * x\n",
    "\n",
    "f.called = 0\n",
    "\n",
    "for x in range(5):\n",
    "    f(x)\n",
    "    \n",
    "print(f.called)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vendar zdaj poznamo zabavnejši način: znamo napisati dekorator. Ta bo ovil funkcijo v funkcijo, ki šteje, kolikokrat je poklicana. Sicer pa bo le poklical in vrnil ovito funkcijo, ne da bi se vtikal v argumente ali rezultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "def count_calls(f):\n",
    "    def wrapper(*args):\n",
    "        y = f(*args)\n",
    "        wrapper.called += 1\n",
    "        return y\n",
    "    \n",
    "    wrapper.called = 0\n",
    "    return wrapper\n",
    "\n",
    "@count_calls\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "for x in range(5):\n",
    "    add(x, x ** 2)\n",
    "    \n",
    "print(add.called)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še bolj imenitne stvari lahko počnemo: lahko naredimo cel log klicev! Seznam parov (argumenti, rezultat) za vse klice funkcije!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[((0, 0), 0), ((1, 1), 2), ((2, 4), 6), ((3, 9), 12), ((4, 16), 20)]\n"
     ]
    }
   ],
   "source": [
    "def logged(f):\n",
    "    def wrapper(*args):\n",
    "        y = f(*args)\n",
    "        wrapper.log.append((args, y))\n",
    "        return f(*args)\n",
    "    \n",
    "    wrapper.log = []\n",
    "    return wrapper\n",
    "\n",
    "@logged\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "for x in range(5):\n",
    "    add(x, x ** 2)\n",
    "    \n",
    "print(add.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkcije s spominom\n",
    "\n",
    "Čas je, da naredimo kaj uporabnega.\n",
    "\n",
    "Tule imamo funkcijo, ki računa Fibonaccijeva števila. Napisana je rekurzivno; z njo lahko izračunamo prvih nekaj Fibonaccijevih števil, potem pa postane prepočasna. Ker znamo logirati klice, lahko ugotovimo tudi, zakaj."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((3,), 3), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((3,), 3), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((4,), 5), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((3,), 3), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((5,), 8), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((3,), 3), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((3,), 3), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((4,), 5), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1), ((3,), 3), ((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((0,), 1), ((1,), 1)]\n"
     ]
    }
   ],
   "source": [
    "@logged\n",
    "def fibo(n):\n",
    "    if n < 2:\n",
    "        return 1\n",
    "    return fibo(n - 2) + fibo(n - 1)\n",
    "\n",
    "fibo(5)\n",
    "\n",
    "print(fibo.log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(fibo.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da izračuna peto Fibonaccijevo število, funkcija 101-krat pokliče samo sebe. Za šesto se pokliče že 277-krat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "277"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibo.log = []\n",
    "fibo(6)\n",
    "len(fibo.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Problem je v tem, da za izračun petega potrebuje tretje in četrto. Za izračuna četrtega potrebuje drugo in tretje -- torej bo dvakrat računalo tretje Fibonaccijevo število. Za izračun tretjega potrebuje drugo in prvo (vsakega po dvakrat - poleg tega pa bo računala še enkrat, namreč takrat, ko bo računala tretjega) ... Skratka, teh klicev je več in več.\n",
    "\n",
    "Fibonaccijeva števila je seveda možno računati učinkoviteje, namreč naprej in ne nazaj. A to ni bistvo. Bistvo je, da imamo počasno funkcijo, ki bi se jo dalo pospešiti tako, da stvari, ki jih je že enkrat izračunala, ne bi računala ponovno. Recimo tako, da bi imela slovar, katerega ključi bi bili pretekli argumenti, vrednosti pa rezultat pri teh argumentih. Ob vsakem klicu bi preverila, če je bila s temi argumenti že klicana. Če, potem le vrne že izračunani rezultat. Če ne, računa in shrani."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((3,), 3), ((2,), 2), ((3,), 3), ((4,), 5), ((5,), 8)]\n"
     ]
    }
   ],
   "source": [
    "cache = {}\n",
    "\n",
    "@logged\n",
    "def fibo(n):\n",
    "    # Če rezultat za te argumente še ni v slovarju, ga izračuamo in dodamo v slovar\n",
    "    if n not in cache:\n",
    "        if n < 2:\n",
    "            cache[n] = 1\n",
    "        else:\n",
    "            cache[n] = fibo(n - 2) + fibo(n - 1)\n",
    "            \n",
    "    return cache[n]\n",
    "\n",
    "fibo(5)\n",
    "\n",
    "print(fibo.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tole je seveda samo za demo. Uporablja globalne spremenljivke in to se ne dela.\n",
    "\n",
    "Vendar ni problema. To bomo itak posplošili: naredili bomo dekorator, ki ovije funkcijo v funkcijo, ki shranjuje rezultate ovite funkcije. In ovito funkcijo kliče le, če in kadar je to potrebno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((3,), 3), ((2,), 2), ((3,), 3), ((4,), 5), ((5,), 8)]\n"
     ]
    }
   ],
   "source": [
    "def cached(f):\n",
    "    cache = {}\n",
    "    def wrapped(x):\n",
    "        if not x in cache:\n",
    "            cache[x] = f(x)\n",
    "        return cache[x]\n",
    "    \n",
    "    return wrapped\n",
    "\n",
    "@logged\n",
    "@cached\n",
    "def fibo(n):\n",
    "    if n < 2:\n",
    "        return 1\n",
    "    return fibo(n - 2) + fibo(n - 1)\n",
    "\n",
    "fibo(5)\n",
    "print(fibo.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To je potrebno le še posplošiti tako, da deluje s funkcijami s poljubnim številom argumentov. A ne bomo. Vemo, samo `wrapped(x)` zamenjamo z `wrapped(*x)` in `f(x)` z `f(*x)`. A vseeno ne bomo. Zato ker so takšen dekorator že naredili namesto nas. Imenuje se `lru_cache` in je v modulu `functools`. Dekorator sprejme tudi argument: povedati mu je potrebno, koliko zadnjih klicev naj si zapomni."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[((1,), 1), ((0,), 1), ((1,), 1), ((2,), 2), ((3,), 3), ((2,), 2), ((3,), 3), ((4,), 5), ((5,), 8)]\n"
     ]
    }
   ],
   "source": [
    "from functools import lru_cache\n",
    "\n",
    "@logged\n",
    "@lru_cache(10)\n",
    "def fibo(n):\n",
    "    if n < 2:\n",
    "        return 1\n",
    "    return fibo(n - 2) + fibo(n - 1)\n",
    "\n",
    "fibo(5)\n",
    "print(fibo.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kako napisati dekorator, ki sprejema tudi argumente? Poleg funkcije?\n",
    "\n",
    "No, `lru_cache` v resnici ni dekorator, temveč funkcija, ki vrne dekorator. Če je dekorator funkcija, ki vrača funkcijo, je `lru_cache` parametriziran dekorator, torej funkcija, ki vrača funkcijo, ki vrača funkcijo. Ni tako komplicirano, vendar smo danes že dovolj zvijali možgane.\n",
    "\n",
    "## Dekoratorji, ki prčkajo po argumentih\n",
    "\n",
    "Napisali smo par dekoratorjev, ki se ukvarjajo z rezultati funkcije, še nobenega pa v zvezi z argumenti. Storimo še to.\n",
    "\n",
    "Recimo, da bi nek modrijan prišel na modro idejo, da bi bilo fino, če bi funkcije, ki sicer sprejemajo samo `float`-e, sprejele tudi nize - seveda takšne nize, ki se lahko pretvorijo v števila."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def to_float(f):\n",
    "    def wrapped_f(*args):\n",
    "        new_args = []\n",
    "        for arg in args:\n",
    "            new_args.append(float(arg))\n",
    "        return f(*new_args)\n",
    "    return wrapped_f\n",
    "\n",
    "sqrt = to_float(sqrt)\n",
    "\n",
    "sqrt(\"25\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tule smo \"popravili\" že vdelano funkcijo `sqrt`. Vsak dekorator je možno uporabiti tudi na ta način. Običajno pa jih uporabljamo za dekoriranje lastnih funkcij, torej tudi tu poskusimo še to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.283185307179586"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@to_float\n",
    "def circumf(r):\n",
    "    return 2 * pi * r\n",
    "\n",
    "circumf(\"1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## \"Overloadanje\" funkcij\n",
    "\n",
    "V nekaterih jezikih je mogoče napisati več različic funkcije z istim imenom, vendar različnimi tipi (ali številom) argumentov. Ob klicu funkcije se prevajalnik na osnovi argumentov odloči, katero funkcijo bo poklical.\n",
    "\n",
    "V Pythonu to ne gre, saj v definiciji funkcije ne deklariramo tipov argumentov. No, lahko, vendar jih Python ignorira in jih, kot prisegajo avtorji, tudi vedno bo.\n",
    "\n",
    "Vseeno pa obstaja dekorator, s katerim lahko dosežemo nekaj takšnega: `singledispatch`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function singledispatch in module functools:\n",
      "\n",
      "singledispatch(func)\n",
      "    Single-dispatch generic function decorator.\n",
      "    \n",
      "    Transforms a function into a generic function, which can have different\n",
      "    behaviours depending upon the type of its first argument. The decorated\n",
      "    function acts as the default implementation, and additional\n",
      "    implementations can be registered using the register() attribute of the\n",
      "    generic function.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from functools import singledispatch\n",
    "\n",
    "help(singledispatch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uporabljamo jo tako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import singledispatch\n",
    "\n",
    "@singledispatch\n",
    "def add(x, y):\n",
    "    return x, y\n",
    "\n",
    "@add.register(str)\n",
    "def _(x, y):\n",
    "    return x + \" \" + y\n",
    "\n",
    "@add.register(list)\n",
    "def _(x, y):\n",
    "    r = []\n",
    "    for e, f in zip(x, y):\n",
    "        r.append(e + f)\n",
    "    return r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Osnovna različica preprosto sešteva."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 6)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če kot argument podamo niz, bo mednju vtaknila presledek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana Berta'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(\"Ana\", \"Berta\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če podamo seznama, pa ju bo seštela po elementih."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 12]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add([1, 5, 4], [2, -3, 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kako uporabimo `singledispatch`, vidimo v gornjem primeru. Osnovno različico dekoriramo s `singledispatch`, nadaljnje pa z `<ime-osnovne-funkcije>.register`. Ime nadaljnjih *ne sme biti* enako osnovni, temveč mora biti kaj neumnega, po možnosti `_`.\n",
    "\n",
    "Osebno mislim, da je to, da nadaljnje funkcije ne morejo imeti normalnih imen, grdo. In mi smo tu zato, da naredimo boljše.\n",
    "\n",
    "## Domač dekorator za overload\n",
    "\n",
    "Tole, kar sledi, je *way beyond*, ne, to je *way way way beyond* prvi letnik. Take stvari delajo na enem težjih predmetov magistrskega študija. Kdor prebere in razume, naj bo kar ponosen nase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def overloadable(base_func):\n",
    "    overloads = {}\n",
    "\n",
    "    def func(*args):\n",
    "        tpe = type(args[0])\n",
    "        return overloads.get(tpe, base_func)(*args)\n",
    "\n",
    "    def overload(tpe):\n",
    "        def overloaded(over_f):\n",
    "            overloads[tpe] = over_f\n",
    "            return func\n",
    "        return overloaded\n",
    "\n",
    "    func.overload = overload\n",
    "    return func"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Najprej se prepričajmo, da deluje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "@overloadable\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "@add.overload(str)\n",
    "def add(x, y):\n",
    "    return x + \" \" + y\n",
    "\n",
    "@add.overload(list)\n",
    "def add(x, y):\n",
    "    r = []\n",
    "    for e, f in zip(x, y):\n",
    "        r.append(e + f)\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana Berta'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(\"Ana\", \"Berta\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 2, 5]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add([5, 4, 2], [1, -2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj pa še, zakaj deluje.\n",
    "\n",
    "```python\n",
    "def overloadable(base_func):\n",
    "    overloads = {}\n",
    "\n",
    "    def func(*args):\n",
    "        tpe = type(args[0])\n",
    "        return overloads.get(tpe, base_func)(*args)\n",
    "\n",
    "    def overload(tpe):\n",
    "        def overloaded(over_f):\n",
    "            overloads[tpe] = over_f\n",
    "            return func\n",
    "        return overloaded\n",
    "\n",
    "    func.overload = overload\n",
    "    return func\n",
    "```\n",
    "\n",
    "Slovar `overloads` bo vseboval vse različice funkcije (razen osnovne). Ključi slovarja bodo tipi, pripadajoče vrednosti pa funkcije, ki jih je potrebno poklicati za posamezen tip.\n",
    "\n",
    "Naš dekorator `overloadable` bo zamenjal podano funkcijo (osnovno, tisto, ki jo bomo kasneje \"overloadali\") s funkcijo `func`. Funkcija `func` pogleda tip prvega argumenta (da, gledamo le prvi argument, a tudi `singledispatch` počne isto!). V slovarju poišče pripadajočo funkcijo, vendar ne uporablja običajnega indeksiranja (`overloads[tpe]`) temveč `get`, ki mu poda privzeto vrednost. Privzeta vrednost pa je kar `base_func`. To funkcijo potem pokliče s podanimi argumenti.\n",
    "\n",
    "Poleg tega pa v dekoratorju definiramo funkcijo `overload`, ki jo pripnemo funkciji, ki jo bomo vrnili. Ta skrbi za to, da bomo lahko kasneje izvedli\n",
    "\n",
    "```python\n",
    "@add.overload(str)\n",
    "def add(x, y):\n",
    "    return x + \" \" + y\n",
    "```\n",
    "\n",
    "Funkcijo `overload` bomo pripeli kot atribut k funkciji `func`, ki jo vračamo. Ta, ki uporablja naš dekorator, bo funkcijo `overload` torej videl pod imenom `add.overload`. Ta funkcija, `add.overload` kot argument prejme tip, v gornjem primeru `str`. Kaj pa vrne? Dekorator! Imamo namreč `@add.overload(str)`, torej pričakujemo, da bo rezultat klica  `add.overload(str)` dekorator. Funkcija `overloaded` (v gornji kodi) je torej dekorator, ki prejme novo različico funkcije (argument `over_f`). V slovar `overloads` pod ključ `tpe` zabeleži tole funkcijo. Vrne pa dekorirano osnovno funkcijo, `func`!\n",
    "\n",
    "To, slednje, je tisto, po čemer se Pythonov `singledispatch` razlikuje od našega (poleg tega, da Pythonov omogoča tudi uporabo za registriranje že napisanih funkcij, ne le dekoriranja, in da je nekoliko hitrejši). Pythonov [register](https://github.com/python/cpython/blob/master/Lib/functools.py#L840) namreč vrne `func`, ki pa se nanaša na novo funkcijo, ne staro."
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}