p1/dodatna predavanja/04 prvorazredni objekti.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prvorazredni objekti\n",
    "====================\n",
    "\n",
    "V programu imamo različne objekte - številke, nize, sezname, terke… V\n",
    "programu ustvarjamo nove objekte. Objekti izginejo iz pomnilnika, ko jih\n",
    "nihče več ne potrebuje. Objekte lahko zlagamo v sezname in terke.\n",
    "Objekte lahko podajamo funkcijam kot argumente. Objekte lahko dobimo kot\n",
    "rezultat funkcije.\n",
    "\n",
    "Nekateri jeziki (Python je med njimi, klasični prevajani jeziki pa\n",
    "tipično ne) se odlikujejo po tem, da je tudi funkcija objekt.\n",
    "Prvorazredni objekt. To pomeni, da lahko s funkcijami počnemo vse, kar\n",
    "lahko počnemo z drugimi objekti. Lahko ustvarjamo nove funkcije; in\n",
    "funkcije lahko izginejo iz pomnilnika, ko jih nihče več ne potrebuje.\n",
    "Lahko jih zlagamo v seznem, podajamo kot argumente in dobimo kot\n",
    "rezultat.\n",
    "\n",
    "Objekti se seveda razlikujejo po svojih zmožnostih: nekatere lahko\n",
    "odštevamo in delimo, druge le seštevamo, tretjih niti to. Funkcij pač ne\n",
    "moremo sešteti. Lahko pa jih pokličemo. Prek seznamov pa lahko gremo z\n",
    "zanko `for`, česar ni mogoče početi ne s funkcijami ne s števili. A to\n",
    "je stvar definicije tipa. Bistvo pa je, da lahko z vsakim objektom,\n",
    "najsibo število, niz ali funkcija, počnemo stvari, našetete v prejšnjem\n",
    "odstavku.\n",
    "\n",
    "Kaj je definicija funkcije?\n",
    "---------------------------\n",
    "\n",
    "Ko Python vidi definicijo funkcije, priredi pripadajočo kodo (in še kaj\n",
    "zraven) imenu. Definicija funkcije, na primer,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return 2 * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "je le nekoliko drugače zapisano prirejanje. Lahko si predstavljamo, da\n",
    "je gornje ekvivalentno spodnjemu.\n",
    "\n",
    "    f = def(x):\n",
    "        return x\n",
    "        \n",
    "\n",
    "To sicer ni pravilna koda v Pythonu, v, recimo, Javascriptu pa v resnici\n",
    "lahko dejansko napišemo\n",
    "\n",
    "    > f = function(t) { return 2 * t }\n",
    "    > f(5)\n",
    "    10\n",
    "\n",
    "(ali pa kaj še krajšega, a nepoznavalcu Javascripta manj očitnega).\n",
    "\n",
    "### Za uvod in okus\n",
    "\n",
    "Imena funkcij so samo imena. Tako kot imena kateregakoli drugega\n",
    "objekta. Torej ni nič narobe (a tudi nič posebej prav), če rečemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "napiši = print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in potem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "napiši(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj se `napiši` nanaša na isti objekt kot `print`. Imenu `print` lahko celo priredimo drugo vrednost (ker je to seveda totalno smiselno)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "print = 42\n",
    "napiši(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ali celo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print = abs\n",
    "abs(-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V tej obliki je to čisto brez zveze, vendar nam bo morda pomagalo razumeti, kar sledi, v po-naslednjem razdelku.\n",
    "\n",
    "Zdaj pa samo popravimo `print`, da ne bo kasneje štale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "print = napiši"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda-funkcije\n",
    "\n",
    "Tudi v Pythonu lahko takole, na hitro definiramo funkcijo. Takšnim\n",
    "funkcijam navadno rečemo lambda-funkcije.\n",
    "\n",
    "Torej: `lambda x, y: x + y` je funkcija, ki prejme dva argumenta\n",
    "(poimenovali smo ju `x` in `y`) ter vrne njuno vsoto. Definicija lambda\n",
    "funkcije je sestavljena iz ključne besede `lambda`, ki ji sledi seznam\n",
    "argumentov, kot pri običajnih funkcijah (a brez oklepajev), nato\n",
    "dvopičje in nato izraz. Brez `return`-a. Samo izraz. In samo en izraz.\n",
    "\n",
    "Pythonove lambda-funkcije so omejene, zelo omejene. Če bi si človek česa\n",
    "želel v Pythonu, bi bile to boljše lambda-funkcije. Vendar jih ni in\n",
    "najbrž nikoli ne bo. Sintaktično se ne ujamejo z njim. Kdor hoče mogočne\n",
    "lambde (in ostati v mainstream jezikih), naj gre programirat v Kotlinu.\n",
    "\n",
    "Takšna lambda seveda ničemur ne služi. Če jo hočemo še kdaj videti in\n",
    "poklicati, ji moramo dati ime. Recimo tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sestej = lambda x, y: x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To se ne dela. Namesto tega bomo vedno pisali"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "def sestej(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambdo lahko pokličemo tudi kar takoj, ne da bi ji dali ime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x, y: x + y)(5, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tudi to se ne dela, ker je neumno. (Ne spreglejte pa oklepajev: samo\n",
    "funkcijo smo morali dati v oklepaj. Če bi napisali\n",
    "`lambda x, y: x + y(5, 1)`, bi bilo to videti, kot da kličemo funkcijo\n",
    "`y`. Točneje, to je definicija lambde, ki vrača `x + y(5, 1)`.\n",
    "\n",
    "Če se lambd ne uporablja ne tako ne drugače - kje pa se jih? “*Le z\n",
    "menoj, bralec!*”, je napisal Bulgakov.\n",
    "\n",
    "### Funkcija kot argument\n",
    "\n",
    "Pri Programiranju 1 stalno ponavljamo tole nalogo: iščemo element\n",
    "seznama, ki je največji po določenem kriteriju. Bodisi po velikosti, kot\n",
    "jo razume Python, bodisi po dolžini, po absolutni vrednosti, po številu\n",
    "a-jev, ki jih vsebuje (če gre za nize) … Vsakič napišemo novo funkcijo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def najdaljsi(s):\n",
    "    # Vrne najdaljši element s\n",
    "    naj_e = None\n",
    "    naj_dol = None\n",
    "    for e in s:\n",
    "        dol = len(e)\n",
    "        if naj_dol is None or dol > naj_dol:\n",
    "            naj_dol = dol\n",
    "            naj_e = e\n",
    "    return naj_e\n",
    "\n",
    "def najvecji_abs(s):\n",
    "    # Vrne element s z \n",
    "    naj_e = None\n",
    "    naj_abs = None\n",
    "    for e in s:\n",
    "        abse = abs(e)\n",
    "        if naj_abs is None or abse > naj_abs:\n",
    "            naj_abs = abse\n",
    "            naj_e = e\n",
    "    return naj_e\n",
    "\n",
    "def najvec_a_jev(s):\n",
    "    # Vrne element (niz) z največ a-ji\n",
    "    naj_e = None\n",
    "    naj_ajev = None\n",
    "    for e in s:\n",
    "        ajev = e.count(\"a\") + e.count(\"A\")\n",
    "        if naj_ajev is None or ajev > naj_ajev:\n",
    "            naj_ajev = ajev\n",
    "            naj_e = e\n",
    "    return naj_e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vse to je očitno eno in isto, razlikuje se le po tem, da enkrat\n",
    "pokličemo `len`, enkrat `abs`, enkrat pa seštevamo število malih in\n",
    "velikih a-jev.\n",
    "\n",
    "Splošna funkcija `najvecji` bi bila videti tako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def max(s, key):\n",
    "    max_e = None\n",
    "    max_key = None\n",
    "    for e in s:\n",
    "        k = key(e)\n",
    "        if max_key is None or k > max_key:\n",
    "            max_key = k\n",
    "            max_e = e\n",
    "    return max_e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vse je enako kot prej, le da namesto `len` ali `abs` kličemo `key`, pri\n",
    "čemer je `key` argument funkcije `max`.\n",
    "\n",
    "Zdaj lahko naredimo tako"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Berta'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Dani\"]\n",
    "max(imena, len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "kot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-42"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevila = [22, 5, -6, -42, 1]\n",
    "max(stevila, abs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V, recimo, prvem primeru, je znotraj funkcije `s` isto kot `imena` (en\n",
    "in isti seznam), `key` isto kot `len`. Ko pokličem `key(e)`, je to isto,\n",
    "kot če bi klicali `len(e)`, saj sta `key` in `len` ena in ista reč.\n",
    "\n",
    "Kaj pa tretji primer, v katerem ne kličemo funkcije, temveč računamo\n",
    "`e.count(\"a\") + e.count(\"A\")`? Tu moramo funkcijo narediti sami. Lahko\n",
    "bi pisali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def stevilo_ajev(s):\n",
    "    return s.count(\"a\") + s.count(\"A\")\n",
    "\n",
    "max(imena, stevilo_ajev)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "vendar je to nepraktično. Dolgo. Definirati celo funkcijo za tako\n",
    "preprosto reč. Tu je torej mesto, kjer uporabimo lambde."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(imena, lambda s: s.count(\"a\") + s.count(\"A\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python seveda natančno takšno funkcijo `max` že ima. Razlikuje se le po\n",
    "tem, da moramo argument s ključem nujno podati tako, da ga poimenujemo,\n",
    "na primer. Še en lep primer: v seznamu seznamov poišči seznam z največjo\n",
    "vsoto elementov:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 1]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tabela = [ [1, 2, 3], [1, 2],[10, 1]]\n",
    "max(tabela, key=sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podoben argument ima tudi funkcija `min`. Imata ga celo metoda `sort` in\n",
    "funkcija `sorted`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, -6, 22, -42]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(stevila, key=abs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2], [1, 2, 3], [10, 1]]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(tabela, key=sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tule smo uredili števila po njihovi absolutni vrednosti (kot “ključ” za urejanje smo uporabili funkcijo `abs`) in potem še po vsoti njihovih elementov.\n",
    "\n",
    "### Primer: seznami funkcij\n",
    "\n",
    "Napišimo funkcijo, ki tabelira podani seznam funkcij na vrednostih od 0\n",
    "do 1, s korakom 0.1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\t0.0\t0.0\t0.0\t\n",
      "0.1\t0.31622776601683794\t0.09983341664682815\t0.010000000000000002\t\n",
      "0.2\t0.4472135954999579\t0.19866933079506122\t0.04000000000000001\t\n",
      "0.3\t0.5477225575051661\t0.29552020666133955\t0.09\t\n",
      "0.4\t0.6324555320336759\t0.3894183423086505\t0.16000000000000003\t\n",
      "0.5\t0.7071067811865476\t0.479425538604203\t0.25\t\n",
      "0.6\t0.7745966692414834\t0.5646424733950354\t0.36\t\n",
      "0.7\t0.8366600265340756\t0.644217687237691\t0.48999999999999994\t\n",
      "0.8\t0.8944271909999159\t0.7173560908995228\t0.6400000000000001\t\n",
      "0.9\t0.9486832980505138\t0.7833269096274833\t0.81\t\n",
      "1.0\t1.0\t0.8414709848078965\t1.0\t\n"
     ]
    }
   ],
   "source": [
    "def tabeliraj(fs):\n",
    "    for x10 in range(11):\n",
    "        x = x10 / 10\n",
    "        print(x, end=\"\\t\")\n",
    "        for f in fs:\n",
    "            print(f(x), end=\"\\t\")\n",
    "        print()\n",
    "\n",
    "from math import *\n",
    "tabeliraj([sqrt, sin, lambda x: x**2])    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z argumentom `end=\"\\t\"` smo funkcijo `print` prosili, naj po vsakem\n",
    "izpisu ne gre v novo vrstico temveč le doda tabulator. To ni bistveno.\n",
    "Bistvena je notranja zanka: funkcija `tabeliraj` je kot argument dobila\n",
    "seznam funkcij, torej gremo v notranji zanki čez ta seznam in `f` je\n",
    "vsakič druga funkcija.\n",
    "\n",
    "Funkcija je seveda na moč neelegantna. O tem, kako to narediti lepše, se\n",
    "bomo še učili; za zdaj le pokažimo, da kdo ne bi imel po krivici slabega\n",
    "mnenja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tabeliraj(fs):\n",
    "    for x10 in range(11):\n",
    "        print(\"\\t\".join(map(str, [x] + [f(x) for x in fs])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S številom decimalk v izpisu pa se res ukvarjajmo kdaj drugič.\n",
    "\n",
    "## Ustvarjanje in vračanje funkcij\n",
    "\n",
    "Rekli smo, da definicija funkcije ustvari objekt-funkcijo in jo priredi\n",
    "imenu. Potemtakem smemo narediti tudi to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    def g(x):\n",
    "        return x ** 2\n",
    "\n",
    "    return g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So jeziki, v katerih ni mogoče pisati funkcij znotraj funkcij. So tudi\n",
    "jeziki, v katerih je to dovoljeno in takšnim funkcijam rečejo lokalne\n",
    "funkcije. In teh funkcij se ne da klicati iz zunanjega okolja. In te\n",
    "funkcije so ustvarjene le enkrat. So pa jeziki, v katerih to deluje\n",
    "boljše."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj bom dobil, če pokličem `f`? Kaj je `t`? Pač, funkcija, ne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj pa naredim še"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sta `t` in `u` ista funkcija? V mnogih jezikih bi - če kaj temu\n",
    "podobnega sploh dopuščajo - bili. V mnogih pa ne. Python je med\n",
    "slednjimi. Najboljši dokaz bo tak:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    def f(k):\n",
    "        def g(x):\n",
    "            return x ** k\n",
    "\n",
    "        return g\n",
    "\n",
    "    kvadriraj = f(2)\n",
    "    kubiraj = f(3)\n",
    "\n",
    "    kvadriraj(5)\n",
    "\n",
    "    kubiraj(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcija `f` vsakič ustvari novo funkcijo `g` in jo vrne. Ta funkcija\n",
    "ima dostop do okolja, v katerem je nastala. (Pravo ime za to je:\n",
    "*closure*.) Zato lahko uporablja `k`.\n",
    "\n",
    "Deluje celo to"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    def f(k):\n",
    "        k2 = k\n",
    "\n",
    "        def g(x):\n",
    "            return x ** k2\n",
    "\n",
    "        return g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In celo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    def f(k):\n",
    "        k2 = k\n",
    "\n",
    "        def g(x):\n",
    "            return x ** k2\n",
    "\n",
    "        return g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zgoraj smo definirali funkcijo `max`, ki prejme seznam in ključ, podobno\n",
    "kot v Python vdelana funkcija `max`. Recimo, da bi potrebovali funkcije\n",
    "`najdaljse_ime`, `najvecja_vsota` in `naj_absolutist`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    def najdaljse_ime(s):\n",
    "        return max(s, len)\n",
    "        \n",
    "    def najvecja_vsota(s):\n",
    "        return max(s, sum)\n",
    "        \n",
    "    def naj_absolutist(s):\n",
    "        return max(s, abs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tole se da narediti tudi preprosteje. (Ja, še preprosteje!) Napišemo\n",
    "lahko funkcijo za sestavljanje takšnih funkcij."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    def naj_funkcija(f):\n",
    "        def naj_f(s):\n",
    "            return naj(s, f)\n",
    "        return naj_f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preden razložimo, kaj dela to čudo, povejmo, kako se uporablja. Kar smo\n",
    "napisali, je funkcija za sestavljanje funkcij."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    najdaljse_ime = naj_funkcija(len)\n",
    "    najvecja_vsota = naj_funkcija(sum)\n",
    "    naj_absolutist = naj_funkcija(abs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S to `naj_funkcija` lahko sestavljamo nove funkcije, ki vračajo največji\n",
    "element glede na podani kriterij.\n",
    "\n",
    "Kaj naredi `naj_funkcija`? Definira funkcijo in jo vrne. Nova funkcija\n",
    "se imenuje `naj_f`, vendar je to samo lokalno ime znotraj funkcije\n",
    "`naj_funkcija`. Torej, še enkrat: `naj_funkcija` sestavi neko funkcijo\n",
    "in jo vrne. To funkcijo nato priredimo “spremenljivki” (“imenu” …\n",
    "kakorkoli že hočete reči temu) `najdaljse_ime`, `najvecja_vsota`,\n",
    "`naj_absolutist`… Te funkcije, `najdaljse_ime`, `najvecja_vsota`,\n",
    "`naj_absolutist` so torej funkcije, ki jih je sestavila in vrnila\n",
    "`naj_funkcija`.\n",
    "\n",
    "Kaj pa dela funkcija, ki jo sestavi `naj_funkcija`? Funkcija, ki jo bo\n",
    "vrnila `naj_funkcija`, sprejme en argument, seznam `s`, in vrne največji\n",
    "element tega seznama, pri čemer ne primerja elementov “direktno”, temveč\n",
    "glede na vrednost funkcije `f`. Katere funkcije `f`? Tiste, ki smo jo\n",
    "podali kot argument funkciji `naj_funkcija`.\n",
    "\n",
    "## Konec\n",
    "\n",
    "\n",
    "Kje pa, s tem smo šele začeli. Prihodnjič: dekoratorji!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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": 5
}