p1/predavanja/06 slovarji in množice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slovar\n",
    "\n",
    "Poglejmo še enkrat sezname. Seznam je nekakšna zbirka nekih poljubnih reči, pri čemer je vsaka reč v svojem \"predalčku\", predalčki pa so oštevilčeni. Prvi ima številko 0, drugi 1, tretji 2 in tako naprej. Za vsak predalček lahko pogledamo, kaj je v njem, spremenimo njegovo vsebino, predalčke lahko odvzemamo in dodajamo.\n",
    "\n",
    "```python\n",
    ">>> s = [6, 9, 4, 1]\n",
    ">>> s[1]\n",
    "9\n",
    ">>> s.append(7)\n",
    ">>> s\n",
    "[6, 9, 4, 1, 7]\n",
    ">>> del s[3]\n",
    ">>> s\n",
    "[6, 9, 4, 7]\n",
    ">>> s[-2:]\n",
    "[4, 7]\n",
    "```\n",
    "\n",
    "Slovar (angl. *dictionary*, podatkovni tip pa se imenuje `dict`) je podoben seznamu, le da se na predalčke sklicujemo z njihovimi *ključi* (angl. *key*, ki so lahko števila, lahko pa tudi nizi, logične vrednosti, terke\\... Temu, kar je shranjeno v predalčku bomo rekli *vrednost* (*value*).\n",
    "\n",
    "Seznam in slovar se že od daleč (če niste kratkovidni) razlikujeta po oglatosti. Seznam smo opisali tako, da smo v *oglatih oklepajih* našteli njihove *elemente*. Slovar opišemo tako, da v *zavitih oklepajih* naštejemo pare *ključ: vrednost*.\n",
    "\n",
    "Stalno omenjani Benjamin si lahko takole sestavi slovar s telefonskimi številkami svojih oboževalk:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "stevilke = {\"Ana\": \"041 310239\", \"Berta\": \"040 318319\", \"Cilka\": \"041 103194\", \"Dani\": \"040 193831\",\n",
    "            \"Ema\": \"051 123123\", \"Fanči\": \"040 135367\", \"Helga\": \"+49 175 4728 475\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do vrednosti, shranjenih v slovarju, pride podobno kot do vrednosti v\n",
    "seznamu: z indeksiranjem, le da v oglate oklepaje ne napiše zaporedne\n",
    "številke, temveč ključ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "stevilke[\"Ana\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "stevilke[\"Dani\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slovarji ne poznajo vrstnega reda. V slovarju ni prvega, drugega,\n",
    "tretjega elementa, saj ključi niso nujno primerljivi - v istem slovarju se lahko kot ključi pojavljajo števila in nizi (kar sicer ni dobra ideja), zdaj pa uredite to, če morete. Vsaj v splošnem se to ne da. Od različice 3.5 si Python neuradno (bolj \"slučajno\") zapomni vrstni red dodajanja, od 3.7 pa je to del standarda jezika. Ker ni vrstnega reda, tudi ni rezin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'slice'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-ee2b86ca837c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstevilke\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"Ana\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\"Cilka\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'slice'"
     ]
    }
   ],
   "source": [
    "stevilke[\"Ana\":\"Cilka\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tole sporočilo o napaki je sicer zelo čudno, vendar povsem smiselno. Boste razumeli, ko boste veliki. ;)\n",
    "\n",
    "O \"mehaniki\" slovarjev morate vedeti le tole: slovarji so hitri, saj elementov v resnici ne iščejo. Na nek za zdaj skrivnosten način \"vedo\", kje je vrednost, ki pripada danemu ključu. Ne da bi iskali, vedo, kam morajo pogledati. Tudi dodajanje novih elementov v slovar je zelo hitro, enako tudi brisanje. Cena, ki jo plačamo za to, je dvojna. Ključi so lahko le podatkovni tipi, ki so nespremenljivi. Nespremenljivi podatkovni tipi so, vemo, nizi, števila, logične vrednosti in terke. Zgoraj smo kot ključ uporabili niz. To je OK. Če bi poskušali kot ključ uporabiti seznam, ne bi šlo. (V resnici je stvar malenkost bolj zapletena, ključ je lahko vsak podatkovni tip, ki je \"razpršljiv\", vendar to ni za bruce). Omejitve veljajo le za ključe. Vrednost je lahko karkoli.\n",
    "\n",
    "Drugi obrok cene, ki jo plačamo za učinkovitost slovarjev, je poraba pomnilnika: slovar porabi nekako dvakrat več pomnilnika kot seznam. Koliko, točno, več, je odvisno od velikost slovarja in tega, kaj shranjujemo. Pri tem predmetu se s pomnilnikom ne obremenjujte.\n",
    "\n",
    "Aha, še tretji obrok cene, iz drobnega tiska: vsak ključ se lahko pojavi največ enkrat. Če poskušamo prirediti neko vrednost ključu, ki že obstaja, le povozimo staro vrednost. Ampak to je tako ali tako pričakovati. Tudi v seznamu nimamo nikoli dveh različnih elementov na istem mestu.\n",
    "\n",
    "#### Kaj lahko počnemo s slovarji?\n",
    "\n",
    "Lahko jim dodajamo nove elemente: preprosto priredimo jim nov element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana': '041 310239',\n",
       " 'Berta': '040 318319',\n",
       " 'Cilka': '041 103194',\n",
       " 'Dani': '040 193831',\n",
       " 'Ema': '051 123123',\n",
       " 'Fanči': '040 135367',\n",
       " 'Helga': '+49 175 4728 475',\n",
       " 'Iva': '040 222333'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke[\"Iva\"] = \"040 222333\"\n",
    "\n",
    "stevilke"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`append` ne obstaja, saj nima smisla: ker ni vrstnega reda, ne moremo\n",
    "dodajati na konec. Sploh pa moramo tako ali tako povedati ključ, zato dodajamo, kot smo videli v gornjem primeru in `append` niti ni potreben. Prav tako (ali pa še bolj) ne obstaja `insert`, saj prav tako (ali pa še bolj) nima smisla.\n",
    "\n",
    "Vprašamo se lahko, ali v slovarju obstaja določen ključ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Cilka\" in stevilke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Jana\" in stevilke"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če se Cilka skrega z Benjaminom, jo lahko ta pobriše (mislim, pobriše njeno številko)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana': '041 310239',\n",
       " 'Berta': '040 318319',\n",
       " 'Dani': '040 193831',\n",
       " 'Ema': '051 123123',\n",
       " 'Fanči': '040 135367',\n",
       " 'Helga': '+49 175 4728 475',\n",
       " 'Iva': '040 222333'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del stevilke[\"Cilka\"]\n",
    "\n",
    "stevilke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Cilka\" in stevilke\n",
    "False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če gremo prek slovarjev z zanko `for`, dobimo vrednosti ključev."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana\n",
      "Berta\n",
      "Dani\n",
      "Ema\n",
      "Fanči\n",
      "Helga\n",
      "Iva\n"
     ]
    }
   ],
   "source": [
    "for ime in stevilke:\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seveda lahko ob vsakem imenu izpišemo tudi številko."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana: 041 310239\n",
      "Berta: 040 318319\n",
      "Dani: 040 193831\n",
      "Ema: 051 123123\n",
      "Fanči: 040 135367\n",
      "Helga: +49 175 4728 475\n",
      "Iva: 040 222333\n"
     ]
    }
   ],
   "source": [
    "for ime in stevilke:\n",
    "    print(ime + \":\", stevilke[ime])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vendar to ni najbolj praktično. Pomagamo si lahko s tremi metodami slovarja, ki vrnejo vse ključe, vse vrednosti in vse pare ključ-vrednost. Imenujejo se (ne preveč presenetljivo) `keys()`, `values()` in `items()`. Delamo se lahko, da vračajo sezname ključev, vrednosti oziroma parov \\... čeprav v resnici vračajo le nekaj, prek česar lahko gremo z zanko `for`. (Ja, podobna finta kot `range` in `enumerate` in `zip`. Vse to bo postalo jasneje prihodnji teden.)\n",
    "\n",
    "Najprej poglejmo `items()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana: 041 310239\n",
      "Berta: 040 318319\n",
      "Dani: 040 193831\n",
      "Ema: 051 123123\n",
      "Fanči: 040 135367\n",
      "Helga: +49 175 4728 475\n",
      "Iva: 040 222333\n"
     ]
    }
   ],
   "source": [
    "for ime, stevilka in stevilke.items():\n",
    "    print(ime + \":\", stevilka)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tako kot sem ob zanki `for` težil, da ne uporabljajte `for i in range(len(s))` temveč `for e in s` in da že v glavi zanke razpakirajte terko, kadar je to potrebno, bom težil tudi tule: uporabljajte `items` in vaši programi bodo takoj preglednejši in s tem pravilnejši.\n",
    "\n",
    "Metoda `values` vrne vse vrednosti, ki so v slovarju. V našem primeru torej telefonske številke. Metodo `values` človek včasih potrebuje, prav pogosto pa ne.\n",
    "\n",
    "V nasprotju s tem metodo `keys` potrebujejo samo študenti. Ne vem točno, zakaj sploh obstaja. No, vem, zato da študenti lahko pišejo `for ime in stevilke.keys()` namesto `for ime in stevilke`. Druge uporabne vrednosti pa ne vidim. :)\n",
    "\n",
    "Skratka: ne uporabljajte metode `keys`.\n",
    "\n",
    "Slovar ima še dve metodi, ki smo ju videli tudi pri seznamu: metodo, ki sprazni slovar in drugo, ki naredi nov, enak slovar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana': '041 310239',\n",
       " 'Berta': '040 318319',\n",
       " 'Dani': '040 193831',\n",
       " 'Ema': '051 123123',\n",
       " 'Fanči': '040 135367',\n",
       " 'Helga': '+49 175 4728 475',\n",
       " 'Iva': '040 222333'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke2 = stevilke.copy()\n",
    "stevilke2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke2.clear()\n",
    "stevilke2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Omenimo le še eno od slovarjevih metod, `get`. Ta dela podobno kot indeksiranje, `stevilke.get(\"Ana\")` naredi isto kot `stevilke[\"Ana\"]`. Metodo `get` uporabimo, kadar želimo v primeru, da ključa morda ni v slovarju, dobiti neko privzeto vrednost. Le-to podamo kot drugi argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'051 123123'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke.get(\"Ema\", \"ni številke\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ni številke'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke.get(\"Greta\", \"ni številke\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še enkrat: ne pišite `stevilke.get(\"Ema\")`. To je čudno. Piše se `stevilke[\"Ema\"]`. Metodo `get` uporabite le takrat, kadar niste prepričani, ali slovar vsebuje ta ključ, in bi radi podali privzeto vrednost.\n",
    "\n",
    "#### Primer: kronogrami\n",
    "\n",
    "Neka stara domača naloga je šla takole.\n",
    "\n",
    "Veliko latinskih napisov, ki obeležujejo kak pomemben dogodek, je napisanih v obliki [kronograma](http://en.wikipedia.org/wiki/Chronogram): če seštejemo vrednosti črk, ki predstavljajo tudi rimske številke (I=1, V=5, X=10, L=50, C=100, D=500, M=1000), dajo letnico dogodka.\n",
    "\n",
    "Tako, recimo, napis na cerkvi sv. Jakoba v Opatiji, CVIVS IN HOC RENOVATA LOCO PIA FVLGET IMAGO SIS CVSTOS POPVLI SANCTE IACOBE TVI, da vsoto 1793, ko je bila cerkev prenovljena (o čemer govori napis).\n",
    "\n",
    "Pri tem obravnavamo vsak znak posebej: v besedil EXCELSIS bi prebrali X + C + L + I = 10 + 100 + 50 + 1 = 161 in ne XC + L + I = 90 + 50 + 1 = 141.\n",
    "\n",
    "Napiši program, ki izračuna letnico za podani niz.\n",
    "\n",
    "Očitna rešitev je:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kronogram(s):\n",
    "    v = 0\n",
    "    for c in s:\n",
    "        if c==\"I\":\n",
    "            v += 1\n",
    "        elif c==\"V\":\n",
    "            v += 5\n",
    "        elif c==\"X\":\n",
    "            v += 10\n",
    "        elif c==\"L\":\n",
    "            v += 50\n",
    "        elif c==\"C\":\n",
    "            v += 100\n",
    "        elif c==\"D\":\n",
    "            v += 500\n",
    "        elif c==\"M\":\n",
    "            v += 1000\n",
    "    return v\n",
    "\n",
    "napis = \"CVIVS IN HOC RENOVATA LOCO PIA FVLGET IMAGO SIS CVSTOS POPVLI SANCTE IACOBE TVI\"\n",
    "kronogram(napis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pri njej vsi, ki poznajo stavek `switch` oz. `case` postokajo, kako je možno, da Python tega stavka nima. Ne, nima ga, ker ga skoraj nikoli ne potrebujemo, vsaj ne v takšni obliki, kot ste ga navajeni iz C-ju podobnih jezikov. Tisto, kar delamo z njim, pogosto rešimo (tudi) s slovarji.\n",
    "\n",
    "V slovar si bomo zapisali, katero številko pomeni katera črka."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "stevke = {\"I\": 1, \"V\": 5, \"X\": 10, \"L\": 50, \"C\": 100, \"D\": 500, \"M\": 1000}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcija zdaj deluje tako, da gre prek niza in za vsako črko preveri, ali je v slovarju. Če je ni, ne pomeni številke; če je, prištejemo toliko, kolikor je vredna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kronogram(s):\n",
    "    v = 0\n",
    "    for c in s:\n",
    "        if c in stevke:\n",
    "            v += stevke[c]\n",
    "    return v\n",
    "\n",
    "kronogram(napis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še hitreje gre z `get`; če črke ni, je njena privzeta vrednost 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kronogram(s):\n",
    "    v = 0\n",
    "    for c in s:\n",
    "        v += stevke.get(c, 0)\n",
    "    return v\n",
    "\n",
    "kronogram(napis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ob tem si ne moremo kaj, da ne bi poškilili za en teden naprej, ko se bomo učili bolj funkcijskega sloga programiranja in znali biti še krajši in jedrnatejši, spet predvsem po zaslugi slovarjev."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kronogram(s):\n",
    "    return sum(stevke.get(c, 0) for c in s)\n",
    "\n",
    "kronogram(napis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slovarji s privzetimi vrednostmi\n",
    "--------------------------------\n",
    "\n",
    "Slovarji so uporabne reči. V veliko primerih pa uporabimo neko različico slovarja, ki ima še en dodaten superpower.\n",
    "\n",
    "Denimo, da smo dobili v preskušanje igralno kocko, za katero nas zanima, ali goljufa. Stokrat smo jo vrgli in zabeležili rezultate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "meti = [4, 4, 4, 3, 2, 3, 5, 3, 3, 4, 6, 6, 6, 1, 3,\n",
    "        6, 6, 4, 1, 4, 6, 1, 4, 4, 4, 6, 4, 6, 5, 5, 6, 6, 2, 4, 4, 6,\n",
    "        3, 2, 6, 1, 3, 6, 3, 2, 6, 6, 4, 6, 4, 2, 4, 4, 1, 1, 6, 2, 6,\n",
    "        6, 4, 3, 4, 2, 6, 5, 6, 3, 2, 5, 1, 5, 3, 6, 4, 6, 2, 2, 4, 1,\n",
    "        4, 4, 3, 1, 4, 2, 1, 3, 1, 4, 6, 1, 1, 3, 4, 1, 4, 3, 2, 4, 6, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zanima nas, kolikokrat je padla katera številka. Nič lažjega. Najprej si pripravimo seznam s sedmimi ničlami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0, 0, 0]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kolikokrat = [0] * 7\n",
    "kolikokrat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj nam bo, recimo `kolikokrat[3]` povedal, kolikokrat je padla trojka. (Čemu sedem? Saj ima kocka samo šest ploskev. Boste videli. Finta.) Zdaj pa štejmo: pojdimo čez vse mete in povečujmo števce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 14, 12, 15, 27, 6, 26]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for met in meti:\n",
    "    kolikokrat[met] += 1\n",
    "\n",
    "kolikokrat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Kje je finta? `kolikokrat[0]` bo pove, kolikokrat je padla ničla. Nikoli pač. Napišite isto reč s seznamom dolžine šest, ne sedem. Ni problem, ampak tako, kot smo nardili je preprostejše.)\n",
    "\n",
    "(Kocka je res videti nekoliko sumljiva: štirke in šestice so nekam pogoste na račun petk. A pustimo statistikom vprašanje, ali je to še lahko naključno ali ne.)\n",
    "\n",
    "Ups, nalogo smo rešili kar s seznamom! Da, to gre, ker so \"predalčki\" seznama oštevilčeni, tako kot ploskve kocke. Tole pa ne bo šlo: tule je seznam telefonskih številk deklet, ki jih je danes klical Benjamin. Katero je poklical kolikokrat?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "klici = ['041 103194', '040 193831', '040 318319', '040 193831', '041 310239',\n",
    "        '040 318319', '040 318319', '040 318319', '040 193831', '040 193831',\n",
    "        '040 193831', '040 193831', '040 193831', '040 318319', '040 318319',\n",
    "        '040 318319', '040 193831', '040 318319', '041 103194', '041 103194',\n",
    "        '041 310239', '040 193831', '041 103194', '041 310239', '041 310239',\n",
    "        '040 193831', '041 310239', '041 103194', '040 193831', '040 318319']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za tako velike številke bi moral imeti seznam zelo veliko predalčkov. Še huje bi bilo, če bi namesto seznama številk dobili seznam klicanih oseb."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "klici = ['Cilka', 'Dani', 'Berta', 'Dani', 'Ana', 'Berta', 'Berta',\n",
    "         'Berta', 'Dani', 'Dani', 'Dani', 'Dani', 'Dani', 'Berta', 'Berta',\n",
    "         'Berta', 'Dani', 'Berta', 'Cilka', 'Cilka', 'Ana', 'Dani', 'Cilka',\n",
    "         'Ana', 'Ana', 'Dani', 'Ana', 'Cilka', 'Dani', 'Berta']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tu smo s seznamom pogoreli. No, ne čisto; rešitev s seznami seveda obstaja, je pa zoprna - podobna je tistemu, kar smo v začetku počeli z bančnimi računi.\n",
    "\n",
    "S slovarji je veliko lepše:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Cilka': 5, 'Dani': 11, 'Berta': 9, 'Ana': 5}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pogostosti = {}\n",
    "for ime in klici:\n",
    "    if ime not in pogostosti:\n",
    "        pogostosti[ime] = 0\n",
    "    pogostosti[ime] += 1\n",
    "\n",
    "pogostosti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ob vsakem novem klicu preverimo, ali je klicano `ime` že v slovarju. Če ga ni, da dodamo. Nato - najsibo ime novo ali ne - povečamo števec klicev pri tej osebi.\n",
    "\n",
    "Ker je ta stvar resnično pogosta, nam Python pomaga z modulom `collections`, ki vsebuje podatkovni tip `defaultdict`. (Modul, ki vsebuje podatkovni tip?! Da, da; tudi to je ena od stvari, ki jih bomo našli v modulih.) Ta se obnaša tako kot slovar, z eno izjemo: če zahtevamo kak element, ki ne obstaja, si ga meni nič tebi nič izmisli. Točneje, doda ga v slovar in mu postavi privzeto vrednost. Katero, določimo. Pri tem ne podamo privzete vrednosti, temveč \"funkcijo\", ki bo vračala privzeto vrednost. `defaultdict` bo ustvarjal te, nove vrednosti tako, da bo poklical to funkcijo brez argumentov in kot privzeto vrednost uporabil, kar vrne funkcija, ki jo v ta namen vsakič sproti pokliče.\n",
    "\n",
    "Zelo pogosto bo privzeta vrednost 0 in funkcija, ki vrača 0, se imenuje, hm, `int`.\n",
    "\n",
    "(\"Funkcija\" `int`, je vedno sumljivejša in sumljivejša. Že od začetka smo v zvezi z njo dajali besedo \"funkcija\" pod narekovaje, zdaj pa vidimo, da zmore vedno več in več stvari. Pa še enako ji je ime kot tipu in funkcij, ki jim je ime enako kot tipom, je vedno več. Kakšna skrivnost se skriva za tem? To boste izvedeli v enem od prihodnjih napetih nadaljevanj Programiranja 1.)\n",
    "\n",
    "Preštejmo torej še enkrat Benjaminove klice, tokrat s slovarjem s privzetimi vrednostmi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int, {'Cilka': 5, 'Dani': 11, 'Berta': 9, 'Ana': 5})"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import collections\n",
    "\n",
    "pogostosti = collections.defaultdict(int)\n",
    "for ime in klici:\n",
    "    pogostosti[ime] += 1\n",
    "    \n",
    "pogostosti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ni to kul?\n",
    "\n",
    "Poglejmo si nekaj, kar je kul še bolj.\n",
    "\n",
    "Števec\n",
    "------\n",
    "\n",
    "Preštevanje je tako pogosta reč, da obstaja zanj specializiran tip. Tako kot `defaultdict` je v modulu `collections`, imenuje pa se `Counter`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'Cilka': 5, 'Dani': 11, 'Berta': 9, 'Ana': 5})"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilo_klicev = collections.Counter(klici)\n",
    "stevilo_klicev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Komentirali ne bomo veliko, ker še ne znamo. Že ob tem, da sem temu rekel tip, sem se moral ugrizniti v jezik, saj bi raje govoril o razredu. Kaj je in kako deluje, pa nas še presega. Zna pa pravzaprav še veliko stvari, tako da tem, ki jih zanima, priporočam, da si ga ogledajo. Mimogrede:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'C': 6,\n",
       "         'V': 7,\n",
       "         'I': 8,\n",
       "         'S': 6,\n",
       "         ' ': 12,\n",
       "         'N': 3,\n",
       "         'H': 1,\n",
       "         'O': 8,\n",
       "         'R': 1,\n",
       "         'E': 4,\n",
       "         'A': 6,\n",
       "         'T': 5,\n",
       "         'L': 3,\n",
       "         'P': 3,\n",
       "         'F': 1,\n",
       "         'G': 2,\n",
       "         'M': 1,\n",
       "         'B': 1})"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "napis = \"CVIVS IN HOC RENOVATA LOCO PIA FVLGET IMAGO SIS\" \\\n",
    "        \"CVSTOS POPVLI SANCTE IACOBE TVI\"\n",
    "\n",
    "collections.Counter(napis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pravi, da lahko kronogram rešimo tudi z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kronogram(s):\n",
    "    crke = collections.Counter(s)\n",
    "    return crke[\"I\"] + 5 * crke[\"V\"] + 10 * crke[\"X\"] + 50 * crke[\"L\"] + \\\n",
    "           100 * crke[\"C\"] + 500 * crke[\"D\"] + 1000 * crke[\"M\"]\n",
    "\n",
    "kronogram(napis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Množice\n",
    "-------\n",
    "\n",
    "Množice so podobne seznamom, a s to razliko, da lahko vsebujejo vsak element samo enkrat. Po drugi strani (in ne le po drugi strani, tudi tehnično) pa so podobne slovarjem. Vsebujejo lahko le elemente, ki so nespremenljivi, poleg tega pa lahko zelo hitro ugotovimo, ali množica vsebuje določen element ali ne, na podoben način kot pri slovarjih hitro ugotovimo, ali vsebujejo določen ključ ali ne.\n",
    "\n",
    "Množice zapišemo z zavitimi oklepaji, tako kot smo vajeni pri matematiki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "danasnji_klici = {\"Ana\", \"Cilka\", \"Eva\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tako lahko sestavimo le neprazno množico. Če napišemo le oklepaj in zaklepaj, `{}`, pa dobimo slovar. (Čemu so se odločili, naj bo to slovar, ne množica? Slovar je bil prej, množice je Python dobil kasneje. Zato. Poleg tega pa slovarje potrebujemo res velikokrat, množice pa precej redkeje.) Če hočemo narediti prazno množico, rečemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "prazna = set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Funkcija\" `set` je malo podobna \"funkciji\" `int`: damo ji lahko različne argumente, pa jih bo spremenila v množico. Damo ji lahko, recimo, seznam, pa bomo dobili množico z vsemi elementi, ki se pojavijo v njem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 6, 42}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([6, 42, 1, 3, 1, 1, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poleg seznamov lahko množicam podtaknemo karkoli, prek česar bi lahko šli z zanko `for`, recimo niz ali slovar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'B', 'a', 'e', 'i', 'j', 'm', 'n'}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(\"Benjamin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana', 'Berta', 'Dani', 'Ema', 'Fanči', 'Helga', 'Iva'}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(stevilke)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spremenljivka `stevilke` (še vedno) vsebuje slovar, katerega ključi so imena Benjaminovih oboževalk. Ker zanka prek slovarja \"vrača\" ključe, bo tudi množica, ki jo sestavimo iz slovarja, vsebovala ključe.\n",
    "\n",
    "V množico lahko dodajamo elemente in vprašamo se lahko, ali množica vsebuje določen element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set(\"Benjamin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"e\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"u\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.add(\"u\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"u\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'B', 'a', 'e', 'i', 'j', 'm', 'n', 'u'}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.add(\"a\")\n",
    "s.add(\"a\")\n",
    "s.add(\"a\")\n",
    "s\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na koncu smo poskušali v množico dodati element, ki ga že vsebuje. To seveda ne gre, množica vsak element vsebuje le enkrat.\n",
    "\n",
    "Če imamo dve množici, lahko izračunamo njuno unijo, presek, razliko (elementi, ki se pojavijo v prvi, ne pa tudi v drugi množici) in simetrično razliko (elementi, ki se pojavijo v eni množici in v drugi) ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = {1, 2, 3}\n",
    "v = {3, 4, 5}\n",
    "u | v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u & v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u - v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 4, 5}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u ^ v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tako kot lahko pri številih uporabimo `+=` za prištevanje (in namesto `x = x + a` pišemo `x += a`), in, podobno, odštejemo, primnožimo in razdelimo z `-=`, `*=` in `/=`, lahko tudi priunijamo, odsekamo ali odštejemo množico z `&=`, `|=` in `-=`. Tako je, na primer `u &= v` isto kot `u = u & v`.\n",
    "\n",
    "Preverimo lahko tudi, ali je neka množica podmnožica (ali nadmnožica druge). To najpreprosteje storimo kar z operatorji za primerjanje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = {1, 2, 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3, 4} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} < u"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`{1, 2, 3}`, je podmnožica `u`-ja, ni pa njegove *prava podmnožica*, saj vsebuje kar cel `u`.\n",
    "\n",
    "Z množicami je mogoče početi še marsikaj zanimivega - vendar bodi dovolj."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}