pn/predavanja/03c Slovarji.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "27d59a9a",
   "metadata": {},
   "source": [
    "## Slovarji\n",
    "\n",
    "Vzemimo, spet, podatke o kolesarjenju, tiste, s štirimi stolpci. Za zdaj smo ugotovili le, kolikšni sta skupna prevožena razdalja in višina, podatek o kolesu pa kar zanemarili. Lahko bi izračunali, recimo, koliko je prevozil s Canyonom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "808959db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Voženj: 28\n",
      "Razdalja: 2932\n",
      "Višina: 25630\n"
     ]
    }
   ],
   "source": [
    "vozenj_canyon = 0\n",
    "razdalja_canyon = 0\n",
    "visina_canyon = 0\n",
    "\n",
    "for vrstica in open(\"kolesa.txt\"):\n",
    "    kolo, razdalja, visina = vrstica.split(\",\")\n",
    "    if kolo == \"Canyon\":\n",
    "        vozenj_canyon += 1\n",
    "        razdalja_canyon += int(razdalja)\n",
    "        visina_canyon += int(visina)\n",
    "    \n",
    "print(\"Voženj:\", vozenj_canyon)\n",
    "print(\"Razdalja:\", razdalja_canyon)\n",
    "print(\"Višina:\", visina_canyon)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac010781",
   "metadata": {},
   "source": [
    "Zdaj pa isto še za Cube, Nakamura in Stevens. Če damo to v isti program, bomo imeli štirikar po tri spremenljivke.\n",
    "\n",
    "Primeri pa se lahko še kaj hujšega: v družini nas je pet in imamo osem koles. (Štirje po enega in eden štiri.)\n",
    "\n",
    "Kako lepo bi bilo, če bi lahko imeli eno samo spremenljivko `vozenj`, ki bi imela \"predalčke\" Canyon, Cube, Nakamura in Stevens. In, seveda, spremenljivki `razdalja` in `visina`, vsako s štirimi predalčki.\n",
    "\n",
    "Očitno to obstaja, sicer si tega ne bi želel, ne? Takšnim spremenljivkam - točneje, taki vrsti spremenljivk rečemo slovar - po angleško *dictionary*, ime Pythonovega podatkovnega tipa pa je `dict`.\n",
    "\n",
    "Za začetek pripravimo nekaj preprostejšega: slovar z višinami hribov. Takšen bi bil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "224a73e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "hribi = {\"Triglav\": 2864, \"Storžič\": 2132, \"Grintovec\": 2558}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39fc60e2",
   "metadata": {},
   "source": [
    "Slovar hribi ima predalčke `\"Triglav\"`, `\"Storžič\"` in `\"Grintovec\"`, vrednosti, shranjene v teh predalčkih pa so 2864, 2132 in 2558. Kot vidimo, slovar pripravimo tako, da med zavite oklepaje zapišemo pare z imenom predalčka (ki mu učeno rečemo *ključ*, *key*) in pripadajočimi *vrednostmi* (*value*), ločimo pa jih z dvopičji.\n",
    "\n",
    "Python nam seveda lahko izpiše celotno vsebino slovarja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4641c176",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Triglav': 2864, 'Storžič': 2132, 'Grintavec': 2558}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hribi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc8e769",
   "metadata": {},
   "source": [
    "Do posameznih vrednosti v slovarju pridemo tako, da \"predalček\" podamo v oglatih oklepajih."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0d4b1ca5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2864"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hribi[\"Triglav\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f966be5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2132"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hribi[\"Storžič\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "466d17fa",
   "metadata": {},
   "source": [
    "Če kak ključ ne obstaja, Python to jasno pove."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e1235c28",
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'Stol'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m hribi[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mStol\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n",
      "\u001b[0;31mKeyError\u001b[0m: 'Stol'"
     ]
    }
   ],
   "source": [
    "hribi[\"Stol\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "543f0eed",
   "metadata": {},
   "source": [
    "Predalčki se vedejo kot spremenljivke. Triglavu lahko priredimo drugo višino"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8c2c8819",
   "metadata": {},
   "outputs": [],
   "source": [
    "hribi[\"Triglav\"] = 2800"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e374aafb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Triglav': 2800, 'Storžič': 2132, 'Grintavec': 2558}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hribi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ddceca5",
   "metadata": {},
   "source": [
    "Lahko mu tudi prištejemo (zdaj manjkajočih) 64 metrov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dfeccbd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "hribi[\"Triglav\"] += 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "593cb8d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Triglav': 2992, 'Storžič': 2132, 'Grintavec': 2558}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hribi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c1ef177",
   "metadata": {},
   "source": [
    "Skratka, kot katerakoli druga spremenljivka.\n",
    "\n",
    "Oboroženi z novim znanjem izračunajmo kolesarsko statistiko."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "746d751d",
   "metadata": {},
   "outputs": [],
   "source": [
    "vozenj = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "razdalje = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "visine = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "\n",
    "for vrstica in open(\"kolesa.txt\"):\n",
    "    kolo, razdalja, visina = vrstica.split(\",\")\n",
    "    vozenj[kolo] += 1\n",
    "    razdalje[kolo] += int(razdalja)\n",
    "    visine[kolo] += int(visina)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "053cd26f",
   "metadata": {},
   "source": [
    "Pa zdaj? No, to kar potrebujemo je v slovarjih."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7aacc2c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Canyon': 28, 'Cube': 43, 'Nakamura': 29, 'Stevens': 0}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vozenj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a5a96f4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Canyon': 2932, 'Cube': 2939, 'Nakamura': 488, 'Stevens': 0}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "razdalje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9a9fa993",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Canyon': 25630, 'Cube': 70947, 'Nakamura': 1499, 'Stevens': 0}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visine"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a694d59",
   "metadata": {},
   "source": [
    "Kaj pa, če bi radi to *lepo* izpisali? Recimo podatke *za vsako kolo*?\n",
    "\n",
    "Čim rečemo \"za vsako\" nas to spomni na ... zanko `for`. Zanko `for` smo doslej naganjali prek datotekm, ko smo morali ponoviti kos programa *za vsako vrstico datoteke*. Kaj se zgodi, če jo poskusimo spustiti čez slovar?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6ef6c42d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon\n",
      "Cube\n",
      "Nakamura\n",
      "Stevens\n"
     ]
    }
   ],
   "source": [
    "for bogvekajboto in vozenj:\n",
    "    print(bogvekajboto)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30adf501",
   "metadata": {},
   "source": [
    "Zanka `for` daje ključe slovarja. Prav, če imamo ključ, potem že znamo priti do vrednosti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "68388a4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon - 28 vozenj\n",
      "Cube - 43 vozenj\n",
      "Nakamura - 29 vozenj\n",
      "Stevens - 0 vozenj\n"
     ]
    }
   ],
   "source": [
    "for kolo in vozenj:\n",
    "    print(kolo, \"-\", vozenj[kolo], \"vozenj\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ba19aee",
   "metadata": {},
   "source": [
    "Ker imajo vsi trije slovarji tako ali tako iste ključe, lahko mimogrede izpišemo še skupno prevoženo višino in razdaljo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6c567f5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon - 26 vozenj, 2766 km, 26392 m.\n",
      "Cube - 43 vozenj, 3174 km, 66705 m.\n",
      "Nakamura - 22 vozenj, 439 km, 1119 m.\n",
      "Stevens - 9 vozenj, 607 km, 3395 m.\n"
     ]
    }
   ],
   "source": [
    "for kolo in vozenj:\n",
    "    print(kolo, \"-\", vozenj[kolo], \"vozenj,\", razdalje[kolo], \"km,\", visine[kolo], \"m.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27f819e9",
   "metadata": {},
   "source": [
    "Nadvse imenitno. No, kar imenitno. Nad vse(m) imenitno pa še ni, ker bo postalo še imenitnejše. :)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e59ac12a",
   "metadata": {},
   "source": [
    "## Dodajanje v slovar\n",
    "\n",
    "Program se začne z\n",
    "\n",
    "```\n",
    "vozenj = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "razdalje = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "visine = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "```\n",
    "\n",
    "Tule je videti nekaj prostora za izboljšave. Kot prvo: moramo res tipkati vsa ta imena koles in ničle? Ne bi šlo brez?\n",
    "\n",
    "Kot drugo: da to deluje, moramo vnaprej vedeti, katere znamke koles se bodo pojavile v datoteki. Kaj, če to ni vnaprej znano? Kako bi programirali v tem primeru?\n",
    "\n",
    "Naučiti se bomo morali tri stvari:\n",
    "\n",
    "1. ustvariti prazen slovar,\n",
    "2. preveriti, ali slovar ima določen predalček in\n",
    "3. v primeru, da ga nima, dodati nov predalček.\n",
    "\n",
    "Vse troje se bo izkazalo za čisto preprosto.\n",
    "\n",
    "Kako sestaviti prazen slovar, zlahka uganemo. Pač ničesar ne zapišemo med oklepaje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "17e21526",
   "metadata": {},
   "outputs": [],
   "source": [
    "vozenj = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6100b881",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vozenj"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbf20166",
   "metadata": {},
   "source": [
    "Kako preveriti, ali slovar vsebuje določen ključ? Besedo `in` smo doslej uporabljali v zanki `for`, ko smo pisali, recimo `for kolo in vozenj`. Lahko jo tudi v `if`, oziroma, brez `if`, v logičnem izrazu, kot operator. Operator `a in c` vrne `True`, če `c` vsebuje `a`.\n",
    "\n",
    "Še vedno imamo pri roki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c5c47221",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Canyon': 2766, 'Cube': 3174, 'Nakamura': 439, 'Stevens': 607}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "razdalje"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0de56f3a",
   "metadata": {},
   "source": [
    "Vidimo, da slovar vsebuje `\"Canyon\"`, ne pa `\"Focus\"`. Operator `in` se s tem videnjem strinja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2324c601",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Canyon\" in razdalje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4dbd0224",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Focus\" in razdalje"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f40c94d8",
   "metadata": {},
   "source": [
    "Odlično, znamo preveriti, ali predalček obstaja. Kljukica pod točko 2.\n",
    "\n",
    "Zdaj pa še dodajanje predalčka."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b7c4d41b",
   "metadata": {},
   "outputs": [],
   "source": [
    "razdalje[\"Focus\"] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f6d9f593",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Canyon': 2766, 'Cube': 3174, 'Nakamura': 439, 'Stevens': 607, 'Focus': 0}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "razdalje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6e5dbebb",
   "metadata": {},
   "outputs": [],
   "source": [
    "hribi[\"Šmarna gora\"] = 667"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "21ee7eed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Triglav': 2992, 'Storžič': 2132, 'Grintavec': 2558, 'Šmarna gora': 667}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hribi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6d3d697",
   "metadata": {},
   "source": [
    "Pa imamo boljši program za kolesarsko statistiko."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "6f16fe3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nakamura - 22 vozenj, 439 km, 1119 m.\n",
      "Cube - 43 vozenj, 3174 km, 66705 m.\n",
      "Canyon - 26 vozenj, 2766 km, 26392 m.\n",
      "Stevens - 9 vozenj, 607 km, 3395 m.\n"
     ]
    }
   ],
   "source": [
    "vozenj = {}\n",
    "razdalje = {}\n",
    "visine = {}\n",
    "\n",
    "for vrstica in open(\"kolesa.txt\"):\n",
    "    kolo, razdalja, visina = vrstica.split(\",\")\n",
    "    if not kolo in vozenj:\n",
    "        vozenj[kolo] = razdalje[kolo] = visine[kolo] = 0\n",
    "    vozenj[kolo] += 1\n",
    "    razdalje[kolo] += int(razdalja)\n",
    "    visine[kolo] += int(visina)\n",
    "    \n",
    "for kolo in vozenj:\n",
    "    print(kolo, \"-\", vozenj[kolo], \"vozenj,\", razdalje[kolo], \"km,\", visine[kolo], \"m.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d51c6a01",
   "metadata": {},
   "source": [
    "Ker vsi trije slovarji bodisi vsebujejo bodisi ne vsebujejo kolesa, preverjamo le, ali je kolo že v slovarju `vozenj`. Če ga ni tam, ga tudi v ostalih ni, torej ga dodamo v vse."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73d4f2e5",
   "metadata": {},
   "source": [
    "Ker se `not kolo in vozenj` bere čudno, obstaja poleg operatorja `in` tudi operator `not in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c1401893",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Scott\" not in vozenj "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9636fcab",
   "metadata": {},
   "source": [
    "## Slovarji - v splošnem\n",
    "\n",
    "Ključi gornjega slovarja (\"imena predalčkov\") so bili nizi, vrednosti pa števila, `int`. Slovarji niso omejeni zgolj na te tipe.\n",
    "\n",
    "Vrednosti so lahko karkoli: ne le `int` in `float`, temveč tudi nizi, logične vrednosti in vsi raznorazni tipi, ki jih bomo še spoznali pri predmetu. Slovar lahko vsebuje celo druge slovarje (uh, celo samega sebe!) kot vrednost.\n",
    "\n",
    "Ključi so bolj omejeni. Ključi morajo biti nespremenljivi. Za naše potrebe in naše dosedanje znanje: ključ je lahko karkoli razen slovarja. \"Prepovedanim\" tipom ključev se bosta kmalu pridružila še seznam in množica, drugih prepovedanih tipov ključev pa pri tem predmetu ne boste spoznali. Vsaj ne takšnih, ki bi vas jih zamikalo uporabiti kot ključ.\n",
    "\n",
    "Pri tem predmetu bodo ključi skoraj vedno nizi, včasih `int`-i in skoraj nikoli nič drugega.\n",
    "\n",
    "Isti slovar ima lahko različne tipe ključev. In različne tipe vrednosti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e89ea268",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana': 129415, 4: True, 3.14: {}}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\"Ana\": 129415, 4: True, 3.14: {}}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdbf10ae",
   "metadata": {},
   "source": [
    "Če se komu zdi to slaba ideja, bo to zato, ker je dejansko slaba. Navadno bodo vsi ključi nekega slovarja in vse vrednosti nekega slovarja enakega tipa. Sicer ... no, kaj pravzaprav shranjujemo v slovarju, če se v njem pojavlja tako raznovrstna šara?!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d632133",
   "metadata": {},
   "source": [
    "## Slovarji imajo tudi metode\n",
    "\n",
    "Vsaka stvar v Pythonu ima metode. Niz, kot smo rekli, ducate. Slovarji jih imajo malo manj, a vseeno jih ne bomo našteli vseh, saj si jih tako ali tako ne bi zapomnili. Bomo že sproti videli, kar bomo potrebovali. (Kdor je neučakan, pa lahko pogleda [dokumentacijo](https://docs.python.org/3/library/stdtypes.html#dict)).\n",
    "\n",
    "### Vrednosti\n",
    "\n",
    "Vzemimo slovar `visine`. Kakšna je skupna višina, ki jo je prevozil kolesar?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "3f91145a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nakamura': 1119, 'Cube': 66705, 'Canyon': 26392, 'Stevens': 3395}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "5c187b50",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97611"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1119 + 66705 + 26392 + 3395"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce9e22f7",
   "metadata": {},
   "source": [
    "Ne, nisem mislil tako. Ne bomo seštevali ročno. Kar program naj sešteje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "f216ad24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97611"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "skupna = 0\n",
    "for kolo in visine:\n",
    "    skupna += visine[kolo]\n",
    "    \n",
    "skupna"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40882bc7",
   "metadata": {},
   "source": [
    "Če razmislimo, nas ključi tu pravzaprav ne zanimajo. Zanimajo nas le vrednosti. Tule bi nam prišlo bolj prav, če bi šla zanka `for` prek vrednosti, ne prek ključev.\n",
    "\n",
    "Ni problema. Slovarji imajo metodo `values`, ki vrne vrednosti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "463fee03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1119\n",
      "66705\n",
      "26392\n",
      "3395\n"
     ]
    }
   ],
   "source": [
    "for visina in visine.values():\n",
    "    print(visina)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c59df1c5",
   "metadata": {},
   "source": [
    "In to seveda znamo sešteti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "07f52160",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97611"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "skupna = 0\n",
    "for visina in visine.values():\n",
    "    skupna += visina\n",
    "    \n",
    "skupna"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9261bd3a",
   "metadata": {},
   "source": [
    "Prej ko slej boste odkrili, da obstaja funkcija `sum`, ki lahko sešteje, kar ji podamo kot argument. Če ji podamo `visine.values()` bo seštela vse vrednosti v slovarju."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "d6b12547",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97611"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(visine.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecce7a22",
   "metadata": {},
   "source": [
    "Torej:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "aa910e2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Število voženj: 100\n",
      "Skupna razdalja: 6986\n",
      "Skupna višina: 97611\n"
     ]
    }
   ],
   "source": [
    "print(\"Število voženj:\", sum(vozenj.values()))\n",
    "print(\"Skupna razdalja:\", sum(razdalje.values()))\n",
    "print(\"Skupna višina:\", sum(visine.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7e32fce",
   "metadata": {},
   "source": [
    "### Privzete vrednosti\n",
    "\n",
    "Slovarji imajo metodo `setdefault(kljuc, vrednost)`, ki za podani ključ nastavi podano vrednost; če ključ že obstaja, pa ne stori ničesar. V vsakem primeru pa vrne vrednost, ki pripada temu ključu - bodisi obstoječo (in torej nespremenjeno) vrednost, bodisi pravkar nastavljeno novo vrednost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "90aa8ca5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nakamura': 22, 'Cube': 43, 'Canyon': 26, 'Stevens': 9}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vozenj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "aba6fe94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vozenj.setdefault(\"Scott\", 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "fddcf5f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nakamura': 22, 'Cube': 43, 'Canyon': 26, 'Stevens': 9, 'Scott': 0}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vozenj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "38643d60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vozenj.setdefault(\"Nakamura\", 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "030c87c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nakamura': 22, 'Cube': 43, 'Canyon': 26, 'Stevens': 9, 'Scott': 0}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vozenj"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b7c96ca",
   "metadata": {},
   "source": [
    "To poenostavi naše računanje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "63a1dea8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nakamura - 22 vozenj, 439 km, 1119 m.\n",
      "Cube - 43 vozenj, 3174 km, 66705 m.\n",
      "Canyon - 26 vozenj, 2766 km, 26392 m.\n",
      "Stevens - 9 vozenj, 607 km, 3395 m.\n"
     ]
    }
   ],
   "source": [
    "vozenj = {}\n",
    "razdalje = {}\n",
    "visine = {}\n",
    "\n",
    "for vrstica in open(\"kolesa.txt\"):\n",
    "    kolo, razdalja, visina = vrstica.split(\",\")\n",
    "    vozenj.setdefault(kolo, 0)\n",
    "    razdalje.setdefault(kolo, 0)\n",
    "    visine.setdefault(kolo, 0)\n",
    "    vozenj[kolo] += 1\n",
    "    razdalje[kolo] += int(razdalja)\n",
    "    visine[kolo] += int(visina)\n",
    "    \n",
    "for kolo in vozenj:\n",
    "    print(kolo, \"-\", vozenj[kolo], \"vozenj,\", razdalje[kolo], \"km,\", visine[kolo], \"m.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1411c552",
   "metadata": {},
   "source": [
    "Meh, ali pa tudi ne. Stavek `if` in malo prirejanja,\n",
    "\n",
    "```\n",
    "    if kolo not in vozenj:\n",
    "        vozenj[kolo] = razdalje[kolo] = visine[kolo] = 0\n",
    "```\n",
    "\n",
    "smo zamenjali s tremi vrsticami `setdefault`-ov. No, če bi imeli en sam slovar, pa je\n",
    "\n",
    "```\n",
    "    d.setdefault(x, 0)\n",
    "```\n",
    "\n",
    "gotovo krajše in preprostejše kot\n",
    "\n",
    "\n",
    "```\n",
    "    if x not in d:\n",
    "        d[x] = 0\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c946466",
   "metadata": {},
   "source": [
    "### Get\n",
    "\n",
    "Za metodo `get` vam moram povedati preprosto zato, ker je to ena od stvari, za katere je boljše, da o njej slišite od modrih, starejših ljudi, kot od vrstnikov.\n",
    "\n",
    "Metoda `get` vrne vrednost, ki pripada podanemu ključu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "ba9745fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Nakamura': 1119, 'Cube': 66705, 'Canyon': 26392, 'Stevens': 3395}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "e75e4170",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66705"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visine.get(\"Cube\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dba55c72",
   "metadata": {},
   "source": [
    "Ne počnite tega. V Pythonu se reče"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "36313316",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66705"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visine[\"Cube\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48ef7c31",
   "metadata": {},
   "source": [
    "V vaših programih bom sicer žalostno opazoval takšno uporabo `get`-a. Do nje bo mnogokrat prišlo, ker vam bodo pri reševanju nalog \"pomagali\" znanci, ki sicer programirajo v Javi ali podobno okornih jezikih, ki zaradi določenih omejitev ne morajo do vsebine slovarjev z oglatimi oklepaji.\n",
    "\n",
    "Zakaj Python potem sploh ima `get`, če naj bi ga ne uporabljali?\n",
    "\n",
    "Metodi `get` lahko podamo privzeto vrednost, ki naj jo vrne, če ključ ne obstaja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "270dfce9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66705"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visine.get(\"Cube\", 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "c1b522ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visine.get(\"Focus\", 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30281a2c",
   "metadata": {},
   "source": [
    "Zato in samo zato."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7bb42a1",
   "metadata": {},
   "source": [
    "### `items`\n",
    "\n",
    "Videli smo, da gre zanka `for`, ko jo spustimo čez slovar, prek njegovih ključev. Če jo naženemo prek tega, kar vrne `values`, bo šla prek vrednosti. Slovarji imajo še metodo `items`, ki vrača pare ključev in vrednosti.\n",
    "\n",
    "Vrnimo se malenkost nazaj. Spomnimo se, kako smo uporabljali rezultat `split`: ker je vračal več stvari, smo ga prirejali več spremenljivkam. Recimo, da imamo niz z dvema besedama, `\"Ana Benjamin\"` in ga razdelimo s `split`. Dobimo dve besedi, torej ju moramo shraniti v dve spremenljivki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "f8c0366f",
   "metadata": {},
   "outputs": [],
   "source": [
    "ona, on = \"Ana Benjamin\".split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "ffbfb7ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ona"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "4c601bc6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benjamin'"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "on"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7f77780",
   "metadata": {},
   "source": [
    "Če metoda `items` vrača pare, bo tudi zanka `for` potrebovala dve spremenljivki, da ga shrani."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "355f2906",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nakamura  -  1119\n",
      "Cube  -  66705\n",
      "Canyon  -  26392\n",
      "Stevens  -  3395\n"
     ]
    }
   ],
   "source": [
    "for kolo, visina in visine.items():\n",
    "    print(kolo, \" - \", visina)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37940212",
   "metadata": {},
   "source": [
    "Zdaj pa kar brž napišimo program, ki bo povedal, katero kolo se je največ vzpenjalo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "fc17df19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Največ se je vzpenjal Cube in sicer 66705 metrov.\n"
     ]
    }
   ],
   "source": [
    "naj_visina = 0\n",
    "\n",
    "for kolo, visina in visine.items():\n",
    "    if visina > naj_visina:\n",
    "        naj_visina = visina\n",
    "        naj_kolo = kolo\n",
    "        \n",
    "print(\"Največ se je vzpenjal\", naj_kolo, \"in sicer\", naj_visina, \"metrov.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "260622c2",
   "metadata": {},
   "source": [
    "### `keys`\n",
    "\n",
    "Tudi ta je iz poglavja \"boljše, da vam za to povem jaz\".\n",
    "\n",
    "`keys` vrne vse ključe slovarja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "03fadc49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nakamura\n",
      "Cube\n",
      "Canyon\n",
      "Stevens\n"
     ]
    }
   ],
   "source": [
    "for kolo in visine.keys():\n",
    "    print(kolo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb2a91be",
   "metadata": {},
   "source": [
    "To je seveda čisto drugače kot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "eed136ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nakamura\n",
      "Cube\n",
      "Canyon\n",
      "Stevens\n"
     ]
    }
   ],
   "source": [
    "for kolo in visine:\n",
    "    print(kolo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4baa64af",
   "metadata": {},
   "source": [
    "Aja, ni. Isto je.\n",
    "\n",
    "Glede metode `keys` bi vam rad povedal le to: pozabite, da obstaja.\n",
    "\n",
    "Prav, zakaj potem Python sploh ima to metodo?! Pojma nimam. Za hec sem vprašal za mnenje chatGPT. :) Takole me je podučil. (Kogar ne zanima krajši komentar chatGPTja, lahko z branjem tu zaključi.)\n",
    "\n",
    "In Python, dictionaries (`dict`) have a `keys()` method that returns a view object containing the keys of the dictionary. While it might seem redundant since you can iterate over the dictionary itself to access its keys, there are some important distinctions and use cases for using `dict.keys()`:\n",
    "\n",
    "1. **View Object**: `dict.keys()` returns a view object that is a dynamic view on the keys of the dictionary. This means that any changes made to the dictionary are immediately reflected in the view, and vice versa. This is not the case when you directly iterate over the dictionary.\n",
    "\n",
    "2. **Compatibility**: The `.keys()` method is available in Python 2 and Python 3, which makes it more backward-compatible for code that needs to run on both versions. Direct iteration over the dictionary may be less compatible.\n",
    "\n",
    "3. **Explicitness:** Using `.keys()` can make your code more explicit and easier to understand. It clearly signals your intention to work with the keys of the dictionary.\n",
    "\n",
    "Nadaljeval je s primerom kode, ki je bila nesmiselna. Zaključil jo je s komentarjem:\n",
    "\n",
    "**In this example, the view object key_view reflects changes made to the dictionary, while iterating directly over the dictionary does not provide the same dynamic behavior. Depending on your use case and specific needs, you may choose to use `dict.keys()` or direct iteration, but understanding the differences and advantages of using dict.keys() can help you make informed decisions in your code.**\n",
    "\n",
    "Vem, da ne razumete, vendar: napisano nima smisla. Če spremenimo slovarm je slovar spremenjen. Prav tako je spremenjen \"key_view\". Oboje je \"dinamično\". \"*does not provide the same dynamic behavior*\" je tipičen primer chatGPTjevega flanca. Zadnji stavek pa sploh.\n",
    "\n",
    "Tiste tri točke so pa zanimive. Tretja je mogoče smiselna in je stvar okusa.\n",
    "\n",
    "Druga točka je popolnoma mimo. Res je, da imata oba metodo `keys`, vendar ne vrača iste stvari. Ena od največjih razlik med Pythonom 2 in 3 je prav v tem, kaj vračajo `keys` in podobne metode.\n",
    "\n",
    "Prva točka je pa zanimiva. S `keys` lahko ustvarimo nek objekt, ki vsebuje le ključe, ne pa tudi vrednosti. Zakaj bi to hoteli, sicer ne vem, vendar ... no, tu je napisal nekaj smiselnega."
   ]
  }
 ],
 "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
}