p1/kratki zapiski/06 slovarji in množice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slovar\n",
    "\n",
    "Vsak normalen jezik ima poleg tabel (seznamov v Pythonu) tudi neko obliko asociativnih tabel. Iz drugih jezikov to poznate kot `HashMap` (Java), `object` in `Map` (javascript), `array` (php), `stl::unordered_map` (C++), `Dictionary` (C#), `Map` (Kotlin).\n",
    "\n",
    "Ob predpostavki, torej, da to že poznate, le na hitro povejmo: do elementov dostopamo s celoštevilskimi indeksi, do elementov slovarjev s ključi. Dostopanje do elementov slovarja (vključno z vstavljanjem in brisanjem) je zelo hitro in je neodvisno od velikosti slovarja. Slovar z milijon elementi je enako hiter kot tak s tremi.\n",
    "\n",
    "Ključi slovarja so lahko nespremenljivi objekti: števila, nizi, terke in `None`, `True`, `False`. Poleg njih pa še poljubni drugi objekti, ki imajo definirano metodo `__hash__`. Vsak ključ se lahko seveda pojavi le enkrat.\n",
    "\n",
    "Vrednosti so lahko seveda karkoli.\n",
    "\n",
    "Slovarje zapisujemo z zavitimi oklepaji, ključ in vrednost ločimo z dvopičjem."
   ]
  },
  {
   "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": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'041 310239'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke[\"Ana\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slovarji *načelno* ne poznajo vrstnega reda. Od Pythona 3.6 naprej so elementi sicer urejeni po vrstnem redu dodajanja, vendar to opazimo zgolj pri izpisovanju in prehodu z zankami. Vseeno pa slovarji nimajo metod kot sta `append` in `insert` in rezin."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elemente dodajamo s prirejanjem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "stevilke[\"Iva\"] = \"040 222333\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operator `in` preveri, ali v slovarju obstaja določen ključ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Cilka\" in stevilke"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Po vrednostih ne moremo iskati - vsaj ne z `in`.\n",
    "\n",
    "Elemente brišemo, tako kot v seznamih, z operatorjem `del`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "del stevilke[\"Cilka\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če gremo prek slovarjev z zanko `for`, dobimo vrednosti ključev."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": 7,
   "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()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 9,
   "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": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke2 = stevilke.copy()\n",
    "stevilke2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 10,
     "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": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'051 123123'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke.get(\"Ema\", \"ni številke\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ni številke'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilke.get(\"Greta\", \"ni številke\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še enkrat: **ne pišite `stevilke.get(\"Ema\")`, kadar bi zadoščalo `stevilka[\"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": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 13,
     "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": 14,
   "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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 15,
     "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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 16,
     "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 v naslednji teden, 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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 17,
     "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",
    "Na teh, dodatnih predavanjih smo že nekajkrat uporabili `defaultdict`. Recimo, da imamo seznam Benjaminovih klicev in nas zanima, kolikokrat je poklical koga."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Cilka': 5, 'Dani': 11, 'Berta': 9, 'Ana': 5}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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']\n",
    "\n",
    "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, si pomagamo z `defaultdict` iz modula `collections`. Ta se obnaša tako kot slovar, le da si vsakič, ko zahtevamo kak element, ki ne obstaja, vrne privzeto vrednost zanj. To vrednost dobi tako, da pokliče funkcijo, ki jo podamo kot argument `defaultdict`-u.\n",
    "\n",
    "Zelo pogosto bo privzeta vrednost 0 ali pa prazen seznam, zato `defaultdictu` kot argument pogosto podamo `int` ali `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int, {'Cilka': 5, 'Dani': 11, 'Berta': 9, 'Ana': 5})"
      ]
     },
     "execution_count": 19,
     "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": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'Cilka': 5, 'Dani': 11, 'Berta': 9, 'Ana': 5})"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevilo_klicev = collections.Counter(klici)\n",
    "stevilo_klicev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kot argument mu podamo karkoli, čez kar se da iti z zanko `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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": 21,
     "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": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1793"
      ]
     },
     "execution_count": 22,
     "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 kot seznami, ki lahko vsebujejo vsak element samo enkrat. Po izvedbi pa so bolj podobne slovarjem: vanje lahko shranjujemo samo nespremenljive tipe, čas, potreben za dodajanje, brisanje in preverjanje, ali množica vsebuje določen element, pa je neodvisen od velikosti množice.\n",
    "\n",
    "Množice zapišemo z zavitimi oklepaji, tako kot smo vajeni pri matematiki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "danasnji_klici = {\"Ana\", \"Cilka\", \"Eva\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prazne množice pa ne sestavimo z `{}`, ker bi bil to slovar. Za prazno množico pokličemo konstruktor, `set()`. (Čemu tako? Slovar je bil prej, množice je Python dobil kasneje. Zato. Poleg tega pa slovarje potrebujemo večkrat kot mmnožice).\n",
    "\n",
    "Konstruktorju `set` lahko sicer podamo poljubno stvar, čez katero lahko gremo z zanko `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 6, 42}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([6, 42, 1, 3, 1, 1, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'B', 'a', 'e', 'i', 'j', 'm', 'n'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(\"Benjamin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana', 'Berta', 'Dani', 'Ema', 'Fanči', 'Helga', 'Iva'}"
      ]
     },
     "execution_count": 28,
     "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": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set(\"Benjamin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"e\" in s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'B', 'a', 'e', 'i', 'j', 'm', 'n'}"
      ]
     },
     "execution_count": 31,
     "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 ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = {1, 2, 3}\n",
    "v = {3, 4, 5}\n",
    "u | v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u & v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = {1, 2, 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3, 4} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3} <= u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 38,
     "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
}