p1/dodatna predavanja/07 generatorji.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generatorji\n",
    "\n",
    "V oglate oklepaje zapiramo (izpeljane ali naštevne) sezname, v zavite zapiramo množice in slovarje. V okrogle pa ... terke? Lahko naredimo \"izpeljano terko\"? Ne, tega ne bi potrebovali velikokrat. Pač pa nas čaka - in bo pogosto v okroglih oklepajih - še nekaj bolj nenavadnega in imenitnejšega: generatorji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = (x ** 2 for x in range(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tale `g`, kot se hitro prepričamo, ni terka, temveč nekaj drugega."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x1067263b0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj je generator, čemu služi in kako ga uporabljamo? Na prvi dve\n",
    "vprašanji lahko odgovorimo naenkrat: generator je nekaj, kar generira\n",
    "objekte. Vsakič, ko bomo od njega zahtevali nov objekt, bo vrnil novo\n",
    "število - najprej 0, potem 1, potem 4, potem 9. pač kvadrate naravnih števil od 0 do (vključno) 3. \n",
    "\n",
    "Kako pa \"zahtevamo\" nov objekt. Tega ne počnemo s funkcijo `next`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/f9/lgq5ysmn24j3lkss6zkgmtr00000gn/T/ipykernel_96026/4253931490.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na koncu, ko smo zahtevali že peti objekt - `g` pa je zmožen generirati le štiri, se je pač pritožil, javil napako.\n",
    "\n",
    "Sem se zgoraj zatipkal, ko sem napisal, da generatorjev ne uporabljamo s funkcijo `next`, potem pa točno to počel? Ne, nisem se zatipkal. V resnici ne bomo. Funkcijo `next` sem jo pokazal samo zato, da bi razumeli, kaj počnejo generatorji. V praksi pa klicanje `next`-a prepustimo `for`-u."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "g = (x ** 2 for x in range(4))\n",
    "\n",
    "for i in g:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če to poskusimo ponoviti, ne gre: generator je že \"iztrošen\". Kar je imel\n",
    "zgenerirati, je zgeneriral."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in g:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lahko zavrtimo generator nazaj? Obstaja `prev`? Ali `rewind`, `restart`. Ne, to bi bila prehuda zahteva, kot bomo videli v nadaljevanju, ko bomo spoznavali, kako so narejeni in česa vsega so v resnici zmožni. Pa tudi uporabno in smiselno ne bi bilo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generatorji kot argumenti\n",
    "\n",
    "Generator je torej videti kot izpeljani seznam, le da namesto oglatih\n",
    "oklepajev uporabimo okrogle. Kadar ga pošljemo kot edini argument\n",
    "funkciji, smemo oklepaje celo izpustiti. Napišimo funkcijo, ki kot\n",
    "argument dobi seznam števil in vrne prvo število, ki je večje od 50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nad50(s):\n",
    "    for e in s:\n",
    "        if e > 50:\n",
    "            return e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preskusimo jo, trikrat:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "82"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nad50([5, 1, 40, 1, 82, 12, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nad50([x ** 2 for x in range(10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dodatni presledki so neumni in so tu samo zaradi pregledanosti primera\n",
    "nad50(    (x ** 2 for x in range(10))    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V prvem primeru je dobila najobičajnejši seznam. Tako smo si\n",
    "predstavljali, ko smo jo pisali. V drugem primeru smo ji dali seznam\n",
    "kvadratov števil do 10 in vrnila je prvi kvadrat, ki je večji od 50. V\n",
    "tretjem klicu pa ji sploh nismo dali seznama, temveč generator, ki je\n",
    "dajal kvadrate - natančno isto reč kot gornji `g`. Funkcija je čez\n",
    "generator pognala zanko `for` natančno tako, kot jo sicer poganja čez\n",
    "sezname.\n",
    "\n",
    "V čem je prednost generatorjev pred seznami? V tem, da ne sestavijo\n",
    "seznama. Če želimo izračunati vsoto kvadratov prvih stotih števil in za\n",
    "to uporabimo generator, na ta način ne sestavimo seznama teh števil (kot\n",
    "bi ga, če bi rekli `sum([x**2 for x in range(100)])`, temveč števila,\n",
    "namreč kvadrate, generiramo sproti (tako, da pokličemo\n",
    "`sum((x**2 for x in range(100)))`. Hm, pa to v resnici deluje? No,\n",
    "seveda. Funkcija `sum` bi lahko bila napisana takole"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum(s):\n",
    "    vsota = 0\n",
    "    for e in s:\n",
    "        vsota += e\n",
    "    return vsota"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zanka for lahko gre prek generatorja, torej ona reč deluje.\n",
    "\n",
    "Že, že, poreče pozornejši študent: kaj pa `range(100)`? Mar ta ne\n",
    "sestavi seznama stotih števil? Smo res kaj dosti pridobili - namesto\n",
    "seznama kvadratov števil do 100 imamo pač števila do 100 - je to res tak\n",
    "napredek? Tu lahko študenta pohvalimo za budnost, vendar se moti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 100)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V resnici `range` ne sestavi seznama, temveč generator. Ampak temu se bomo posvetili malo kasneje, ko bomo o generatorjih vedeli še malo več.\n",
    "\n",
    "Tu si raje oglejmo še en lušten detalj. Spomnimo se, da okrog elementov terke ni potrebno pisati oklepajev; to smo uporabili, recimo, pri vračanju rezultatov z `return x, y` ali pri menjavi vrednosti spremenljivk `a, b = b, a`. Podobno tudi okrog generatorjev ni potrebno pisati oklepajev, kadar so edini argument funkcije.\n",
    "Zadnji klic funkcije `nad_50`, ko smo podali generator, je imel precej oklepajev - da bi se znašli med njimi, smo dodali celo nepotrebne presledke.\n",
    "\n",
    "```python\n",
    "nad50(   (x ** 2 for x in range(10))   )\n",
    "```\n",
    "\n",
    "Ker je tale generator edini argument funkcije, smemo oklepaje izpustiti in pisati kar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nad50(x ** 2 for x in range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vsoto kvadratov števil od 0 do 9 lahko izračunamo tako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "285"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(x ** 2 for x in range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tako bodemo počeli poslej.\n",
    "\n",
    "\n",
    "### Funkcije, ki generirajo\n",
    "\n",
    "Še nekoliko naprednejša snov: Bi znali napisati generator Fibonaccijevih\n",
    "števil, tako kot smo napisali generator kvadratov? Da, vendar bo\n",
    "preprostejša nekoliko drugačna pot. Napisali bomo funkcijo, ki ne vrača\n",
    "le enega rezultata temveč \"generira\" rezultate. Torej, nekaj takšnega:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    # Tole ne deluje!\n",
    "    a = b = 1\n",
    "    for i in range(n):\n",
    "        return a\n",
    "        a, b = b, a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tale funkcija ne deluje, napisali smo jo le, da ilustriramo idejo: radi\n",
    "bi naredili zanko. Ko funkcijo prvič pokličemo, bi `return` vrnil prvo\n",
    "Fibonaccijevo število. Ko jo pokličemo naslednjič, se funkcija ne bi\n",
    "izvajala od začetka, temveč od tam, kjer smo nazadnje vrnili rezultat,\n",
    "se pravi z vrstico, ki sledi `return`u. No, v resnici naredimo natanko\n",
    "tako, le namesto `return`a moramo uporabiti `yield`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    a = b = 1\n",
    "    for i in range(n):\n",
    "        yield a\n",
    "        a, b = b, a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preskusimo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object fibonacci at 0x1068bf840>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = fibonacci(10)\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rezultat je torej - generator! Generatorje lahko napišemo v takšni obliki, kot smo jih spoznali sprva, lahko pa v obliki \"funkcije\". Mehanika je v resnici takšna, da klic te funkcije vrne generator - kot smo poklicali `fibonacci(10)`, smo kot rezultat dobili generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kako to deluje, bomo najlažje videli, če v funkcijo nasujemo nekaj `print`-ov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    print(\"Spet bo treba računati\")\n",
    "    a = b = 1\n",
    "    for i in range(n):\n",
    "        print(\"Zdaj bom vrnil člen\", a)\n",
    "        yield a\n",
    "        print(\"In potem bomo nadaljevali\")\n",
    "        a, b = b, a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pokličimo funkcijo, shranimo generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = fibonacci(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se je kaj izpisalo? Nič!!! \"Funkcija\" se sploh še ni začela izvajati! Funkcija steče vsakič, ko pokličemo `next` in \"zamrzne\" ob `yield`-u."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spet bo treba računati\n",
      "Zdaj bom vrnil člen 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poglejte `print`-e in izpis, pa boste točno videli, kaj se je izvedlo.\n",
    "\n",
    "In potem glejte, kako teče funkcija naprej vsakič, ko pokličemo `next`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In potem bomo nadaljevali\n",
      "Zdaj bom vrnil člen 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In potem bomo nadaljevali\n",
      "Zdaj bom vrnil člen 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In potem bomo nadaljevali\n",
      "Zdaj bom vrnil člen 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcija vsakič nadaljuje od tam, kjer se je prejšnjič ustavila, se pravi od `yield`-a.\n",
    "\n",
    "Seveda tudi tega generatorja ne bomo klicali z `next`, temveč s `for`.\n",
    "\n",
    "```python\n",
    "for x in fibonacci(10):\n",
    "    print(x)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Napišemo lahko celo funkcijo, ki vrne (no, generira) **vsa** Fibonaccijeva števila."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci():\n",
    "    a = b = 1\n",
    "    while True:\n",
    "        yield a\n",
    "        a, b = b, a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neskončno zanko, `while True`, smo že videli, vendar je bil v njej vedno\n",
    "`break`, ki jo je nekoč prekinil. Kdo pa prekine to zanko? Če nismo\n",
    "previdni, nihče.\n",
    "\n",
    "```python\n",
    "for i in fibonacci():\n",
    "    print(i)\n",
    "```\n",
    "\n",
    "se vidimo onstran večnosti. Pač pa lahko poiščemo, recimo, prvo\n",
    "Fibonaccijevo število, ki je večje od 50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "for i in fibonacci():\n",
    "    if i > 50:\n",
    "        print(i)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ah, saj imamo že funkcijo za to reč, `nad50`. Naj kar ta pove,\n",
    "katero je prvo Fibonaccijevo število večje od 50!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nad50(fibonacci())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Primer: Generator deliteljev\n",
    "\n",
    "Še en zanimiv primer je generator, ki vrne vse delitelje podanega\n",
    "števila."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 6, 7, 14, 21, 42]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def delitelji(n):\n",
    "    for i in range(1, n + 1):\n",
    "        if n % i == 0:\n",
    "            yield i\n",
    "            \n",
    "list(delitelji(42))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Opazimo lahko, da z enim deliteljem dobimo dva: če je `i` delitelj\n",
    "`n`-ja, je tudi `n // i` delitelj `n`-ja. Če je tako, zadošča, da gremo\n",
    "do korena iz `n` in vrnemo po dva delitelja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 24, 2, 12, 3, 8, 4, 6]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def delitelji(n):\n",
    "    for i in range(1, int(sqrt(n) + 1)):\n",
    "        if n % i == 0:\n",
    "            yield i\n",
    "            yield n // i\n",
    "            \n",
    "list(delitelji(24))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Koren iz `n` moramo spremeniti v celo število, ker `range` ne mara\n",
    "necelih.\n",
    "\n",
    "Pazite, tole sta dva `yield`a. Funkcija se izvaja tako, da vrne najprej\n",
    "eno število, in ko zahtevamo naslednje, se izvede naslednji `yield`.\n",
    "\n",
    "Funkcija je zdaj bistveno hitrejša (pri velikih številih bi se to\n",
    "utegnilo kar poznati - namesto, da gre do milijona, bo šla le do 1000.\n",
    "Vendar žal ne dela pravilno. Če je `n`, recimo, `25`, bo funkcija\n",
    "dvakrat vrnila 5. A tega se znamo hitro znebiti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delitelji(n):\n",
    "    for i in range(1, int(sqrt(n) + 1)):\n",
    "        if n % i == 0:\n",
    "            yield i\n",
    "            if i ** 2 != n:\n",
    "                yield n // i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj nas morda moti le še to, da števila ne prihajajo v pravem vrstnem\n",
    "redu. Kot delitelje 42 bi namesto 1, 2, 3, 6, 7, 14, 21, 42 dobili 1,\n",
    "42, 2, 21, 3, 14, 6, 7. To lahko popravimo tako, da `n // i` ne vračamo\n",
    "sproti, temveč jih le shranjujemo in jih vračamo kasneje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delitelji(n):\n",
    "    ostali = []\n",
    "    for i in range(1, int(sqrt(n) + 1)):\n",
    "        if n % i == 0:\n",
    "            yield i\n",
    "            if i ** 2 != n:\n",
    "                ostali.append(n // i)\n",
    "    for e in ostali:\n",
    "        yield e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nismo še čisto zmagali. Zdaj imamo 1, 2, 3, 6, 41, 21, 14, 7 - prva\n",
    "polovica je iz prvega `yield`a, druga (od 41 naprej) iz drugega. Te,\n",
    "druge, vrača v enakem vrstnem redu, v katerem jih je vstavljal v seznam,\n",
    "saj `append` pač vstavlja na konec.\n",
    "\n",
    "Pa vstavljajmo raje na začetek! Uporabimo `insert`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delitelji(n):\n",
    "    ostali = []\n",
    "    for i in range(1, int(sqrt(n) + 1)):\n",
    "        if n % i == 0:\n",
    "            yield i\n",
    "            if i ** 2 != n:\n",
    "                ostali.insert(0, n // i)\n",
    "    for e in ostali:\n",
    "        yield e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Žal se je `insert`u modro izogibati. Za to, da vstavi element na prvo\n",
    "mesto, mora enega za drugim premakniti vse ostale. V teoriji (ki se jo\n",
    "boste učili drugo leto) je ta program enako počasen kot bi bil, če bi\n",
    "prvo zanko spustili prek `range(1, n + 1)`. S tem, ko smo zamenjali\n",
    "`append` z `insert`, smo, vsaj v teoriji, zapravili ves prihranek.\n",
    "\n",
    "To je preprosto urediti. Vstavljali bomo na konec, z `append`. Pač pa\n",
    "bomo seznam nato prehodili v obratnem vrstnem redu. To se da narediti z\n",
    "indeksiranjem (`for i in range(-1, -n - n, -1): yield ostali[i]`, vendar\n",
    "si bomo raje pomagali s priročno funkcijo `reversed`, ki obrne seznam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delitelji(n):\n",
    "    ostali = []\n",
    "    for i in range(1, int(sqrt(n) + 1)):\n",
    "        if n % i == 0:\n",
    "            yield i\n",
    "            if i ** 2 != n:\n",
    "                ostali.append(n // i)\n",
    "    for e in reversed(ostali):\n",
    "        yield e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če nam je pomnilnika žal bolj kot časa, pa lahko naredimo drugače: gremo do korena in vračamo delitelji, nato pa od korena nazaj dol in vračamo njihove pare. Z drugimi besedami: to kar v gornjem programu shranjujemo, v spodnjem ponovno zgeneriramo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt, ceil\n",
    "\n",
    "def delitelji(n):\n",
    "    ostali = []\n",
    "    for i in range(1, int(ceil(sqrt(n)))):\n",
    "        if n % i == 0:\n",
    "            yield i\n",
    "    for i in range(int(sqrt(n)), 0, -1):\n",
    "        if n % i == 0:\n",
    "            yield n // i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prepričajmo se, da deluje tudi v zoprnih robnih primerih."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 6, 7, 14, 21, 42]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(delitelji(42))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 25]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(delitelji(25))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(delitelji(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(delitelji(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(delitelji(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(delitelji(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteratorji\n",
    "\n",
    "Generatorji so samo posebna zvrst iteratorjev. Kaj pa so iteratorji?\n",
    "\n",
    "Uvedimo jih tako, da najprej posplošimo nekaj, kar že poznamo.\n",
    "\n",
    "Ob slovarjih smo izvedeli, da kot ključ ne moremo uporabiti ravno poljubnega objekta, temveč le objekte, ki so nespremenljivi *immutable*. To je samo približno res. Uporabiti smemo objekte, ki so *hashable*. Objekti morajo imeti določeno (bolj interno) metodo `__hash__`, ki jo slovarji (in množice) potrebujejo zato, da se bodo odločili, kam shraniti določen ključ (oz. element). Če podatkovni tip to metodo ima, je *hashable*; če ne, ne in ne more služiti kot ključ slovarja (in biti elemnet množice). Metode `__hash__` nikoli ne kličemo neposredno, temveč pokličemo funkcijo `hash(obj)`, ki pokliče `obj.__hash__`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3551166701062947909"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hash(\"Berta\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3551166701062947909"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Berta\".__hash__()  # tega ne počnemo, temveč kličemo `hash`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Ta ovinek je pogost. Tudi funkcija `len(obj)` v resnici pokliče `obj.__len__` in vrne njen rezultat. Metode `__len__` nikoli ne kličemo neposredno. Kot tudi pišemo `s[i]` in ne `s.__getitem__(i)`. Ker nismo neumni.)\n",
    "\n",
    "Zdaj pa se vrnimo h generatorjem. Tudi gornja metoda `next` je samo ovinek: `next` pokliče metodo `__next__`. Podatkovni tipi, ki imajo metodo `__next__` so *iterable*. Konkretno, takim objektom rečemo *iteratorji*.\n",
    "\n",
    "*Generatorji so vrsta iteratorjev.* Niso pa generatorji edini iteratorji. V Pythonu je kup priložnostnih iteratorjev. Iterator dobimo s funkcijo `iter`, ki ji podamo objekt, prek katerega bi radi iterirali. Če imamo seznam `s` in pokličemo `iter(s)`, bomo dobili iterator prek tega seznama."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<list_iterator at 0x1068569e0>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = [\"Ana\", \"Berta\", \"Cilka\"]\n",
    "t = iter(s)\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Berta'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cilka'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcija `iter` je sicer enaka prevara kot `hash`, `len` ali `iter`: seznami imajo metodo `__iter__`. Funkcija `iter` torej le pokliče `__iter__` in ta vrne iterator, torej objekt, ki ima `__next__` in ta vrača zaporedne elemente seznama.\n",
    "\n",
    "Prav tako imajo metodo `__iter__` tudi niz (vrne iterator, ki vrača zaporedne znake niza), množica in terka (vračata zaporedne elemente) in slovar (vrača ključe v nekem kakršnemkoliže vrstnem redu)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<dict_keyiterator at 0x1068a6520>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\"Ana\": 12, \"Berta\": 20, \"Cilka\": 15}\n",
    "t = iter(d)\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Berta'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cilka'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kaj torej počne zanka for?\n",
    "\n",
    "**Z zanko `for` lahko gremo čez tiste in natančno tiste reči, ki so iterabilne - torej, ki imajo metodo *iter*.**\n",
    "\n",
    "Zanka `for` je zelo preprosta reč. Če imamo zanko\n",
    "\n",
    "```\n",
    "for spremenljivka in nekaj:\n",
    "```\n",
    "\n",
    "bo poklicala `g = iter(nekaj)`, potem pa izvajala `spremenljivka = next(g)`, dokler `next(g)` ne vrne napake `StopIteration`. Napako bo seveda skrila, saj v resnici ne gre za napako, temveč le za signal, da je delo opravljeno. Pokažimo kar primer. Vzemimo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = [\"Ana\", \"Berta\", \"Cilka\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Najprej ga prehodimo s `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana\n",
      "Berta\n",
      "Cilka\n"
     ]
    }
   ],
   "source": [
    "for x in s:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kar se v resnici dogaja zgoraj, je to: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana\n",
      "Berta\n",
      "Cilka\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/f9/lgq5ysmn24j3lkss6zkgmtr00000gn/T/ipykernel_96026/2251081137.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "g = iter(s)\n",
    "while True:\n",
    "    x = next(g)\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No, skoraj to. Naš `while` se konča z napako, `for` pa to napako prestreže. Tega še ne znamo, a pokažimo, saj bodo mnogi itak razumeli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana\n",
      "Berta\n",
      "Cilka\n"
     ]
    }
   ],
   "source": [
    "g = iter(s)\n",
    "while True:\n",
    "    try:\n",
    "        x = next(g)\n",
    "        print(x)\n",
    "    except StopIteration:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To je to. To v resnici dela zanka `for`.\n",
    "\n",
    "Na doslejšnjih predavanjih smo govorili stvari kot \"z zanko `for` lahko gremo prek seznamov\", \"zanka for zna iti tudi prek množic\" ... Figo. Zanka `for` ne zna ničesar. Vse delo opravijo iteratorji. Zanka `for` od objekta zahteva iterator in ga kliče.\n",
    "\n",
    "## Generatorji so tudi iteratorji; tudi iteratorji so iteratorji\n",
    "\n",
    "Naslov zveni malo bedasto. Gre le zato, da imajo iteratorji metodo `iter` in če jo pokličemo, iteratorji vrnejo kar samega sebe. Zato lahko `for`-u damo seznam ali generator, in `for` lahko v vsakem primeru pokliče `iter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<list_iterator at 0x106855450>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = iter([])\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<list_iterator at 0x106855450>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iter(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Številka v obliki `0x...nekaj`, pove, kje v pomnilniku se nahaja ta reč. Na ta način lahko prepoznamo, ali gre za isto stvar ali ne. Tu je številka enaka, torej `iter(t)` vrne kar sam `t`. Kot sem rekel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kaj so zip, range, enumerate in podobni?\n",
    "\n",
    "Nekoč smo imeli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\"]\n",
    "teze = [72, 65, 75, 68, 63]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in ko sem povedal za `zip(imena, teze)`, sem rekel, da se vede, kot da bi vrnil seznam parov imen in tež. Vendar nisem napisal\n",
    "\n",
    "```python\n",
    "zip(imena, teze)\n",
    "```\n",
    "\n",
    "temveč"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Ana', 72), ('Berta', 65), ('Cilka', 75), ('Dani', 68), ('Ema', 63)]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(imena, teze))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in rekel, da spreglejmo tisti `list`.\n",
    "\n",
    "`zip` je v resnici generator. Ko ga podamo `list`-u, le da z nekakšno zanko `for` pobere vse njegove elemente in jih zloži v novi seznam. Kasneje smo `zip` uporabljali le v zanki `for`, ki ji je vseeno, ali dobi seznam ali generator. Zato sem lahko govoril, da se `zip` vede, kot da bi vrnil seznam.\n",
    "\n",
    "Najprej preverimo, da je res, kar govorim."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x1068fc380>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = zip(imena, teze)\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Ana', 72)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Berta', 65)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Cilka', 75)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Res je generator. Ker po današnjem predavanju kar pokamo od pameti, pa napišimo svoj `zip`. Če torej `zip`-a še ne bi bilo, bi si ga sami sprogramirali približno tako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Ana', 72)\n",
      "('Berta', 65)\n"
     ]
    }
   ],
   "source": [
    "def my_zip(s, t):\n",
    "    for i in range(len(s)):\n",
    "        yield s[i], t[i]\n",
    "        \n",
    "t = my_zip(imena, teze)\n",
    "print(next(t))\n",
    "print(next(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana 72\n",
      "Berta 65\n",
      "Cilka 75\n",
      "Dani 68\n",
      "Ema 63\n"
     ]
    }
   ],
   "source": [
    "for ime, teza in my_zip(imena, teze):\n",
    "    print(ime, teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Takle `zip` bi delal samo, če mu podamo stvari, ki jih je možno indeksirati (recimo sezname), pri čemer mora biti za prvo stvar (`s`) možno poklicati `len`, poleg tega pa prva stvar ne sme biti daljša od druge. In, končno, tale `zip` sprejme samo dva argumenta, pravi `zip` pa jih poljubno. A za zdaj bodi. Boljše naredimo kasneje.\n",
    "\n",
    "Kaj pa `enumerate`. Isto, seveda. Tudi generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<enumerate at 0x1068ef040>"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = enumerate(imena)\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 'Ana')"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'Berta')"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tudi `enumerate` bi si znali narediti sami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_enumerate(s):\n",
    "    for i in range(len(s)):\n",
    "        yield i, s[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Ana\n",
      "1 Berta\n",
      "2 Cilka\n",
      "3 Dani\n",
      "4 Ema\n"
     ]
    }
   ],
   "source": [
    "for i, ime in my_enumerate(imena):\n",
    "    print(i, ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range`? Isto. Tule je preprostejša različica `range`-a, ki zahteva zgornjo in spodnjo mejo, korak pa je vedno `1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "def my_range(start, end):\n",
    "    i = start\n",
    "    while i < end:\n",
    "        yield i\n",
    "        i += 1\n",
    "\n",
    "for i in my_range(5, 8):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Od Pythona 3 naprej vse tovrstne funkcije vračajo iteratorje. Tudi metode slovarjev, `values`, `items` in, hm, `keys`, vrnejo iteratorje.\n",
    "\n",
    "Lepota iteratorjev je, da nikoli ne ustvarijo celotnih seznamov. To je hitrejše in prijaznejše do pomnilnika. Obenem uporaba iteratorjev vodi k malo drugačnemu pogledu na potek programa - predstavljamo si ga lahko kot tok podatkov. V Pythonu je to malo manj izrazito, ker ni ravno idealen jezik za tak način programiranja. A vendar se ga da prikazati tudi z njim.\n",
    "\n",
    "Najbolj frajerski so iteratorji, ki generirajo neskončna zaporedja. V `itertools` imamo iterator `count(n)`, ki šteje od `n` do neskončno. Če argument `n` izpustimo, bo štel od 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "from itertools import count\n",
    "\n",
    "for i in count(5):\n",
    "    if i == 10:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če ne bi imeli `enumerate`, bi namesto `enumerate(s)` pisali `zip(count(), s)`. Iterator `zip` bi šel pač hkrati prek iteratorja, ki ga vrne `count` in prek `s`.\n",
    "\n",
    "Tudi `count` ni vesoljska znanost, ta pa res ne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "def my_count(n=0):\n",
    "    while True:\n",
    "        yield n\n",
    "        n += 1\n",
    "        \n",
    "for i in my_count(5):\n",
    "    if i == 10:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`count()` izgleda relativno neuporaben. Ni. Sam ga imam zelo rad in ga pogosto uporabim. V določenih situacijah (katerih opis pa tule izpustimo) ga dejansko uporabljam namesto `enumerate`. Prav pa pride tudi vedno, kadar nekaj štejemo, iščemo ... in ne vemo, do kod bo potrebno šteti.\n",
    "\n",
    "Katero je prvo število, katerega kvadrat presega 1000?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "for i in count():\n",
    "    if i ** 2 > 1000:\n",
    "        break\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seveda lahko sestavimo tudi kvadrate vseh naravnih števil."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "kvadrati = (x ** 2 for x in count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In potem spustimo zanko čeznje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "for x in kvadrati:\n",
    "    if x > 1000:\n",
    "        break\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Katero pa je prvo popolno število? Se pravi, prvo število, ki je enako vsoti svojih deliteljev?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "for n in count(1):  # šteti začnemo pri 1, sicer bi dobili 0\n",
    "    if n == sum(x for x in range(1, n) if n % x == 0):\n",
    "        break\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še bolj imenitno: s `count` si lahko pripravimo generator vseh popolnih števil!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "popolna = (n for n in count(1) if n == sum(x for x in range(1, n) if n % x == 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(popolna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(popolna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "496"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(popolna)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8128"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(popolna)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`for n in count(1)` poskrbi, da bo šel `n` od 1 do neskončno, `if` pa izloča vsa nepopolna števila. Ko pokličemo `next`, bo zanka gnala `n` toliko časa, da bo `if` zadovoljen in generator bo \"izgeneriral\" `n`. Ko naslednjič pokličemo `next`, teče zanka naprej. In tako vsakič, ko zahtevamo naslednje število. Prva tri je našel hitro, na 8128 pa je bilo potrebno že malo počakati.\n",
    "\n",
    "Če razumete tale, zadnji generator, vam je jasno vse.\n",
    "\n",
    "## Resnični `zip`, `range`, `enumerate`\n",
    "\n",
    "Zgornje funkcije so bile malo poenostavljene. Resnične so sprogramirane v C-ju. Če bi jih hoteli narediti v Pythonu, pa tudi ne bi bile bistveno daljše od gornjih približkov, le malo bolj previdno se jih moramo lotiti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_zip(*args):\n",
    "    args = [iter(arg) for arg in args]\n",
    "    try:\n",
    "        while True:\n",
    "            yield tuple([next(arg) for arg in args])\n",
    "    except StopIteration:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcija dobi poljubno število argumentov, zato `*args`.\n",
    "\n",
    "V prvi vrstici takoj pokličemo `iter` za vsak argument in to zložimo kar nazaj v args. Tako zagotovimo, da imamo same iteratorjev, se pravi, da nam je vseeno, ali je nek argument (že) iterator ali pa (še) seznam ali kaj podobnega.\n",
    "\n",
    "Nato bomo v neskončnost ponavljali `tuple([next(arg) for arg in args])`. Z `[next(arg) for arg in args]` sestavimo seznam vsega, kar vračajo posamični iteratorji, in to pretvorimo v terko, ker `zip` pač vrača terke. (Zakaj ne kar `tuple(next(arg) for arg in args)`? Daljša zgodba. [PEP-479](https://www.python.org/dev/peps/pep-0479/).)\n",
    "\n",
    "`try`-`except` prestrežeta `StopIteration` in končata delo.\n",
    "\n",
    "Preverimo, da res deluje: pokličimo ga s tremi argumenti, pri čemer je en (neskončen) generator, ostala dva pa sta tudi različno dolga."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Ana 72\n",
      "1 Berta 65\n",
      "2 Cilka 75\n"
     ]
    }
   ],
   "source": [
    "for i, ime, teza in my_zip(count(), imena, teze[:-2]):\n",
    "    print(i, ime, teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj pa `range`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_range(start, end=None, step=1):\n",
    "    if end == None:\n",
    "        end = start\n",
    "        start = 0\n",
    "    while start < end if step > 0 else start > end:\n",
    "        yield start\n",
    "        start += step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(my_range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(my_range(5, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 9, 11, 13]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(my_range(5, 15, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 13, 11, 9, 7]"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(my_range(15, 5, -2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pravi `range` zna še marsikaj, ampak \"generatorski\" del smo podelali.\n",
    "\n",
    "`enumerate` je v primerjavi z njima res preprost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_enumerate(s, start=0):\n",
    "    s = iter(s)\n",
    "    try:\n",
    "        while True:\n",
    "            yield start, next(s)\n",
    "            start += 1\n",
    "    except StopIteration:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(5, 'Ana'), (6, 'Berta'), (7, 'Cilka'), (8, 'Dani'), (9, 'Ema')]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(my_enumerate(imena, start=5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Konec\n",
    "\n",
    "Enkrat se bo treba ustaviti. V zvezi z vsemi temi rečmi bi bilo mogoče povedati še zelo veliko. Tole\n",
    "je ena najbolj kul tem v Pythonu. Pravzaprav treba priznati, da to niti\n",
    "ni tema iz Pythona. V ozadju tega, kar počnemo tule, je poseben slog\n",
    "programiranja, [funkcijsko programiranje](https://en.wikipedia.org/wiki/Functional_programming).\n",
    "Python ga omogoča in med \"normalnimi\" jeziki je za takšen slog\n",
    "pravzaprav eden boljših. Obstajajo pa jeziki, ki so posebej narejeni za\n",
    "takšno programiranje. Če je bilo komu tole, kar smo počeli doslej, všeč\n",
    "naj si nujno ogleda kak [SML](https://en.wikipedia.org/wiki/Standard_ML)\n",
    "ali\n",
    "[Haskell](https://en.wikipedia.org/wiki/Haskell_(programming_language)),\n",
    "morda pa ga bo zabaval tudi\n",
    "[Racket](https://en.wikipedia.org/wiki/Racket_(programming_language))\n",
    "(dialekt Lispa).\n",
    "\n",
    "V Pythonu pa si bo ta, ki so mu bile te reči všeč, dobro ogledal module\n",
    "[functools](https://docs.python.org/3/library/functools.html),\n",
    "[iterools](https://docs.python.org/3/library/itertools.html) in\n",
    "[operator](https://docs.python.org/3/library/operator.html).\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}