p1/predavanja/07 izpeljani seznami, slovarji, množice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9c1e086b",
   "metadata": {},
   "source": [
    "## Zakaj se učimo pisati \"onelinerje\"?! Ni to grdo?!\n",
    "\n",
    "Tokratna tema bo pustila - napačen! - vtis, da se učimo pisati funkcije v eni vrstici. A ta ekshibicionizem res sodi v Programiranje 1?! Ni to pravzaprav grdo?\n",
    "\n",
    "Ne sodi. In zna biti grdo.\n",
    "\n",
    "Nekateri študenti so za ta šport, izziv, res zagnani. \"A se da tudi za tole narediti oneliner?\" je kar pogosto vprašanje. Da. Vse se da. Ampak je navadno brez zveze. Potem, ko znaš, pogosto ni niti več izziv. Kot da bi se vprašal, ali se da iti peš v Pariz. Ja, samo ne vem, zakaj bi to počel.\n",
    "\n",
    "Zakaj se potem učimo \"pisati onelinerje\"? \n",
    "\n",
    "Saj se ne. Učimo se pisati generatorje, iteratorje, izpeljane sezname, množice in slovarje. Zakaj? To je kratko in jedrnato, povsem razumljivo in tudi hitrejše - če uporabljamo po pameti. Vsekakor torej nekaj, kar je koristno znati. Če v to silimo, kadar ni potrebe, pa bomo seveda napisali kodo, ki bo daljša, nerazumljiva in počasna.\n",
    "\n",
    "Kar bomo počeli danes, je torej še eno orodje, ki nam je na voljo, uporabljati pa ga je potrebno, kot vsa druga orodja, v pravem trenutku.\n",
    "\n",
    "Drugi namen tega je privajanje na drugačen način razmišljanja pri progrmairanju. Na programe - predvsem kodo, ki je sestavila kak seznam, slovar, množico - smo doslej gledali *postopkovno*. Opisali smo *korake* gradnje seznama, slovarja, množice -- vsak element posebej smo izračunali in ga *dodali* z `append`, `add` ali kakorkoli že. Današnji programi bodo *deklarativni*: namesto, da bi povedali, kako sestaviti seznam, bomo povedali zgolj, kaj naj vsebuje. Koda niti ne bo tako zelo različna, le malo obrnjena bo. Popolnoma drugačen pa bo moral biti način razmišljanja ob pisanju in branju.\n",
    "\n",
    "Poleg tega dveh razlogov pa je pisanje funkcij v eni vrstici seveda tudi zabaven šport - tudi, kadar je rezultat takšen, da ni primeren za produkcijsko kodo. :)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ad1af3e",
   "metadata": {},
   "source": [
    "## \"Deklarativni zapis\" \n",
    "\n",
    "Kar bomo počeli, pravzaprav že poznate. Pri matematiki množico včasih opišemo tako, da naštejemo njene elemente.\n",
    "\n",
    "$$S = \\{1, 2, 3\\}$$\n",
    "\n",
    "Včasih pa zgolj opišemo njihove lastnosti (z nekaj previdnosti, [da nas ne obrije Russell](https://en.wikipedia.org/wiki/Barber_paradox)). Takole bi opisali  množico dvakratnikov vseh\n",
    "naravnih števil, katerih kvadrat je manjši od 120, takole:\n",
    "\n",
    "$$S= \\{2 x; \\forall x \\in \\mathbb{N} \\wedge x^2<120\\}.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fb771ab",
   "metadata": {},
   "source": [
    "## Izpeljani seznami\n",
    "\n",
    "Začnimo s tistim, kar poznamo najdlje: s seznami. Doslej smo jih zapisali tako, da smo v oglatih oklepajih naštevali njihove elemente,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6cff908e",
   "metadata": {},
   "outputs": [],
   "source": [
    "k = [9, 16, 81, 25, 196]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4df2ccfe",
   "metadata": {},
   "source": [
    "Oglate oklepaje bomo uporabljali tudi poslej, le da znotraj njih ne bomo našteli elementov, temveč napisali izraz, ki jih sestavi. Recimo, da bi hotel seznam korenov števil iz gornjega seznama (po nekem čednem naključju gornji seznam vsebuje ravno same kvadrate). Naredil bi tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0f34c55a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "[sqrt(x) for x in k]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fafc53b1",
   "metadata": {},
   "source": [
    "Torej: napisal sem oglate oklepaje, kot vedno, kadar definiram seznam, a\n",
    "namesto, da bi naštel elemente, sem povedal, kakšni naj bodo. Rekel sem,\n",
    "naj bodo elementi mojega novega seznama *koren iz x*, pri čemer so `x`\n",
    "elementi seznama `k`. Kaj pa, če bi hotel namesto tega imeti kvadrate\n",
    "števil? Isti šmorn:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9a9edfa3",
   "metadata": {},
   "outputs": [],
   "source": [
    "[x ** 2 for x in k]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c99c89ab",
   "metadata": {},
   "source": [
    "Oblika tega, kar pišemo, je vedno `[izraz for spremenljivka in nekaj]`, kjer je *spremenljivka* ime neke spremenljivke (npr. `x`, *izraz* nek izraz, ki (običajno, ne pa čisto nujno) vsebuje to spremenljivko (npr. `sqrt(x)` ali `x ** 2`), *nekaj* pa je nekaj, čez kar je možno spustiti zanko `for`, torej seznam, slovar, množica ali kaj, česar še ne poznamo, vendar bomo spoznali še danes.\n",
    "\n",
    "Ko sestavljamo tak *izpeljan seznam*, moramo torej razmišljati:\n",
    "\n",
    "- kaj hočemo v tem seznamu? S kakšnim izrazom opišem (izračunem) element?\n",
    "- prek česa (katerega seznama, `range`-a...) moram iti, da bom dobil te elemente.\n",
    "\n",
    "Poglejmo še nekaj primerov.\n",
    "\n",
    "Imam seznam imen, recimo,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7be878c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9ec9f87",
   "metadata": {},
   "source": [
    "Kako bi izračunal poprečno dolžino imena? Imam funkcijo `sum`, ki zna\n",
    "sešteti števila v seznamu. Potrebujem torej le še seznam dolžin (namesto\n",
    "seznama imen). Pa poglejmo gornji \"točki\". Kaj želim v seznamu? Dolžine imen. Kako jih dobim? Očitno z nekim `len(ime)`, pri čemer je `ime` pač vsako ime iz seznama `imena`. V tem stavku smo odgovorili na obe vprašanji -- kaj bom računal (`len(ime)`) in čez kaj bom spustil zanko (čez `imena`). Torej vemo: potrebujemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "969ed7b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "[len(ime) for ime in imena]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7da120d0",
   "metadata": {},
   "source": [
    "Zdaj pa tole le še seštejem in delim z dolžino seznama."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "897e198b",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([len(ime) for ime in imena]) / len(imena)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f717c9a6",
   "metadata": {},
   "source": [
    "Poprečna dolžina imena ni nič posebej zanimivega. Računajmo raje\n",
    "poprečno težo in, da nam ne bo dolgčas, jo bomo računali iz teh\n",
    "troj `(teža, ime, je_ženska)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e76e29f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "podatki = [\n",
    "    (74, \"Anže\", False),\n",
    "    (82, \"Benjamin\", False),\n",
    "    (58, \"Cilka\", True),\n",
    "    (66, \"Dani\", False),\n",
    "    (61, \"Eva\", True),\n",
    "    (84, \"Franc\", False)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea46649",
   "metadata": {},
   "source": [
    "Takole nam je storiti: z zanko se zapeljemo čez podatke, izračunamo vsoto prvih elementov in jo delimo z dolžino seznama.\n",
    "\n",
    "Najprej poglejmo, kako bi to počeli po starem. Lepo prosim, ne tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3c97f2ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "vsota = 0\n",
    "for i in range(len(podatki)):\n",
    "    vsota += podatki[i][0]\n",
    "\n",
    "print(vsota / len(podatki))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94645438",
   "metadata": {},
   "source": [
    "Tole je že boljše:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5f5bc927",
   "metadata": {},
   "outputs": [],
   "source": [
    "vsota = 0\n",
    "for podatek in podatki:\n",
    "    vsota += podatek[0]\n",
    "    \n",
    "print(vsota / len(podatki))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cf8c5c6",
   "metadata": {},
   "source": [
    "Če hočete, da vas vaš profesor ohrani v trajnem lepem spominu, pa boste sprogrmirali tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "78fdf8c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "vsota = 0\n",
    "for teza, ime, zenska in podatki:\n",
    "    vsota += teza\n",
    "    \n",
    "print(vsota / len(podatki))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d308ad3b",
   "metadata": {},
   "source": [
    "Zdaj pa naredimo tako, kot smo se naučili danes. Naredimo lahko"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "028ff1ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "vsota = sum([podatek[0] for podatek in podatki])\n",
    "\n",
    "print(vsota / len(podatki))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85b14eb8",
   "metadata": {},
   "source": [
    "ali, po boljši, zadnji različici"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5b55f89e",
   "metadata": {},
   "outputs": [],
   "source": [
    "vsota = sum([teza for teza, ime, zenska in podatki])\n",
    "\n",
    "print(vsota / len(podatki))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "457c7e79",
   "metadata": {},
   "source": [
    "### Izpeljani seznami in pogoji\n",
    "\n",
    "Pri izpeljevanju seznamov lahko dodamo še pogoj, s katerim izbiramo elemente, ki naj se dodajo.\n",
    "\n",
    "Kako bi sestavili seznam kvadratov vseh lihih števil do 100? Seznam kvadratov vseh števil do 100 je trivialen, napisati nam je treba le:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "96594bbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "[x ** 2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5a45a9d",
   "metadata": {},
   "source": [
    "Če želimo pobrati samo liha števila, lahko v izpeljavo seznama dodamo še pogoj."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "669c5c79",
   "metadata": {},
   "outputs": [],
   "source": [
    "[x ** 2 for x in range(10) if x % 2 == 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dd7fe6b",
   "metadata": {},
   "source": [
    "Tole pravzaprav ni čisto potrebno, lahko bi rekli preprosto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c173cdb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = [x ** 2 for x in range(1, 10, 2)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "863b852a",
   "metadata": {},
   "source": [
    "Kaj pa, če bi hoteli seznam vseh števil do 30, ki niso deljiva s 7 in ne vsebujejo števke 7?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "892f813d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 8,\n",
       " 9,\n",
       " 10,\n",
       " 11,\n",
       " 12,\n",
       " 13,\n",
       " 15,\n",
       " 16,\n",
       " 18,\n",
       " 19,\n",
       " 20,\n",
       " 22,\n",
       " 23,\n",
       " 24,\n",
       " 25,\n",
       " 26,\n",
       " 29]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in range(30) if x % 7 != 0 and \"7\" not in str(x)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9964f078",
   "metadata": {},
   "source": [
    "Prvi del pogoja poskrbi, da število ni deljivo s 7 (ostanek po deljenju s 7 mora biti različen od 0). Drugi del poskrbi, da število ne vsebuje števke 7: število preprosto pretvorimo v niz in preverimo, da ne vsebuje sedmice.\n",
    "\n",
    "Kako bi izračunali vsoto tež moških v gornjem seznamu `podatki`? Za zanko dodamo pogoj. Za začetek sestavimo le seznam imen vseh moških."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "00d02597",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Anže', 'Benjamin', 'Dani', 'Franc']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[ime for teza, ime, zenska in podatki if not zenska]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55cad8b7",
   "metadata": {},
   "source": [
    "V definicijo našega seznama lepo na konec, za `for`, dodamo še `if` in\n",
    "pogoj, ki mu mora zadoščati element, da nas zanima.\n",
    "\n",
    "Na enak način naberemo tudi teže."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "165eaf98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[74, 82, 66, 84]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[teza for teza, ime, zenska in podatki if not zenska]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e09795e",
   "metadata": {},
   "source": [
    "Elemente tega seznama seštejemo s `sum`, pa smo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1016bbfb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "306"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([teza for teza, ime, zenska in podatki if not zenska])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aeab1e6d",
   "metadata": {},
   "source": [
    "Zdaj veste, zakaj sem tako utrujal, da ne uporabljajte\n",
    "`for i in range(len(s))`: zato, ker z njim namesto lepega, kratkega\n",
    "preglednega `[teza for teza, ime, zenska in podatki if not zenska]`\n",
    "dobimo\n",
    "`[podatki[i][0] for i in range(len(podatki)) if not podatki[i][2]]`.\n",
    "Seveda lahko delate tudi na ta, drugi način, če vam je v užitek. V svobodi živimo; noben zakon ne prepoveduje mazohizma.\n",
    "\n",
    "Sestavimo seznam vseh deliteljev danega števila `n`. Vzemimo, recimo\n",
    "`n = 60`. Seznam deliteljev je tedaj seznam vseh `x`, pri čemer `x`\n",
    "prihaja z intervala 1 ≤ x ≤ n, za katere velja, da je ostanek po\n",
    "deljenju `n` z `x` enak 0 (torej `x` deli `n`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "67b13431",
   "metadata": {},
   "outputs": [],
   "source": [
    "def delitelji(n):\n",
    "    return [x for x in range(1, n + 1) if n % x == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92d2bceb",
   "metadata": {},
   "source": [
    "Zdaj lahko hitro ugotovimo, ali je dano število popolno: popolna števila\n",
    "so (se še spomnimo?) števila, ki so enaka vsoti svojih deliteljev (brez\n",
    "sebe samega)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "663f5751",
   "metadata": {},
   "outputs": [],
   "source": [
    "def popolno(n):\n",
    "    return n == sum(delitelji(n)) - n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29efc9e8",
   "metadata": {},
   "source": [
    "Še bolj imenitna števila so praštevila, števila brez deliteljev. Se\n",
    "pravi tista, ki so deljiva le z 1 in s samim seboj."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a3ff2256",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prastevilo(n):\n",
    "    return delitelji(n) == [1, n]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02eded74",
   "metadata": {},
   "source": [
    "Če funkcije `delitelji` še ne bi imeli - nič hudega. Ali je število\n",
    "praštevilo, bi še vedno dognali v eni sami vrstici. Poleg tega bi lahko\n",
    "šli le od 2 do n (brez n); tako bi izpustili 1 in n ter število\n",
    "razglasili za praštevilo, če je je deljivo le z 1 in s samim seboj."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d2ff344e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prastevilo(n):\n",
    "    return [x for x in range(1, n + 1) if n % x == 0] == [1, n]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31db3186",
   "metadata": {},
   "source": [
    "Seveda je preprosteje, če spremenimo meje v `range` tako, da ne vključujejo `1` in `n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c9ef2845",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prastevilo(n):\n",
    "    return [x for x in range(2, n) if n % x == 0] == []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daf2548e",
   "metadata": {},
   "source": [
    "Še boljše pa je, če se spomnimo, da so prazni seznami neresnični."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0cd56d57",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prastevilo(n):\n",
    "    return not [x for x in range(2, n) if n % x == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fc4be4a",
   "metadata": {},
   "source": [
    "Za bis dodajmo še nekaj, česar ne bomo razložili."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "473d8f8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prastevilo(n):\n",
    "    return all(n % x for x in range(2, n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "145baeef",
   "metadata": {},
   "source": [
    "S to funkcijo - v katerikoliže obliki - hitro sestavimo seznam vseh praštevil med 2 in 100:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "211fb4ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2,\n",
       " 3,\n",
       " 5,\n",
       " 7,\n",
       " 11,\n",
       " 13,\n",
       " 17,\n",
       " 19,\n",
       " 23,\n",
       " 29,\n",
       " 31,\n",
       " 37,\n",
       " 41,\n",
       " 43,\n",
       " 47,\n",
       " 53,\n",
       " 59,\n",
       " 61,\n",
       " 67,\n",
       " 71,\n",
       " 73,\n",
       " 79,\n",
       " 83,\n",
       " 89,\n",
       " 97]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n for n in range(2, 101) if prastevilo(n)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a186b158",
   "metadata": {},
   "source": [
    "Znamo pa, jasno, tudi brez funkcije; tisto, kar dela funkcija, pač kar\n",
    "prepišemo v pogoj."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ce86725a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2,\n",
       " 3,\n",
       " 5,\n",
       " 7,\n",
       " 11,\n",
       " 13,\n",
       " 17,\n",
       " 19,\n",
       " 23,\n",
       " 29,\n",
       " 31,\n",
       " 37,\n",
       " 41,\n",
       " 43,\n",
       " 47,\n",
       " 53,\n",
       " 59,\n",
       " 61,\n",
       " 67,\n",
       " 71,\n",
       " 73,\n",
       " 79,\n",
       " 83,\n",
       " 89,\n",
       " 97]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n for n in range(2, 101) if not [x for x in range(2, n) if n % x == 0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f20afbe7",
   "metadata": {},
   "source": [
    "Takšnih reči sicer raje ne pišemo, saj hitro postanejo nepregledne.\n",
    "\n",
    "### Splošni vzorec\n",
    "\n",
    "V splošnem: vsak kos kode, ki izgleda takole\n",
    "\n",
    "```python\n",
    "r = []\n",
    "for e in s:\n",
    "    if pogoj(e):\n",
    "        r.append(izraz)\n",
    "```\n",
    "\n",
    "lahko prepišemo v\n",
    "\n",
    "```python\n",
    "r = [izraz for e in s if pogoj(e)]\n",
    "```\n",
    "\n",
    "Množice\n",
    "-------\n",
    "\n",
    "Množice sestavljamo natančno tako kot sezname, le da namesto oglatih\n",
    "oklepajev uporabimo zavite. Takole dobimo vse delitelje 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c37597ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{i for i in range(1, 61) if 60 % i == 0}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98fa4bfc",
   "metadata": {},
   "source": [
    "Slovarji\n",
    "--------\n",
    "\n",
    "Ista reč. Če hočemo narediti slovar, ki bo kot ključe vseboval števila\n",
    "do 10, kot vrednosti pa njihove kvadrate, napišemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "2628bb18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{i: i ** 2 for i in range(11)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5819b0b",
   "metadata": {},
   "source": [
    "## Nekaj uporabnih funkcij\n",
    "\n",
    "Te stvari res zaživijo, če jih uporabljamo v kombinaciji z nekaj funkcijami. Nekatere že poznamo, nekatere bodo postale smiselne šele danes.\n",
    "\n",
    "### `enumerate`\n",
    "\n",
    "Doslej sem sitnaril, da jo uporabljajmo, kadar potrebujemo tako indeks elementa kot njegovo vrednost. Zdaj bo še toliko uporabnejša, saj bo bistveno izboljšala preglednost izpeljanih seznamov, množic in slovarjev.\n",
    "\n",
    "Zdaj, ko smo ravno tako pametni, vemo tudi, kako bi napisali `enumerate`, če le-tega še ne bi bilo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d15b2440",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'A'), (1, 'n'), (2, 'a')]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def enumerate(s):\n",
    "    i = 0\n",
    "    for x in s:\n",
    "        yield i, x\n",
    "        i += 1\n",
    "        \n",
    "list(enumerate(\"Ana\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dc2ab79",
   "metadata": {},
   "source": [
    "### `zip`\n",
    "\n",
    "Tudi za `zip` že vemo: podamo ji nekaj seznamov in vrne nov seznam - seznam terk z elementi seznamov, ki smo jih poslali kot argumente.\n",
    "\n",
    "No, od danes vemo: v resnici vrne generator parov, ne seznama parov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f7349478",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x7ff2830931e0>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zip(\"Benjamin\", \"Margareta\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9725f738",
   "metadata": {},
   "source": [
    "Ignorirajte tiste `0x10193c308` (ali karkoli že se prikaže) - izpis je povedal, da smo naredili `zip` in ne seznama. Seveda lahko iz njega \"izgeneriramo\" seznam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "31a94fdb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('B', 'M'),\n",
       " ('e', 'a'),\n",
       " ('n', 'r'),\n",
       " ('j', 'g'),\n",
       " ('a', 'a'),\n",
       " ('m', 'r'),\n",
       " ('i', 'e'),\n",
       " ('n', 't')]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(\"Benjamin\", \"Margareta\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5869e166",
   "metadata": {},
   "source": [
    "Napišimo funkcijo, ki pove, v koliko črkah se ujemata dani besedi. Tako se, recimo, MELODIJA in DELODAJALEC ujemata v šestih črkah.\n",
    "\n",
    "```\n",
    "MELODIJA\n",
    "DELODAJALEC\n",
    " ELOD JA\n",
    "```\n",
    "\n",
    "Da bo naše delo lažje, se najprej spomnimo, da se `True` vede, kot da bi bil `1` in `False`, kot da bi bil 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9887e959",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True + 7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54c24f36",
   "metadata": {},
   "source": [
    "Vzemimo torehj besedi MELODIJA in DELODAJALEC."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "2212c459",
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = \"MELODIJA\"\n",
    "b2 = \"DELODAJALEC\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6dc4331",
   "metadata": {},
   "source": [
    "Združimo ju v seznam parov črk (`list` pa dodamo samo v izpisu, da vidimo, kaj smo v resnici setavili)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "625efaf4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('M', 'D'),\n",
       " ('E', 'E'),\n",
       " ('L', 'L'),\n",
       " ('O', 'O'),\n",
       " ('D', 'D'),\n",
       " ('I', 'A'),\n",
       " ('J', 'J'),\n",
       " ('A', 'A')]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(b1, b2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7486207",
   "metadata": {},
   "source": [
    "Poženimo zanko čez seznam parov črk in sestavimo nov seznam, ki bo vseboval `True`, če sta črki enaki in `False`, če različni."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a64a8a5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False, True, True, True, True, False, True, True]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[c == d for c, d in zip(b1, b2)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdd6ef7e",
   "metadata": {},
   "source": [
    "Zdaj pa preštejmo, koliko je `True`-jev. Kako? Če je `False` isto kot 0 in `True` isto kot 1, potem preprosto izračunamo vsoto elementov seznama."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "c5965c05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(c == d for c, d in zip(b1, b2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69e8de7c",
   "metadata": {},
   "source": [
    "Če bi torej hoteli napisati funkcijo, ki pove, v koliko črkah se besedi ujemata, bi rekli kar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5ee1779b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ujemanj(b1, b2):\n",
    "    return sum(c==d for c, d in zip(b1, b2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a9cf87e",
   "metadata": {},
   "source": [
    "Napišimo funkcijo, ki izračuna Evklidsko razdaljo med dvema točkama, katerih koordinate so predstavljene s seznamom. Imejmo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "141c2029",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2, 1, -3]\n",
    "b = [3, 5, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0deeeac4",
   "metadata": {},
   "source": [
    "Nalogo bi včasih rešili takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "46b05ed0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclid(a, b):\n",
    "    s = 0\n",
    "    for x, y in zip(a, b):\n",
    "         s += (x - y) ** 2\n",
    "    return sqrt(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d221cfc",
   "metadata": {},
   "source": [
    "Zdaj znamo veliko veliko preprosteje. Znamo sestaviti seznam parov? Znamo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f62380cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, 3), (1, 5), (-3, 4)]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[(x, y) for x, y in zip(a, b)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2369b2f",
   "metadata": {},
   "source": [
    "Znamo sestaviti seznam razlik parov? Znamo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "5dc8797d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, -4, -7]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x - y for x, y in zip(a, b)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72a82c87",
   "metadata": {},
   "source": [
    "Pravzaprav potrebujemo seznam kvadratov razlik."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "619b2151",
   "metadata": {},
   "source": [
    "[(x - y) ** 2 for x, y in zip(a, b)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30d4e0c0",
   "metadata": {},
   "source": [
    "In zdaj moramo vse to le še sešteti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "984aaa83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((x - y) ** 2 for x, y in zip(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a78bc2da",
   "metadata": {},
   "source": [
    "Funkcija, ki izračuna Evklidsko razdaljo, je torej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7abdf9db",
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclid(a, b):\n",
    "    return sqrt(sum((x - y) ** 2 for x, y in zip(a, b)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b67c29e",
   "metadata": {},
   "source": [
    "Te reči so, ko se jih navadiš, prav imenitno berljive. Program je skoraj dobesedno prepisan opis v naravnem jeziku: evklidska razdalja je koren vsote kvadratov razlik elementov, ki jih \"vzporedno\" jemljemo iz dveh seznamov.\n",
    "\n",
    "### `all` in `any`\n",
    "\n",
    "Funkciji `all` in `any` sta videti trivialno, v resnici\n",
    "pa sta prav imenitni in uporabni. Prva, `all`, prejme generator (ali, seveda, seznam, množico, niz, slovar...) in vrne `True`, če le-ta generira same resnične reči (recimo same `True`).\n",
    "\n",
    "Število `n` je praštevilo, če so vsi ostanki po deljenju z `i` (za vsak `i` od `2` do `n`) različni od 0. Z `all` se tole prevede skoraj dobesedno v Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "dba6fb3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prastevilo(n):\n",
    "    return all(n % i != 0 for i in range(2, n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5f95b80",
   "metadata": {},
   "source": [
    "Funkcija `any` vrne `True`, če tisto, kar podamo kot argument, vsebuje vsaj kakšno resnično vrednost. Kako deluje, pokažimo kar na obrnjenih praštevilih: število je sestavljeno, če je ostanek po deljenju s kakim drugim številom enak 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "abe1f77c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sestavljeno(n):\n",
    "    return any(n % i == 0 for i in range(2, n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "642dd61c",
   "metadata": {},
   "source": [
    "Mimogrede opazimo, da sta `all` in `any` povezana prek de Morganovega pravila, ki se bi ga morali spomniti iz matematike. Število je praštevilo, če ni sestavljeno,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "a4c8a657",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prastevilo(n):\n",
    "    return not sestavljeno(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2fad47f",
   "metadata": {},
   "source": [
    "Če namesto, da bi poklicali `sestavljeno`, vstavimo kar kodo funkcije `sestavljeno`, dobimo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "4c04c3d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prastevilo(n):\n",
    "    return not any(n % i == 0 for i in range(2, n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f3996fe",
   "metadata": {},
   "source": [
    "Če le obrnemo pogoj, vidimo, da je\n",
    "\n",
    "```python\n",
    "not any(n % i == 0 for i in range(2, n))\n",
    "```\n",
    "\n",
    "isto kot\n",
    "\n",
    "```python\n",
    "all(not n % i == 0 for i in range(2, n))\n",
    "```\n",
    "\n",
    "### `itertools.count`\n",
    "\n",
    "Še več cukra se nahaja v modulu `itertools`.\n",
    "\n",
    "Funkcija `count` iz modula `itertools` je kot `range`, ki ji podamo kvečjemu spodnjo mejo ali pa še te ne. `count()` generira vsa števila od 0 do neskončno, `count(n)` pa vsa števila od `n` naprej.\n",
    "\n",
    "Sam jo najpogosteje uporabljam v zvezi z `zip`. `zip(count(), s)` je isto kot `enumerate(s)`. To sicer ni prav uporabno - očitno je `enumerate(s)` preprosteje in jasneje kot `zip(count(), s)`. Pač pa se dogaja, da greš z `zip` čez tri sezname hkrati, poleg tega pa potrebuješ še indekse. To se da pisati kot\n",
    "\n",
    "```python\n",
    "for i, (x, y, z) in enumerate(zip(s, t, u)):\n",
    "```\n",
    "\n",
    "lahko pa pišemo kar\n",
    "\n",
    "```python\n",
    "for i, x, y, z in zip(count(), s, t, u)\n",
    "```\n",
    "\n",
    "Pa še kje vam bo prišel prav, če se spomnite nanj."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19542f3b",
   "metadata": {},
   "source": [
    "### `itertools.chain`\n",
    "\n",
    "Če imamo več generatorjev (ali seznamov, slovarjev...) in bi radi šli z eno zanko čez vse, torej čez enega za drugim, jih sestavimo s `chain`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "65a2714f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "n\n",
      "a\n",
      "B\n",
      "e\n",
      "r\n",
      "t\n",
      "a\n",
      "C\n",
      "i\n",
      "l\n",
      "k\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "from itertools import chain\n",
    "\n",
    "for c in chain(\"Ana\", \"Berta\", \"Cilka\"):\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a33c65c7",
   "metadata": {},
   "source": [
    "Seveda je to isto kot `for c in \"Ana\" + \"Berta\" + \"Cilka\":`, vendar je lepota v tem, da nizov nismo sešteli, temveč je `chain`. To je lepo predvsem, kadar ne verižimo nizov, temveč kaj, česar se ne da seštevati."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ca8ff0",
   "metadata": {},
   "source": [
    "### Itertools\n",
    "\n",
    "Vsi, ki vam je bilo tole všeč, bodo uživali tudi v ostalih [dobrotah iz modula `itertools`](https://docs.python.org/3/library/itertools.html#itertools.chain)."
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}