p1/predavanja/07b funkcijske funkcije.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b0aae694",
   "metadata": {},
   "source": [
    "## Funkcijsko programiranje\n",
    "\n",
    "Tule bomo spoznali nekaj tipičnih funkcij iz zakladnice *funkcijskega programiranja*. Tu ne gre za \"programiranje s funkcijami\", kot bi kdo naivno pomislil, temveč na nek način zlaganja programov. Boste videli.\n",
    "\n",
    "Tema je kar napredna in namenjena bolj zagretim študentom.\n",
    "\n",
    "Različni jeziki imajo različno sintakso. Zelo veliko jih sicer povzema C-jevsko - kdor zna C ali Javo, mu bosta domača tudi Javascript in php). Pythonova ali, recimo, Kotlinova sintaksa je precej drugačna. Medtem ko našteti jeziki bloke označujejo z zavitimi oklepaji, jih Python z bloki; Pascal ima raje `begin` in `end`. Programer v C-ju mora pomagati prevajalniku, tako da sam skrbno postavlja kupe oklepajev in podpičij; v Pythonu je nepotrebno, ker je jezik zasnovan drugače, moderni Javascript pa meje med stavki (kjer bi morali v C dati podpičje, v Pythonu pa iti v novo vrstico) preprosto ugiba in (navadno) ugane.\n",
    "\n",
    "Od sloga sintakse je odvisno, kaj se bo v jeziku lepo povedalo, kaj ne.\n",
    "\n",
    "- Python, recimo, nima zanke do-while, ki jo morda poznate iz drugih jezikov. Osnovni razlog je, da se je v Pythonovem načinu oblikovanja blokov, z dvopičji, preprosto ne da lepo opisati. Ker je zanka do-while obenem zelo redko dejansko uporabna (sam jo zapogrešam najbrž enkrat letno, če sploh) in ker jo je preprosto nadomestiti z `while True` ter pogojnim `break` na koncu zanke, so se odločili, da z njo ne bodo kazili jezika (lahko pa pogledate [predlog](https://peps.python.org/pep-0315/) in [odgovor](https://mail.python.org/pipermail/python-ideas/2013-June/021610.html)).\n",
    "- Drugačen primer je ternarni operator, v C-jevskih jezikih zapisan z `?:`. Ta način bi v Pythonu izstopal, ker je Python bolj \"beseden\" jezik (`and` in `or`, ne `&&` in `||`). Ker je vendarle uporaben in predvsem, ker so se programerji pogosto zatekali k alternativi, ki včasih ne da pravega rezultata (C-jevski `p ? a : b` so v Pythonu zapisali z `p and a or b`, kar pa da napačen rezultat, če je `p` resničen, `a` pa je, recimo, `0` ali prazen seznam), je Python po [dolgih diskusijah](https://peps.python.org/pep-0308/) dobil operator `if-else`, ki pa se ga celo malo izogibamo. Ker je čuden.\n",
    "- Nekaj, kar je v Pythonu - ki je sicer sodoben jezik - absolutno grozno, so lambda-funkcije. Pri Programiranju 1 bi jih najbrž morali predstaviti, vendar Pythonove tega skoraj niso vredne. Omejene so na en sam izraz, nepregledne, uporabne zgolj v butičnih primerih. V Javascriptu in Kotlin med funkcijo in lambda-funkcijo ni razlike - tako kot mora biti. Lisp je pa itak razred zase.\n",
    "\n",
    "Vsaka sintaksa ima torej svoje slabosti in prednosti. Python smo v zgornjih točkah le kritizirali, vendar to, recimo, le zato, ker smo pri predmetu doslej spoznavali, kako izrazna, učinkovita je njegova sintaksa. Glede na tokratno temo pa ... mešani občutki.\n",
    "\n",
    "Pythonov sintaktični slog je fantastičen, ko gre za izpeljane sezname, slovarje, množice. Osnovno inspiracijo je dobil v jeziku Haskell, vendar (tudi) v Pythonu to deluje sintaktično lepo, pregledno.\n",
    "\n",
    "Druga sintaksa za podoben način programiranja temelji na nekaj funkcijah, konkretno `map`, `filter` in `reduce`. V tej obliki jih bomo našli v večini drugih jezikov, v katere bi bilo morda težje uvesti Pythonovo (no, Hasklovo) sintakso. In, predvsem, v jezikih z močnejšo lambdo. Te funkcije ima tudi Python, vendar niso tako zelo uporabne. Veliko več zakladov pa najdemo v modulu itertools, ki tudi nekako sodi v to zgodbo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7b2fb47",
   "metadata": {},
   "source": [
    "## Map\n",
    "\n",
    "Funkcija `map` kot argument prejme funkcijo in nekaj, prek česar je možno nagnati zanko. Vsak element tega, nečesa, \"premapira\" čez funkcijo. Če imamo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "775ade71",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "k = [9, 25, 16, 81]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23443c25",
   "metadata": {},
   "source": [
    "bo `map(sqrt, k)` vrnil korene vseh števil v `k`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9041661a",
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in map(sqrt, k):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1603177",
   "metadata": {},
   "source": [
    "Funkcija `map` dela, približno tole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9418a546",
   "metadata": {},
   "outputs": [],
   "source": [
    "def map(func, s):\n",
    "    return [func(x) for x in s]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "249c11f6",
   "metadata": {},
   "source": [
    "Do Pythona 3.0 je funkcija `map` v resnici vračala seznam, od različica 3.0 naprej pa vrne *iterator*. Za tiste, ki ne veste, kaj je to: vede se kot seznam, samo da ni; čezenj lahko gremo z zanko `for`. Za tiste, ki ne veste, pa bi radi izvedeli: preberite zapiske o generatorjih in iteratorjih. Za tiste, ki veste: ja, takšen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "253b56ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "def map(func, s):\n",
    "    for x in s:\n",
    "        yield func(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb9ef386",
   "metadata": {},
   "source": [
    "Ali (isto, le krajše)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4f034a8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def map(func, s):\n",
    "    return (func(x) for x in s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54081490",
   "metadata": {},
   "source": [
    "Funkcijo `map` smo pogosteje uporabljali do Pythona 2.0. Ta pa je uvedel izpeljane sezname. Prednost novejše različice je v tem, da\n",
    "\n",
    "- ne zahteva funkcije, temveč izraz; generatorja `(x ** 2 for x in s)` ne moremo prepisati v `map(**2, s)`, temveč potrebujemo lambdo: `map(lambda x: x ** 2, s)`;\n",
    "- je `map` počasnejši, ker vedno kliče funkcijo, medtem ko je novejši zapis, generator, ne (vsak, dokler lahko vse opravimo z izrazom).\n",
    "\n",
    "Osebno `map` rad uporabim, kadar imam funkcijo ravno pri roki in kadar izgleda sintaktično lepše.\n",
    "\n",
    "Se pravi: redko.\n",
    "\n",
    "## Filter\n",
    "\n",
    "Funkcija `filter` je druga funkcija, ki so jo izpeljani seznami spravili ob delo. `filter(func, s)` vrne vse tiste elemente `s`, pri katerih `func` vrne `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7a591a8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def vsebuje_i(s):\n",
    "    return \"i\" in s\n",
    "\n",
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\"]\n",
    "\n",
    "for x in filter(vsebuje_i, imena):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2804fee8",
   "metadata": {},
   "source": [
    "To je seveda isto kot `(x for x in imena if vsebuje_i(x))`, kar je tako ali tako le bolj zapletena različica `(x for x in imena if \"i\" in x)`. Resnici na ljubo tudi `filter` ne potrebuje poprej definirane funkcije, saj bi lahko pisali `filter(lambda x: \"i\" in x, imena)`. Vendar je očitno, zakaj filtra ne vidimo več velikokrat.\n",
    "\n",
    "Izpeljani seznami, slovarji, množice in generatorji v enem zamahu naredijo oboje, mapirajo in filtrirajo.\n",
    "\n",
    "## Reduce\n",
    "\n",
    "Funkcija `reduce` je edina iz te družbe, ki ni ostala brezposelna. No, hkrati pa tudi najmanj uporabna od njih, saj Python ni ravno jezik za te hece. Mogoče je tudi to razlog, da jo dobimo v modulu `functools` in ne kar tako, na prostem.\n",
    "\n",
    "`reduce(func, s)` je nekako ekvivalenten temu `func(func(func(func(s[0], s[1])), s[2]), s[3]), s[4])` - če je `s` seznam s petimi elementi. Ali, v kodi (ki sicer ne zna vsega, kar zna `reduce`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f286265f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reduce(func, s):\n",
    "    acc = s[0]\n",
    "    for x in s[1:]:\n",
    "        acc = func(acc, x)\n",
    "    return acc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f11dc55",
   "metadata": {},
   "source": [
    "Po domače: `reduce` pokliče funkcijo na prvih dveh elementih, nato na rezultatu tega klica in tretjem elementu, nato na rezultatu tega klica in četrtem elementu... Spremenljivko `acc` pa smo poimenovali po njeni vlogi: akumulator.\n",
    "\n",
    "Če vemo, kaj so iteratorji in kaj počne `next`, znamo bolj natančno (če ne, pa nič narobe, tudi gornje je dovolj dobro za razumevanje, ki ga potrebujemo za uporabo funkcije):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "99d5c014",
   "metadata": {},
   "outputs": [],
   "source": [
    "def reduce(func, s, acc=None):\n",
    "    t = iter(s)\n",
    "    if acc is None:\n",
    "        acc = next(t)\n",
    "        \n",
    "    for x in t:\n",
    "        acc = func(acc, x)\n",
    "    return acc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c17f58f",
   "metadata": {},
   "source": [
    "Z `reduce` se da početi zanimive stvari. Pripravimo si nekaj funkcij (ki bi lahko bile tudi lambde, ampak recimo, da jih ne znamo pisati)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7e903527",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sestej(a, b):\n",
    "    return a + b\n",
    "\n",
    "def zmnozi(a, b):\n",
    "    return a * b\n",
    "\n",
    "def vrni_vecjega(a, b):\n",
    "    if a > b:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n",
    "    \n",
    "def oba_resnicna(a, b):\n",
    "    return a and b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d06ed5bb",
   "metadata": {},
   "source": [
    "Pripravimo si še priložnostni seznam števil."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "aa8036a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = [4, 2, 6, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "977a0f18",
   "metadata": {},
   "source": [
    "Z `reduce` lahko zdaj izračunamo vsoto elementov seznama"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e120bc32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(sestej, s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02140da0",
   "metadata": {},
   "source": [
    "produkt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dc380fda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "144"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(zmnozi, s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f733b522",
   "metadata": {},
   "source": [
    "in poiščemo največji element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "db3bbe92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(vrni_vecjega, s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6030d513",
   "metadata": {},
   "source": [
    "mimogrede pa še 10!, se pravi produkt števil do 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "7d6ef129",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(zmnozi, range(1, 11))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49091f35",
   "metadata": {},
   "source": [
    "Če imamo seznam `True`-jev in `False`-ov, lahko z `reduce` izračunamo njegovo konjunkcijo (`and` prek vseh elementov`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b51382b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(oba_resnicna, [True, True, True, True, True])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7d1a1041",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reduce(oba_resnicna, [True, True, True, False, True])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86d70244",
   "metadata": {},
   "source": [
    "Imenitna reč, problem je le, da se nam teh funkcij ne da definirati vnaprej, Pythonove lambde, s katerimi lahko funkcijo definiramo kar sproti, znotraj klica `reduce`, pa so zelo kilave in tudi nikoli ne bodo drugačne kot kilave."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e7409ba",
   "metadata": {},
   "source": [
    "# Zakladi iz modula `itertools`\n",
    "\n",
    "Za dve funkciji iz modula `iterools` smo že povedali v \"glavnem\" delu predavanja: `chain` in `count`. Tidve boste potrebovali najpogosteje. Poleg njih vsebuje še veliko drugih - zanimivih in uporabnih, če se spomnimo nanje."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "649c4eea",
   "metadata": {},
   "source": [
    "### `pairwise`\n",
    "\n",
    "Zaporedne elemente seznama dobimo, vemo, z `zip(s, s[1:])`. Od različice 3.10 lahko uporabimo `pairwise`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e7c3145a",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\", \"Fanči\", \"Greta\", \"Helga\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "836f7705",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana Berta\n",
      "Berta Cilka\n",
      "Cilka Dani\n",
      "Dani Ema\n",
      "Ema Fanči\n",
      "Fanči Greta\n",
      "Greta Helga\n"
     ]
    }
   ],
   "source": [
    "from itertools import pairwise\n",
    "\n",
    "for x, y in pairwise(s):\n",
    "    print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2da0e83a",
   "metadata": {},
   "source": [
    "### `cycle` in `repeat`\n",
    "\n",
    "`cycle` preprosto ponavlja seznam v neskončnost. Zanke\n",
    "\n",
    "```python\n",
    "for x in cycle(s):\n",
    "    print(x)\n",
    "```\n",
    "\n",
    "raje ne poganjajmo, saj bi v neskončnost ponavljala gornjih osem imen. Zanko čez `cycle` bomo vedno z nečim prekinili. Recimo tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a32f435d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana levo\n",
      "Berta desno\n",
      "Cilka levo\n",
      "Dani desno\n",
      "Ema levo\n",
      "Fanči desno\n",
      "Greta levo\n",
      "Helga desno\n"
     ]
    }
   ],
   "source": [
    "from itertools import cycle\n",
    "\n",
    "for ime, smer in zip(s, cycle([\"levo\", \"desno\"])):\n",
    "    print(ime, smer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d290236",
   "metadata": {},
   "source": [
    "Ta primer tudi nakazuje rdečo nit tega, kar bomo počeli tu - in kar se v splošnem trudimo početi s takimi funkcijami - opraviti čimveč dela s smiselnim gnezdenjem teh funkcij."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa09149d",
   "metadata": {},
   "source": [
    "`repeat` uporabimo, če želimo v neskončnost ponavljati en sam element. V resnici ga ne potrebujemo velikokrat; tule je malo umeten primer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "15c9aa95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana gre skozi vrata 1\n",
      "Berta gre skozi vrata 2\n",
      "Cilka gre skozi vrata 3\n",
      "Dani gre skozi vrata 4\n",
      "Ema gre skozi vrata 4\n",
      "Fanči gre skozi vrata 4\n",
      "Greta gre skozi vrata 4\n",
      "Helga gre skozi vrata 4\n"
     ]
    }
   ],
   "source": [
    "from itertools import repeat, chain\n",
    "\n",
    "for ime, vrata in zip(s, chain(range(1, 4), repeat(4))):\n",
    "    print(ime, \"gre skozi vrata\", vrata)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19eb2098",
   "metadata": {},
   "source": [
    "Če zmanjka vrat (ki jih generira `range(1, 4)`), morajo vsi skozi zadnja vrata, 4."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7df39aab",
   "metadata": {},
   "source": [
    "### `zip_longest`\n",
    "\n",
    "Gornje sicer ni nič drugega kot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "54dadfe4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana gre skozi vrata 1\n",
      "Berta gre skozi vrata 2\n",
      "Cilka gre skozi vrata 3\n",
      "Dani gre skozi vrata 4\n",
      "Ema gre skozi vrata 4\n",
      "Fanči gre skozi vrata 4\n",
      "Greta gre skozi vrata 4\n",
      "Helga gre skozi vrata 4\n"
     ]
    }
   ],
   "source": [
    "from itertools import zip_longest\n",
    "\n",
    "for ime, vrata in zip_longest(s, range(1, 4), fillvalue=4):\n",
    "    print(ime, \"gre skozi vrata\", vrata)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be6a679c",
   "metadata": {},
   "source": [
    "Funkcija `zip` vedno vrne toliko reči, kolikor jih je v krajšem izmed podanih seznamov (ali česarkoli že). Funkcija `zip_longest` generira reči toliko časa, kolikor zmore najdaljši od podanih argumentov, manjkajoče vrednosti pa nadomešča s podano `fillvalue`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dc0d8e5",
   "metadata": {},
   "source": [
    "### `batched`\n",
    "\n",
    "Tole je čisto sveža pridobitev, iz Pythona 3.12. Ker v času sestavljanja zapiskov poganjam Python 3.11 (nova različica Pythona vedno pride v začetku oktobra, zato pri predmetu vedno uporabljamo prejšnjo), tega primera niti e ne moremo pognati:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c59beb1",
   "metadata": {},
   "source": [
    "```\n",
    "from itertools import batched\n",
    "\n",
    "for skupina in batched(s, 3):\n",
    "    print(skupina)\n",
    "```\n",
    "\n",
    "v različici 3.12 izpiše\n",
    "\n",
    "```\n",
    "[\"Ana\", \"Berta\", \"Cilka\"]\n",
    "[\"Dani\", \"Ema\", \"Fanči\"]\n",
    "[\"Greta\", \"Helga\"]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c8a3b44",
   "metadata": {},
   "source": [
    "To funkcijo smo v resnici pogrešali in se zatekali celo k takšnim norostim, kot je"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e85e581a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Ana', 'Berta', 'Cilka')\n",
      "('Dani', 'Ema', 'Fanči')\n"
     ]
    }
   ],
   "source": [
    "for skupina in zip(*[iter(s)] * 3):\n",
    "    print(skupina)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2603abcf",
   "metadata": {},
   "source": [
    "Rezultat je podoben, le da manjka zadnja, nepopolna skupina. Razumeti, zakaj to deluje, pa naj bo v izziv tistim, ki imajo radi izzive."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6455bf2",
   "metadata": {},
   "source": [
    "### `compress`\n",
    "\n",
    "\n",
    "Funkcija `compress` \"kompresira\" sezname tako, da odstrane neželene elemente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3eb7cf70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Dani', 'Greta']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from itertools import compress\n",
    "\n",
    "primerna = [True, True, False, True, False, False, True]\n",
    "\n",
    "list(compress(s, primerna))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be75029d",
   "metadata": {},
   "source": [
    "V osebnoizpovedni noti naj povem, da te funkcije nisem opazil vse do teh predavanj in zato redno pridno pisal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "22b7a623",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Dani', 'Greta']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x, p in zip(s, primerna) if p]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "800aae04",
   "metadata": {},
   "source": [
    "Nekako isto, vendar brez potrebe daljše.\n",
    "\n",
    "Istočasno naj to služi kot še en primer, ko izpeljani seznami nudijo isti mehanizem kot te funkcije."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbc75942",
   "metadata": {},
   "source": [
    "### `takewhile`, `dropwhile`\n",
    "\n",
    "`takewhile(func, s)` sprejme funkcijo in neko zaporedje (recimo seznam) ter vrača njegove člene, do prvega, za katerega `func` vrne `False` (oziroma neresnično vrednost)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57e8a3a3",
   "metadata": {},
   "source": [
    "Tole bi rešilo nalogo, ki bi spraševala, do kod se lahko pripeljemo po podani poti, če ne moremo voziti, po poteh, ki jih ni in po poteh, ki ne zahtevajo nobene veščine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "ac0f31f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gremo iz A v B\n",
      "Gremo iz B v A\n",
      "Gremo iz A v C\n",
      "Pot se konča v  C\n"
     ]
    }
   ],
   "source": [
    "from itertools import takewhile\n",
    "\n",
    "A, B, C, D = \"ABCD\"\n",
    "zemljevid = {(A, B): \"trava\", (A, C): \"avtocesta\", (A, D): \"robnik\", (C, B): \"bolt\", (B, A): \"trava\"}\n",
    "pot = \"ABACDA\"\n",
    "\n",
    "for iz, v in takewhile(zemljevid.get, pairwise(pot)):\n",
    "    print(\"Gremo iz\", iz, \"v\", v)\n",
    "print(\"Pot se konča v \", v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42f11169",
   "metadata": {},
   "source": [
    "Funkciji `takewhile` smo podali `zemljevid.get`. Ta bo prejemala pare, ki jih vrača `pairwise`. Če par obstaja, `get` vrne pripadajočo vrednost. Če je ta prazna, je neresnična in pot se ustavi (ker smo rekli, da ne bomo šli po povezavah, ki ne zahtevajo nobene veščine). Če povezava ne obstaja, pa `get` vrne `None`, kar je prav tako neresnično.\n",
    "\n",
    "Če nas vmesni koraki ne zanimajo, pišemo kar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "02f40fa8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gremo iz A v B\n",
      "Gremo iz B v A\n",
      "Gremo iz A v C\n",
      "Pot se konča v  C\n"
     ]
    }
   ],
   "source": [
    "from itertools import takewhile\n",
    "\n",
    "A, B, C, D = \"ABCD\"\n",
    "zemljevid = {(A, B): \"trava\", (A, C): \"avtocesta\", (A, D): \"robnik\", (C, B): \"bolt\", (B, A): \"trava\"}\n",
    "pot = \"ABACDA\"\n",
    "\n",
    "for iz, v in takewhile(zemljevid.get, pairwise(pot)):\n",
    "    print(\"Gremo iz\", iz, \"v\", v)\n",
    "print(\"Pot se konča v \", v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "542512d7",
   "metadata": {},
   "source": [
    "Za rešitev domače naloge, v kateri nas zanima, do katere točke na zemljevidu pridemo s podanimi veščinami in katere veščine nam manjkajo, pa lahko uporabimo `dropwhile`. Ta izpušča člene, dokler zanje funkcije vrača `True` (oziroma resnično vrednost). Nas zanima le prva vrednost - in izvabimo jo z `next`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e6c6f117",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import dropwhile, pairwise\n",
    "\n",
    "def koncna_tocka(pot, zemljevid, vescine):\n",
    "    zemljevid = dvosmerni_zemljevid(zemljevid)\n",
    "    pov = next(dropwhile(lambda pov: pov in zemljevid and zemljevid[pov] <= vescine, pairwise(pot)))\n",
    "    return pov[0], zemljevid[pov] - vescine"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "547f851e",
   "metadata": {},
   "source": [
    "Uporabili smo še slavno lambdo: `lambda pov: pov in zemljevid and zemljevid[pov] <= vescine` je \"sproti definirana funkcija\", ki prejme en argument (`pov`) in vrne vrednost izraza `pov in zemljevid and zemljevid[pov] <= vescine`. Ta je resničen, če smemo prehoditi to povezavo. `dropwhile`-u damo to funkcijo in pare točk na poti. Ko ga `next` pozove, naj vrne naslednji element, ta preskoči vse povezave, ki jih smemo ubrati in vrne prvo, ki je ne moremo. Vrnemo prvo točko te povezave in, seveda, veščine, ki jih zahteva ta povezava ni jih kolesar nima (`zemljevid[pov] - vescine`)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d535c4c0",
   "metadata": {},
   "source": [
    "## Zaključne misli :)\n",
    "\n",
    "Menda smo videli, za kaj gre: kup funkcij, ki jih lahko nizamo in vsaka procesira -- predeluje, filtrira, preskakuje, grupira -- zaporedja in jih podaja naslednji funkciji. To včasih vodi v elegantne rešitve, včasih pa v nerazumljive.\n",
    "\n",
    "Slednje je v Pythonu kar pogosto. Problem je, da se funkcije nizajo odznotraj navzven, argumenti pa izgubljajo nekje na koncu. Primer smo videli v eni domačih nalog."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "09dd4b48",
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import itemgetter\n",
    "from itertools import groupby\n",
    "\n",
    "def zapisi(ovire):\n",
    "    return \"\\n\".join(zapisi_vrstico(y, sorted(x[:2] for x in group))\n",
    "                     for y, group in groupby(sorted(ovire, key=itemgetter(2)), itemgetter(2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f0bc562",
   "metadata": {},
   "source": [
    "Deluje, ni pa berljivo. Python je lep jezik, ni pa vsak jezik lep za vsak slog programiranja. Če se kdo potrudi to prebrati, bo videl, da mora brati nazaj - najprej se zgodi (drugi) `sorted`, nato `groupby`, potem `zapisi_vrstico`, katere rezultati se združijo z `join`. To bi se bralo veliko lepše v jezikih, v katerih se to zapiše naprej, recimo v Kotlinu ali Javascriptu.\n",
    "\n",
    "Tule je primer funkcije, ki vrne ime podanega direktorija (`slug`) in vseh poddirektorijev znotraj njega (vgnezdeno, torej s podpodpodpodpodpoddirektoriji). Funkcija je napisana v enakem slogu v JavaScriptu in Pythonu."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "787be116",
   "metadata": {},
   "source": [
    "Javascript:\n",
    "\n",
    "```js\n",
    "const traversePaths = (slug) => fs\n",
    "    .readdirSync(slug)\n",
    "    .map((name) => path.join(slug, name))\n",
    "    .filter((subslug) => fs.statSync(subslug).isDirectory())\n",
    "    .reduce((acc, subslug) => [...acc, ...traversePaths(subslug)], [slug]);\n",
    "```\n",
    "\n",
    "Python:\n",
    "\n",
    "```python\n",
    "from os import path, listdir\n",
    "from itertools import reduce\n",
    "\n",
    "def traversePaths(slug):\n",
    "    return reduce(lambda acc, subslug: acc + traversePaths(subslug),\n",
    "                  filter(path.isdir, \n",
    "                         map(lambda name: path.join(slug, name),\n",
    "                             listdir(slug)\n",
    "                            )\n",
    "                        ),\n",
    "                  [slug]\n",
    "                 )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eed4a717",
   "metadata": {},
   "source": [
    "Funkcija dela tako:\n",
    "\n",
    "- preberemo direktorij (`readDirSync` v JavaScriptu, `listdir` v Pythonu),\n",
    "- v `map` vsakemu imeno dodamo pot do njega (`path.join`),\n",
    "- s `filter` obdržimo le imena, ki se nanašajo na direktorije (`isDirectory`, `isDir`),\n",
    "- z `reduce` k `[slug]` prištejemo sezname vseh imen, ki jih dobimo z rekurzivnim klicem `traversePath`.\n",
    "\n",
    "Vidimo problem? V Javascriptu so `map`, `filter`, `reduce` in podobno metode seznamov (no, arrayev), zato se berejo v pravilnem vrstnem redu. V Pythonu so to funkcije, ki dobijo sezname kot argument, zato mora biti tisto, kar se zgodi prej, napisano kasneje. K temu dodajmo še zoprne lambde ... in ta funkcija v Pythonu pač ne sodi v produkcijsko kodo."
   ]
  }
 ],
 "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
}