pn/predavanja/05 Funkcije.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4182ea77",
   "metadata": {},
   "source": [
    "# Funkcije\n",
    "\n",
    "Opazili ste - in malo vam gre tudi na živce, bi rekel - da stalno ponavljamo ene in iste zadeve. Recimo: stalno je potrebno iskati *ključ seznama, ki mu pripada največja vrednost*. V smislu, imamo slovar, katerega ključi so predmeti in vrednosti njihove cene, naloga pa hoče, da poiščemo najdražji predmet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "97f53cd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "cene = {\n",
    "    'slika': 45,\n",
    "    'pozlačen dežnik': 29,\n",
    "    'Meldrumove vaze': 78,\n",
    "    'skodelice': 83,\n",
    "    'kip': 107,\n",
    "    'čajnik': 15,\n",
    "    'srebrn jedilni servis': 63,\n",
    "    'perzijska preproga': 21}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f58b084f",
   "metadata": {},
   "source": [
    "In potem se, vsakič znova, ubijamo z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9e84ef7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "max_k = max_v = None\n",
    "\n",
    "for k, v in cene.items():\n",
    "    if max_v is None or v > max_v:\n",
    "        max_v = v\n",
    "        max_k = k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "952a86ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kip\n"
     ]
    }
   ],
   "source": [
    "print(max_k)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b4ad11",
   "metadata": {},
   "source": [
    "Opravičujem se za kratka, nezgovorna imena spremenljivk, ampak vsega tega imam res že dosti.\n",
    "\n",
    "Imam dobro novico in dve slabi."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "458bb515",
   "metadata": {},
   "source": [
    "*Dobra novica*: obstaja funkcija `argmax`, ki ji podamo slovar in vrne ključ, ki pripada največji vrednosti.\n",
    "\n",
    "*Prva slaba novica*: dobra novica ne drži. Funkciji `argmax` ne podamo slovarja, temveč seznam parov. Funkcija primerja druge elemente parov, poišče največjega in vrne pripadajoči prvi element. Vendar ta slaba novica ni tako usodna: funkciji pač podamo `d.items()` (če je `d` naš slovar). Tako bo dobila `[('slika', 45), ('pozlačen dežnik', 29), ('Meldrumove vaze', 78), ('skodelice', 83), ('kip', 107), ('čajnik', 15), ('srebrn jedilni servis', 63), ('perzijska preproga', 21)]` in vrnila `'kip'`, saj je to prvi element, ki mu pripada največji drugi element.\n",
    "\n",
    "*Druga slaba novica*: dobra novica sploh ne drži. Take funkcije ni. Fake novica."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aba49b3b",
   "metadata": {},
   "source": [
    "Vedno rad citiram nepozabnega srednješolskega profesorja matematike Francija Oblaka: \"*Česar ni, se pa nar'di.*\" Naredimo torej takšno funkcijo.\n",
    "\n",
    "Oglejmo si celico 2, v kateri smo računali ta naš slavni maksimum. V njej je zapisano vse, kar mora delati ta funkcija. Seveda pa si želimo, da bi poiskala maksimum v poljubnem slovarju, ne nujno v `cene`. Poleg tega se bomo dogovorili, da tisto, v čemer išče maksimum, ne bo slovar temveč seznam parov. Imeli bomo torej nekaj takšnega:\n",
    "\n",
    "```python\n",
    "max_k = max_v = None\n",
    "\n",
    "for k, v in s:\n",
    "    if max_v is None or v > max_v:\n",
    "        max_v = v\n",
    "        max_k = k\n",
    "```\n",
    "\n",
    "To je le prepisana vsebina gornje celice, le `cene.items()` sem zamenjal s `s`. Ta `s` bo tisto, kar je funkcija dobila kot argument.\n",
    "\n",
    "Kaj se to pravi, \"*`s` bo tisto, kar je funkcija dobila kot argument*\"?! No, pač, če bomo poklicali `argmax(cene.items())`, bo funkcija `s` vseboval `cene.items()`.\n",
    "\n",
    "Očitno bo potrebno postoriti (vsaj) še dvoje. Troje, pravzaprav. Četvero. (To že postaja podobno [Španski inkviziciji](https://www.youtube.com/watch?v=Cj8n4MfhjUc))!\n",
    "\n",
    "1. Te vrstice je treba nekako \"zgrupirati\", povedati Pythonu, da bo to koda neke funkcije.\n",
    "2. Funkciji je potrebno dati ime (`argmax`).\n",
    "3. Povedati je potrebno, da bo zahtevala en argument.\n",
    "4. Povedati je potrebno, pod kakšnim imenom bomo znotraj funkcije videli (dostopali do...) podatka, danega kot argument (oziroma, v splošnem, do podatkov, podanih kot argumenti).\n",
    "\n",
    "Vse to storimo praktično v eni vrstici."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8b71c210",
   "metadata": {},
   "outputs": [],
   "source": [
    "def argmax(s):\n",
    "    max_k = max_v = None\n",
    "\n",
    "    for k, v in s:\n",
    "        if max_v is None or v > max_v:\n",
    "            max_v = v\n",
    "            max_k = k"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15485520",
   "metadata": {},
   "source": [
    "1. Z besedo `def` povemo, da sledi definicija ganz nove funkcije. (Dandanašnja mladina sploh ne zna več prave slovenščine, zato jo je treba kdaj spomniti, da obstajajo tudi druge, bolj slovenske besede kot *totally*.)\n",
    "\n",
    "2. Sledi ime funkcije, torej `argmax`.\n",
    "\n",
    "3. Nato pridejo oklepaji in v njih toliko imen, kolikor argumentov zahteva funkcija. Med imena (če jih je več) postavimo vejice. Če funkcija ne mara argumentov, vseeno napišemo oklepaje, čeravno so prazni oklepaji videti neumno. Tu so možne še vsakršne druge komplikacije, kot recimo argumenti, ki jih lahko izpustimo in imajo privzeto vrednost, ali pa funkcije, ki prejemajo poljubno število argumentov, funkcije, ki zahtevajo, da argumente poimenujemo. Začetni tečaj programiranja, sploh za študente, ki najbrž ne bodo profesionalni računalnikarji, vsega tega ne potrebuje.\n",
    "\n",
    "4. To, kar funkcija dobi kot argument(e), vidimo pod imeni, ki so navedena v oklepajih. Naša funkcija je navedla eno ime, `s`, torej kot argument pričakuje eno stvar in znotraj funkcije se bomo na to stvar sklicevali z imenom `s`. Pod kakšnim imenom je ta stvar znana zunaj, nas niti ne zanima niti (če nismo res vztrajni in dobro poznamo Python) tega ne moremo izvedeti. In prav je tako.\n",
    "\n",
    "Preskusimo, če deluje!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1d3a29d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(argmax(cene.items()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04c73527",
   "metadata": {},
   "source": [
    "`None`? Kakšen `None`?! Mar nismo obljubili, da bo funkcija vračala ... Aja. Kje pa piše, kaj ta funkcija vrne? V funkciji živi kup spremenljivk - ne le `max_v` in `max_k` temveč tudi `k` in `v`. Python ne more vedeti, katera od njih naj bo rezultat funkcije. Če sploh katera; obstajajo tudi funkcije (recimo `print`), ki ne vračajo ničesar. Da, Python si je očitno predstavljal, da ta funkcija ne bo vračala ničesar, pa se nam je zato posmehnil s tem `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f76026c",
   "metadata": {},
   "source": [
    "V seznam potreb španske inkvizicije torej moramo dodati še\n",
    "\n",
    "5. Povedati moramo, kaj funkcija vrne.\n",
    "\n",
    "in dopolniti funkcijo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b5728b32",
   "metadata": {},
   "outputs": [],
   "source": [
    "def argmax(s):\n",
    "    max_k = max_v = None\n",
    "\n",
    "    for k, v in s:\n",
    "        if max_v is None or v > max_v:\n",
    "            max_v = v\n",
    "            max_k = k\n",
    "    return max_k"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d3a79ef",
   "metadata": {},
   "source": [
    "In jo preskusiti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6ebc7711",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kip\n"
     ]
    }
   ],
   "source": [
    "print(argmax(cene.items()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4936aec5",
   "metadata": {},
   "source": [
    "To je to: z besedo `return` povemo, kaj naj funkcija vrne."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "258b7a8b",
   "metadata": {},
   "source": [
    "## Več `return`-ov\n",
    "\n",
    "Napišimo funkcijo `dragoceni(s)`, ki vrne predmete, katerih cene so večje od 70. Točneje, funkcija prejme seznam parov, pri čemer predpostavljamo, da je drugi element para število. Vrne tiste prve elemente, pri katerih je drugi element večji od `70`. Rezultat morajo biti Meldrumove vaze, skodelice in kip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "173619de",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dragoceni(s):\n",
    "    for k, v in s:\n",
    "        if v > 70:\n",
    "            return k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a5241492",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meldrumove vaze\n"
     ]
    }
   ],
   "source": [
    "predmeti = dragoceni(cene.items())\n",
    "\n",
    "print(predmeti)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bae22bd4",
   "metadata": {},
   "source": [
    "Kaj pa skodelice in kip?\n",
    "\n",
    "Nekatere je najbrž zaskrbelo že prej, nekateri razumejo zdaj, nekateri pa še bodo. Naloga ni bila ravno najboljše definirana. *Kaj* točno naj bi funkcija vračala? Niz? Več nizov? Se pravi, kakšnega tipa naj bi bili `predmeti`?\n",
    "\n",
    "Besedilo naloge je nekako impliciralo, da bo šlo za več nizov, ni pa jasno povedala, kako naj bi bilo teh več nizov shranjenih. Naivno smo postavili `return` v zanko in pričakovali, da se bo izvedel večkrat ... Python pa bo že nekaj naredil s temi več rezultati. No, ne bo.\n",
    "\n",
    "Trije nauki.\n",
    "\n",
    "1. Ko se Python naleti na `return`, se izvajanje funkcije konča. Funkcija vrne vrednost, ki sledi `return` in to je to. Če je `return` v zanki, bo zanke pač konec.\n",
    "2. Tako kot smo ob sestavljanju slovarja sklenili, da bomo poprej razmislili, kaj bodo njegovi ključi in njegove vrednosti, moramo tudi ob sestavljanju funkcije pomisliti, kaj (na primer: kakšnega tipa) bodo njeni argumenti in njen rezultat. Tu nismo.\n",
    "3. Funkcija lahko vrača tudi druge stvari, recimo sezname.\n",
    "\n",
    "Tretji nauk še ni naučen, zato le hitro popravimo funkcijo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "82558f82",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dragoceni(s):\n",
    "    dragi = []\n",
    "    for k, v in s:\n",
    "        if v > 70:\n",
    "            dragi.append(k)\n",
    "    return dragi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "697ef792",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Meldrumove vaze', 'skodelice', 'kip']\n"
     ]
    }
   ],
   "source": [
    "predmeti = dragoceni(cene.items())\n",
    "\n",
    "print(predmeti)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4665d77c",
   "metadata": {},
   "source": [
    "Napišimo še eno podobno funkcijo s podobnim naukom: funkcijo `obstajajo_dragoceni`, ki vrne `True`, če obstaja kak dragocen predmet in `False`, če ne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "335e57b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def obstajajo_dragoceni(s):\n",
    "    dragi = []\n",
    "    for k, v in s:\n",
    "        if v > 70:\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ddf5860",
   "metadata": {},
   "source": [
    "Razumemo? Ta funkcija ima dva `return`-a. Kot smo uvideli, se lahko zgodi le eden - pač tisti, na katerega naletimo prej. Za vsak predmet preverimo, ali je dragocen. Če je, vrnemo `True`. Kdaj pa bomo vrnili `False`? Po koncu zanke - če se je ta iztekla, ne da bi jo prekinil kak `return True`. Če torej ni bilo nobenega dragocenega predmeta."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "099bfd6d",
   "metadata": {},
   "source": [
    "## Funkcije se kličejo med sabo\n",
    "\n",
    "V programih, ki smo jih pisali doslej, smo klicali različne Pythonove funkcije. Tudi v svojih funkcijah jih lahko. V gornjih primerih tega sicer ni bilo veliko, klicali smo le `append`, a najbrž ne bi nihče dvignil obrvi, če bi poklicali tudi kakšen `len` ali `print` ali karkoli drugega. Kaj pa naše funkcije? Lahko v svojih funkcijah kličemo svoje funkcije? Najsevedajše da. Večje programe gradimo kot skladovnice lastnih funkcij; preprostejše funkcije kombiniramo v vedno zapletenejše, nivoje in nivoje visoko. Pri tem predmetu česa prav zapletenega ne bo, preprost primer pa lahko vidimo že tu: funkcija `dragoceni` je splošnejša od funkcije `obstajajo_dragoceni`. Prva vrne seznam dragocenih predmetov, druga pa pove le, ali dragoceni predmeti obstajajo. Druga funkcija bi lahko preprosto poklicala prvo in preverila, ali le-ta vrne prazen seznam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "869a89bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def obstajajo_dragoceni(s):\n",
    "    # Ne programirajte tako!!!\n",
    "    if dragoceni(s) != []:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea4c5d0",
   "metadata": {},
   "source": [
    "Današnji primeri so res bogati. Vsak kaže par stvari. Tale vsaj dve. Uh, tri. Inkvizicija.\n",
    "\n",
    "1. Programiranje si boste olajšali, če boste razmišljali o tem, kaj že imate in to uporabljali. Še več; včasih boste napisali dve podobni funkciji in če boste pametni, boste tisto, kar jima je skupno, izločili v tretjo funkcijo. Tako boste lahko onidve funkciji skrajšali tako, da boste poklicali, kar je skupnega.\n",
    "2. Svarilo: funkcija `obstajajo_dragoceni` je s tem postala počasnejša! Prej je zanka `for` tekla do prvega dragocenega predmeta in se tam končala, prekinil jo je `return`. Zdaj `obstajajo_dragoceni` sicer ne vsebuje nobene zanke, vendar sproži zanko v `dragoceni`, ta pa vedno teče do konca, pa še predmete zlaga v nek seznam, ki ga potem zavržemo, saj nas zanima le, ali je prazen ali ne. Nas to boli? Odvisno od situacije. Če takole, za lastne potrebe analiziramo neke kratke datoteke, ni problema. Če bi bili podatki ogromni in če bi funkcijo, kot je `obstajajo_dragoceni` klicali velikokrat, pa bi jo raje pustili takšno, kot je bila.\n",
    "3. Tako se ne programira!\n",
    "\n",
    "Nadaljujmo s tretjo točko. `dragoceni(s) != []` je logični izraz, katerega rezultat je **že** `True` ali `False`. Funkcija bi se pravilneje (ne v smislu tega, da vrača pravilen rezultat, temveč v smislu, uh, smiselnosti) glasila"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a1d955ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def obstajajo_dragoceni(s):\n",
    "    return dragoceni(s) != []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "375a3665",
   "metadata": {},
   "source": [
    "Nauk 4: funkcije so lahko tudi zelo kratke. V življenju sem napisal že veliko funkcij, dolgih eno samo vrstico. Mogoče malenkost daljših in bolj zapletenih, vendar - funkcije, dolge eno samo vrstico, niso nič izjemnega. V nekaterih jezikih pa se daljših pravzaprav (v nekem smislu) niti ne da pisati."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45bbf0f1",
   "metadata": {},
   "source": [
    "## Več argumentov\n",
    "\n",
    "Gornje funkcije ne upoštevajo inflacije. Danes je 80 veliko, jutri pa ne boste mogli v Hofer ali Lidl, ne da bi tam pustili vsaj toliko. (Za arhiv: tole pišem 7. novembra 2023. Bomo videli, kako se bo staralo.)\n",
    "\n",
    "Napišimo boljši funkciji `dragoceni` in `obstajajo_dragoceni`: poleg seznama naj prejmeta še mejo \"dragocenosti\". Če bomo poklicali `dragoceni(cene.items(), 70)` bomo dobili enak rezultat kot zdaj, če `dragoceni(cene.items(), 100)` pa samo še kip."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0afbafe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dragoceni(s, meja):\n",
    "    dragi = []\n",
    "    for k, v in s:\n",
    "        if v > meja:\n",
    "            dragi.append(k)\n",
    "    return dragi\n",
    "\n",
    "\n",
    "def obstajajo_dragoceni(s, meja):\n",
    "    return dragoceni(s, meja) != []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a303de09",
   "metadata": {},
   "source": [
    "## Argumenti s privzetimi vrednostmi\n",
    "\n",
    "Mimogrede se naučimo še to: pogosto pišemo funkcije, ki \"skoraj ne potrebujejo\" nekega argumenta. Recimo, da bi funkcijo, kot je `dragoceni`, klicali na sto mestih v programu in meja bi bila praktično vedno `70`, le v parih primerih pa kaj drugega. V tem primeru bi argumentu `meja` nastavili prizveto vrednost na `70`. Argument bi s tem postal *opcijski* - lahko ga podamo ali pa tudi ne. Če ga izpustimo, bi imel vrednost 70.\n",
    "\n",
    "To je preprosto narediti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "4de217ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dragoceni(s, meja=70):\n",
    "    dragi = []\n",
    "    for k, v in s:\n",
    "        if v > meja:\n",
    "            dragi.append(k)\n",
    "    return dragi\n",
    "\n",
    "\n",
    "def obstajajo_dragoceni(s, meja=70):\n",
    "    return dragoceni(s, meja) != []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3d6d475c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['kip']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dragoceni(cene.items(), 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2c5e5706",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Meldrumove vaze', 'skodelice', 'kip']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dragoceni(cene.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1488a05f",
   "metadata": {},
   "source": [
    "## Več rezultatov ... in nič rezultatov\n",
    "\n",
    "Kaj se zgodi, če funkcija nima ukaza `return` (ali pa ga ima, vendar med izvajanjem funkcije nikoli ni prišlo do njega, ker je bil, recimo, skrit znotraj nekega `if`, čigar pogoj nikoli ni bil resničen), že vemo. Funkcija v tem primeru vrne `None`.\n",
    "\n",
    "Funkcije vedno vrnejo natančno eno stvar. Ne nič, ne dve, ne pet. Eno.\n",
    "\n",
    "To je slabo. Ampak ne preveč, saj se lahko na to pravilo preprosto požvižgamo. Kot prvo: če ne vrnemo ničesar, funkcija vrne `None`. S tem sicer vrne (natančno) eno stvar, vendar nas to nič ne boli. Naj jo.\n",
    "\n",
    "Enako se požvižgamo na pravilo, da sme funkcija vrniti le eno stvar in jih mirno vrnemo več."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "06906070",
   "metadata": {},
   "outputs": [],
   "source": [
    "def argminmax(s):\n",
    "    min_k = min_v = None\n",
    "    max_k = max_v = None\n",
    "\n",
    "    for k, v in s:\n",
    "        if min_v == None or v < min_v:\n",
    "            min_v = v\n",
    "            min_k = k\n",
    "        if max_v == None or v > max_v:\n",
    "            max_v = v\n",
    "            max_k = k\n",
    "    return min_k, max_k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "05983795",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "čajnik\n",
      "kip\n"
     ]
    }
   ],
   "source": [
    "najm, najv = argminmax(cene.items())\n",
    "\n",
    "print(najm)\n",
    "print(najv)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79d9a7e4",
   "metadata": {},
   "source": [
    "Razumemo, kaj se dogaja?\n",
    "\n",
    "`min_k, max_k` je v resnici terka."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0690e82a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('čajnik', 'kip')"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "argminmax(cene.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c990b5bf",
   "metadata": {},
   "source": [
    "Ko smo spoznali terke, smo omenili, da jih smemo pisati brez oklepajev, vendar to počnemo v redkih primerih. Tu je primer, ko terke *vedno* pišemo brez oklepajev. (To je spet nepisano pravilo: lahko bi dodali tudi oklepaja). Delamo se (predstavljamo si), da je `return` vrnil dve stvari (čeprav je v resnici eno, namreč terko z dvema elementoma). Ob klicu funkcije rezultat takoj razpakiramo.\n",
    "\n",
    "Pa imamo: funkcije, ki navidez vračajo več vrednosti. Ta konkretno, dve.\n",
    "\n",
    "Zato se lahko na pravilo, da funkcije vedno vračajo natančno eno stvar, preprosto požvižgamo. Navidez vračajo tudi nobene ali več. Da je v resnici le ena, nihče ne bo opazil."
   ]
  }
 ],
 "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
}