pn/predavanja/06 Moduli.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c408aae2",
   "metadata": {},
   "source": [
    "# Moduli\n",
    "\n",
    "Povedali smo že: Python ima tisoče in tisoče funkcij, zato morajo biti urejene, postavljene tja, kjer jih bomo lahko našli.\n",
    "\n",
    "Enega od principov smo že spoznali: metode. Metode so pripete na reči (bolj učeno in pravilno: objekte) in počnejo stvari, tipične za te reči. Nizi imajo metode, kot so `lower` in `split`, slovarji pa `get` in `setdefault`.\n",
    "\n",
    "Poleg metod ima Python tudi funkcije, ki ne spadajo k nobenemu specifičnemu tipu. Primera sta `input` in `print`. A teh je malo; privilegij ležati kar tako, na prostem, ima le nekaj zelo splošno uporabnih funkcij.\n",
    "\n",
    "Večina funkcij, ki niso metode, je pospravljenih v škatlice. Škatlicam se v Pythonu reče *modul* (angl. *module*). Najbrž boste slišali tudi izraz paket (*package*) in celo knjižnica (*library*). Zaradi njih se ne vznemirjajte: paket je hierarhična zbirka modulov, knjižnica pa neka zaokrožena celota različnih ... modulov, paketov ... česarkoli. Za nas so tule pomembni samo moduli. Izvedeli bomo, kako jih uporabljati in videli nekaj uporabnih reči v nekaj uporabnih modulih."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59bc9c91",
   "metadata": {},
   "source": [
    "## Uvažanje modulov\n",
    "\n",
    "Da uporabimo funkcije v modulu, moramo modul najprej uvoziti.\n",
    "\n",
    "Doslej smo uporabljali, na primer, funkcije iz modula `math` in uvažali smo jih s `from math import *`. Pri poučevanju programiranja se izogibam temu, da bi morali tipkati kakšne fraze, ki jih ne razumete. `from math import *` je bila ena redkih in čas je, da izvemo, za kaj gre. Ter tudi čas, da se te fraze odvadimo in se naučimo pisati kot se spodobi.\n",
    "\n",
    "Modul z matematičnimim funkcijami, `math`, pravilno uvozimo tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8cd3ec2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1db52201",
   "metadata": {},
   "source": [
    "S tem v bistvu dobimo novo spremenljivko, `math`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ac2bf7c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'math' from '/Users/janez/opt/miniconda3/envs/prog/lib/python3.11/lib-dynload/math.cpython-311-darwin.so'>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26317c21",
   "metadata": {},
   "source": [
    "Tole je spremenljivka najbolj čudnega tipa doslej. Ni preprosto število (`int`, `float`) ali niz (`str`) ali seznam ali terka (`list`, `tuple`), temveč spremenljivka vrste \"modul\" (\"module\"). \n",
    "\n",
    "Funkcije pripadajo modulu, tako kot metode objektu. če imamo niz `ime`, bomo do njegove metode `upper` prišli s piko, `ime.upper`. Tu pa je podobno: če imamo modul `math`, bomo do njegove funkcije `sqrt` prišli z `math.sqrt`, do njegove spremenljivke `pi` pa z `math.pi`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ece2032b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d70e8228",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7071067811865475"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(math.pi / 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "255b0152",
   "metadata": {},
   "source": [
    "Uvozimo še en modul, `os`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "540a93e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e49911aa",
   "metadata": {},
   "source": [
    "V `os` so funkcije, s katerimi lahko ustvarimo direktorij ali pobrišemo datoteko. Poleg tega pa vsebuje še nekaj zanimivega: modul. Modul `path` je modul znotraj modula `os`. Vsebuje, recimo, funkcijo `splitext`, ki za podano ime datoteke vrne osnovo in končnico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c90a24af",
   "metadata": {},
   "outputs": [],
   "source": [
    "osnova, koncnica = os.path.splitext(\"nek_film.avi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e06ae25d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nek_film'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "osnova"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "799fbf90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'.avi'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncnica"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "058373c4",
   "metadata": {},
   "source": [
    "Tako se uvaža module.\n",
    "\n",
    "### Uvažanje posamičnih funkcij\n",
    "\n",
    "Če funkcije določenega modula kličemo velikokrat in predvsem, če to počnemo v aritmetičnih izrazih, to postane nepregledno.\n",
    "\n",
    "```python\n",
    "x = 2 * math.sin(math.radians(phi) + math.pi / 2) - 2 * math.cos(math.radians(alpha))\n",
    "```\n",
    "\n",
    "Boljše bi bilo imeti te funkcije pri roki brez ponavljajočega se `math`. Uvozimo jih z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "34875c67",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sin, cos, radians, pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "75b8b36f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7071067811865476"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cos(pi / 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43991886",
   "metadata": {},
   "source": [
    "`from math import sin, cos, radians, pi` uvozi naštete funkcije in postanejo, pod temi imeni, dostopne programu. Imeli bomo torej imena `sin`, `cos`, `radians` in `pi`, ne pa tudi `tan` in `log`. Predvsem pa ne `math`.\n",
    "\n",
    "Se pravi:\n",
    "\n",
    "- če uvozimo `import math`, imamo `math` in, recimo `math.cos`, ne pa `cos`. Uvozili smo pač `math`, ne `cos`.\n",
    "- če uvozimo `from math import cos` pa imamo `cos` in ne `math` ali `math.cos`. Uvozili smo pač `cos` in ne `math`.\n",
    "\n",
    "### Uvažanje vsega\n",
    "\n",
    "Obstaja še \"preprostejši\" način uvažanja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3a59f805",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f92974d1",
   "metadata": {},
   "source": [
    "Ta je podoben prejšnjemu, le da funkcij ne naštevamo. `*` predstavlja *vse*, kar je v modulu.\n",
    "\n",
    "Prvi način, uvažanje modula, ima to prednost, da je v vsakem klicu funkcije jasno, odkod ta funkcija prihaja. Slabost so precej daljši izrazi.\n",
    "\n",
    "Drugi način, uvažanje posamičnih funkcij skrajša izraze. Odkod prihaja kakšna funkcija, še vedno vidimo, vendar je potrebno za to pogledati na začetek programa, v `import`-e.\n",
    "\n",
    "Tretji način je v splošnem slab. Izrazi so krajši, vendar za posamične funkcije ne vemo, odkod so prišle. Na ta način uvažamo kvečjemu modul `math` in nobenega drugega. Posebej v večjih projektih.\n",
    "\n",
    "**Sprememba:** gornji odstavek sem napisal pred desetimi leti. V resnici že dolgo, dolgo nisem uvozil modula na takšnen način, razen v prvih tednih Programiranja 1. Tudi vam ga ni treba. To se ne dela.\n",
    "\n",
    "## Kje uvažamo\n",
    "\n",
    "Vedno na začetku programa. Ne kar tako, vmes.\n",
    "\n",
    "Izjemoma: na začetku funkcije. To storimo, recimo, kadar ni jasno, ali bo modul možno uvoziti, oziroma je uvažanje počasno, potrebujemo pa ga le v neki funkciji. Druga situacija, kjer bi to prišlo prav, je, če se dva modula uvažata vzajemno, eden drugega. To razrešimo tako, da določen modul uvozimo šele, ko ga potrebujemo.\n",
    "\n",
    "To ni zakon, samo dogovor.\n",
    "\n",
    "Uvažanje modulov se v resnici zgodi samo enkrat. Če petkrat napišemo `import math`, se bo modul v resnici uvozil le prvič."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3601508",
   "metadata": {},
   "source": [
    "## Modul `math`\n",
    "\n",
    "Ogledali si bomo nekaj uporabnih modulov. Python jih ima približno dvesto; še tisoče in tisoče jih najdete na internetu.\n",
    "\n",
    "Prvi je `math`, vendar o njem ne bomo povedali veliko. Ima pač vse funkcije, ki si jih ima katerikoli kalkulator ... in še malo več. :) Na primer največji skupni delitelj, fakulteto in binomske koeficiente ...\n",
    "\n",
    "Priložnost izkoristimo le za to, da omenimo dve posebnosti v zvezi s števili. Podatkovni tip `float` premore poleg normalnih števil še dve posebni: neskončno (in minus neskončno) ter ni-število (*not a number*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5647dd75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.inf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c38c15f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-inf"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-math.inf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6e3fca04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.nan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42ed40d5",
   "metadata": {},
   "source": [
    "Prvi dve sta lahko uporabni za kako iskanje minimuma ali maksimuma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8f26f567",
   "metadata": {},
   "outputs": [],
   "source": [
    "def min(s):\n",
    "    m = math.inf\n",
    "    for x in s:\n",
    "        if x < m:\n",
    "            m = x\n",
    "    return m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6bf25ab",
   "metadata": {},
   "source": [
    "`math.inf` je večji od vseh števil (razen od sebe) in torej uporabna začetna vrednost pri iskanju minimuma."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceb167e3",
   "metadata": {},
   "source": [
    "`nan` je zanimivejša reč. V nekaterih jezikih ga dobimo kot rezultat napačnih argumentov za matematične funkcije, recimo, če poskušamo izračunati koren ali logaritem negativnega števila. Pythonove funkcije v tem primeru vrnejo napako, pač pa ga vrnejo nekatere funkcije v knjižnicah (modulih), ki si jih bomo namestili dodatno, zato je prav, da veste zanj.\n",
    "\n",
    "`nan`, *not a number*, je slepa ulica števil. Karkoli počnemo z njim - ga seštevamo, odštevamo, množimo, celo množimo z nič - vedno ostane `nan`. Še huje: `nan` ni ne večji ne manjši od nobenega števila. Niti od neskončno ni manjši (in seveda ne večji, pa tudi enak ne)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0b51e5b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.nan < math.inf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ead56f98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.nan > math.inf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a80457e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.nan == math.inf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7643fe5e",
   "metadata": {},
   "source": [
    "In, najhujše, enak ni niti sebi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7bfc1bc9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.nan == math.nan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84be816b",
   "metadata": {},
   "source": [
    "Kako potem preverimo, če ima neka spremenljivka vrednost `nan` - če je ne moremo primerjati niti z `nan`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2815a768",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vse je OK.\n"
     ]
    }
   ],
   "source": [
    "x = math.nan\n",
    "\n",
    "if x == math.nan:\n",
    "    print(\"Ojoj!\")\n",
    "else:\n",
    "    print(\"Vse je OK.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "141a8346",
   "metadata": {},
   "source": [
    "Pač, izkoristimo njegovo neumnost proti njemu samemu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8d2d1de6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Svet se podira!\n"
     ]
    }
   ],
   "source": [
    "x = math.nan\n",
    "\n",
    "if x != x:\n",
    "    print(\"Svet se podira!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0dad74f",
   "metadata": {},
   "source": [
    "Lepši, pravilnejši način, da preverimo, ali ima neka spremenljivka vrednost `nan`, je funkcija `math.isnan`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "14b6f04f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ojoj!\n"
     ]
    }
   ],
   "source": [
    "if math.isnan(x):\n",
    "    print(\"Ojoj!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d972bccd",
   "metadata": {},
   "source": [
    "Na vse to se bo koristno spomniti, ko bomo delali z, na primer, kakšnimi statističnimi knjižnicami, ki bodo takrat, ko česa ne bo možno izračunati, vrnili `nan`.\n",
    "\n",
    "Mimogrede, tole čudno obnašanje, po katerem `nan` ni enak niti samemu sebi, ni kakšna Pythonova muha, temveč del standarda IEEE 754, ki določa zapis števil s plavajočo vejico (float) in njegovo vedenje. Enako se vede vsak vzgojen jezik."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f77befe1",
   "metadata": {},
   "source": [
    "## Modul `random`\n",
    "\n",
    "Modul `random` vsebujejo funkcije, ki počnejo (psevdo-)naključne stvari. (To je: videti so naključne, vendar niso, saj je vse, kar naračunajo običajni računlniki, izračunano in ne izžrebano.) Omenili jih bomo le nekaj."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16bb1e2b",
   "metadata": {},
   "source": [
    "`random.random()` vrne naključno število med 0 in 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3267f7d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8088080148072502"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random.random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "de5bacca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5502323145363647"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.random()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89dc0816",
   "metadata": {},
   "source": [
    "`random.uniform(a, b)` vrne naključno število med `a` in `b`. Funkcija se imenuje `uniform`, ker gre za enakomerno porazdelitev - vsa števila so enako verjetna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1596be9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.801216989018465"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.uniform(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6bfa7d1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.786154792833283"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.uniform(10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93b1e846",
   "metadata": {},
   "source": [
    "Če potrebujemo celo naključno število, pokličemo `randint`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "c7c661e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.randint(10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "679f2eea",
   "metadata": {},
   "source": [
    "Če nas namesto enakomerne zanima kakšna druga porazdelitev: modul `random` jih pozna veliko: beta, gama, eksponentna ... in seveda tudi Gaussova."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d1a3660b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "87.46911052444023"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iq = random.gauss(100, 10)\n",
    "\n",
    "iq"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f72dcc",
   "metadata": {},
   "source": [
    "Sestavimo seznam imen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7c9a4ba8",
   "metadata": {},
   "outputs": [],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\", \"Fanči\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "742ca12c",
   "metadata": {},
   "source": [
    "`random.choice` vrne naključni element podanega seznama."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b155c829",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.choice(imena)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd1d42bb",
   "metadata": {},
   "source": [
    "`random.sample` izbere naključni vzorec podane velikosti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f239f3d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Cilka', 'Fanči', 'Berta']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.sample(imena, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35018a64",
   "metadata": {},
   "source": [
    "`random.choices` je podoben, vendar se izbrani primeri lahko tudi ponavljajo. Velikost vzorca mora biti podana kot argument z imenom `k`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0c365aba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Dani', 'Cilka', 'Cilka', 'Cilka', 'Cilka']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.choices(imena, k=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02da3ff7",
   "metadata": {},
   "source": [
    "`random.shuffle` premeša podani seznam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "a2c2cf5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanči']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7ad4edb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Cilka', 'Berta', 'Ana', 'Fanči', 'Dani', 'Ema']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.shuffle(imena)\n",
    "\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2326df0",
   "metadata": {},
   "source": [
    "## Modul `os`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41cea7ce",
   "metadata": {},
   "source": [
    "Modul `os` vsebuje kop reči, povezanih z operacijskim sistemom. Ker o operacijskih sistemih ne vemo dovolj, večine funkcij ne bi razumeli. (Ta prva oseba množine velja tudi zame. Sicer večino razumem, o mnogih pa bi moral prebrati malo več, da bi vedel, za kaj pravzaprav gre.) Prgišče pa jih bomo vseeno redno uporabljali.\n",
    "\n",
    "- `getcwd()` vrne trenutni direktorij. Torej direktorij, v katerem bi funkcija `open` iskala datoteko, če bi ji podali le ime datoteke.\n",
    "- `chdir(path)` spremeni trenutni direktorij. Pot je lahko absolutna (s `/` na začetku) ali relativna.\n",
    "- `mkdir(path)` naredi nov direktorij.\n",
    "- `remove(filename)` pobriše datoteko s podanim imenom. Brez milosti. Nobenega \"ali res želite pobrisati\".\n",
    "- `rename(name, newname)` preimenuje datoteko.\n",
    "- `listdir(path)` vrne seznam vseh imen datotek v podanem direktoriju.\n",
    "\n",
    "Največkrat boste potrebovali slednjo. Podatke iz vremenskih postaj, recimo, sem dobil v obliki tisočev datotek, ki sem jih potem prebral in (seveda filtrirane) podatke zapisal v novo datoteko.\n",
    "\n",
    "Tole je trenutna vsebina trenutnega direktorija (v katerem so tile zapiski)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f3477111",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3cb95bab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['temperature.svg',\n",
       " '08b Numpy - naslednji koraki.ipynb',\n",
       " 'vremenske-postaje.txt',\n",
       " 'xml - zapiski.md',\n",
       " 'Untitled1.ipynb',\n",
       " 'kolesa.txt',\n",
       " 'avtorji-na-b.md',\n",
       " '.DS_Store',\n",
       " 'kolesa2.txt',\n",
       " '03c Slovarji.ipynb',\n",
       " '06 Mnozice.ipynb',\n",
       " 'temperature.txt',\n",
       " 'Untitled.ipynb',\n",
       " '07 Pisanje datotek (in se malo branja).ipynb',\n",
       " 'tecajnica.json',\n",
       " '06 Moduli.ipynb',\n",
       " '04 seznami.ipynb',\n",
       " 'vreme',\n",
       " 'authors-b.html',\n",
       " '03a Kako racunalnik shrani besedilo.ipynb',\n",
       " 'temperature.pdf',\n",
       " 'test.json',\n",
       " '09 Analiza podatkov in risanje.ipynb',\n",
       " '12 Python in Excel.ipynb',\n",
       " 'temperature.png',\n",
       " '11 Markdown in Jupyter, HTML, regularni izrazi.ipynb',\n",
       " 'xml',\n",
       " '08 Osnove numpyja.ipynb',\n",
       " 'test.pkl',\n",
       " '02b logični izrazi.ipynb',\n",
       " 'tecajnica.pickle',\n",
       " '.ipynb_checkpoints',\n",
       " '02 datoteke, zanke, pogoji.ipynb',\n",
       " 'besedilo.txt',\n",
       " '05 Zanka `while`.ipynb',\n",
       " '04 Terke.ipynb',\n",
       " '10 Branje podatkov v standardnih formatih.ipynb',\n",
       " 'x.html',\n",
       " 'december.txt',\n",
       " '05 Funkcije.ipynb',\n",
       " '03b Metode nizov.ipynb',\n",
       " 'kolesa-z-glavo.txt',\n",
       " '07 Oblikovanje nizov.ipynb']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2352c35e",
   "metadata": {},
   "source": [
    "## Modul `os.path`\n",
    "\n",
    "`path` je modul znotraj modula `os`. Tudi ta ima marsikaj, nekaj funkcij pa je primernih tudi za nas.\n",
    "\n",
    "- `os.path.exists(name)` vrne `True`, če (v trenutnem direktoriju) obstaja datoteka ali direktorij s podanim imenom.\n",
    "- `os.path.isdir(name)` vrne `True`, če je podano ime direktorij (znotraj trenutnega direktorija).\n",
    "- `os.path.isfile(name)` vrne `True`, če je podano ime datoteka (znotraj trenutnega direktorija).\n",
    "- `os.path.splitext(name)` vrne osnovo in končnico podanega imena datoteke.\n",
    "\n",
    "Ostale so očitne, za nas je posebej zanimiva zadnja.\n",
    "\n",
    "Izpišimo imena vseh datotek s končnico .txt, ki se nahajajo v trenutnem direktoriju."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "31ebaf07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vremenske-postaje.txt\n",
      "kolesa.txt\n",
      "kolesa2.txt\n",
      "temperature.txt\n",
      "besedilo.txt\n",
      "december.txt\n",
      "kolesa-z-glavo.txt\n"
     ]
    }
   ],
   "source": [
    "for ime in os.listdir():\n",
    "    osnova, koncnica = os.path.splitext(ime)\n",
    "    if os.path.isfile(ime) and koncnica == \".txt\":\n",
    "        print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3582d9da",
   "metadata": {},
   "source": [
    "## Modul `collections`\n",
    "\n",
    "Med vsemi zanimivimi rečmi v `collections` vsaj za zdaj omenimo le dve.\n",
    "\n",
    "### `defaultdict`\n",
    "`defaultdict` je slovar, ki sproti dodaja neobstoječe ključe, podati pa mu moramo funkcijo, s katero si bo izmišljal njihove vrednosti. Primerne so le funkcije, ki ne sprejemajo argumentov, oziroma, točneje, funkcije, ki jih lahko pokličemo (tudi) brez argumentov. Najpogosteje bo to `int`. Če jo pokličemo brez argumentov namreč vrne `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d246ff45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "0e01ce49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int, {'Ana': 5, 'Berta': 3})"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "d = defaultdict(int)\n",
    "\n",
    "d[\"Ana\"] = 5\n",
    "d[\"Berta\"] = 3\n",
    "\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "121aa2d2",
   "metadata": {},
   "source": [
    "Doslej nič posebnega, le pri izpisu nam ne pokaže samo slovarja, temveč doda še, da je to `defaultdict` s funkcijo `int`. Zabava se začne, ko povprašamo po ključu, ki ne obstaja. Tu pokliče podano funkcijo (`int`) in vrne njeno vrednost, novi par pa doda tudi v slovar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9165edad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"Cilka\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "c696c295",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int, {'Ana': 5, 'Berta': 3, 'Cilka': 0})"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6e1fe07",
   "metadata": {},
   "source": [
    "Smemo celo, recimo, povečati vrednost neobstoječemu ključu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "5fdf0203",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int, {'Ana': 5, 'Berta': 3, 'Cilka': 0, 'Dani': 1})"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"Dani\"] += 1\n",
    "\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4463326",
   "metadata": {},
   "source": [
    "Preštejmo, kolikokrat se je avtor datoteke kolesa.txt vozil s katerim kolesom in koliko je prevozil z njim. Spomnimo se: vrstice datoteke predstavljajo posamične poti in vsebujejo ime kolesa, razdaljo v kilometrih in še nekaj, kar nas tu ne zanima (višino)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "5cc89d22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defaultdict(<class 'int'>, {'Nakamura': 22, 'Cube': 43, 'Canyon': 26, 'Stevens': 9})\n",
      "defaultdict(<class 'int'>, {'Nakamura': 439, 'Cube': 3174, 'Canyon': 2766, 'Stevens': 607})\n"
     ]
    }
   ],
   "source": [
    "uporaba = defaultdict(int)\n",
    "pot = defaultdict(int)\n",
    "\n",
    "for vrstica in open(\"kolesa.txt\"):\n",
    "    kolo, razdalja, _ = vrstica.split(\",\")\n",
    "    uporaba[kolo] += 1\n",
    "    pot[kolo] += int(razdalja)\n",
    "    \n",
    "print(uporaba)\n",
    "print(pot)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea158ed",
   "metadata": {},
   "source": [
    "Enako bi lahko naredili tudi z običajnimi slovarji, vendar bi zahtevalo nekaj `if`-ov ali pa metod, kot sta `setdefault` ali `get`.\n",
    "\n",
    "Zdaj pa se posvetimo dražbi: radi bi sestavili slovar, katerega ključi bodo predmeti, vrednosti seznami ponudb za ta predmet. Spet bomo uporabili `defaultdict`, vendar vrednosti ne bodo `int`-i, temveč seznami. Funkcija `list` nam, če jo pokličemo brez argumentov, prikladno vrne prazen seznam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "c3c3ad81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = defaultdict(list)\n",
    "\n",
    "d[\"foo\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84fb41bf",
   "metadata": {},
   "source": [
    "V tak seznam lahko celo dodajamo z `append`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "fad3a028",
   "metadata": {},
   "outputs": [],
   "source": [
    "d[\"bax\"].append(12)\n",
    "d[\"bax\"].append(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "f112fdb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list, {'foo': [], 'bax': [12, 5]})"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d87679a",
   "metadata": {},
   "source": [
    "Zdaj pa zares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "265d52c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "slika [31, 33, 35, 37, 40, 45]\n",
      "pozlačen dežnik [29]\n",
      "Meldrumove vaze [44, 46, 48, 53, 57, 60, 61, 63, 67, 71, 76, 78]\n",
      "skodelice [50, 55, 60, 61, 62, 65, 68, 70, 74, 76, 80, 83]\n",
      "kip [30, 32, 37, 39, 43, 44, 45, 50, 53, 55, 58, 61, 63, 68, 72, 76, 77, 81, 85, 86, 90, 92, 94, 97, 98, 99, 100, 103, 107]\n",
      "čajnik [15]\n",
      "srebrn jedilni servis [27, 30, 35, 39, 40, 45, 47, 49, 53, 55, 58, 59, 62, 63]\n",
      "perzijska preproga [16, 21]\n"
     ]
    }
   ],
   "source": [
    "ponudbe = defaultdict(list)\n",
    "\n",
    "for vrstica in open(\"../domace-naloge/03-drazba-brez-anonimnosti/zapisnik.txt\"):\n",
    "    predmet, oseba, cena = vrstica.split(\",\")\n",
    "    ponudbe[predmet].append(int(cena))\n",
    "    \n",
    "for predmet, cene in ponudbe.items():\n",
    "    print(predmet, cene)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aef7eb1",
   "metadata": {},
   "source": [
    "Kako lažje bi bile domače naloge, če bi že pred par tedni vedeli za `defaultdict`! Vendar se potem nikoli ne bi naučili zares delati z datotekami, zankami, seznami... ;)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d58ac43",
   "metadata": {},
   "source": [
    "### `Counter`\n",
    "\n",
    "`Counter` iz nekega razloga pišemo z veliko. (Razlog ni posebej dober. Iz istega razloga bi lahko z veliko pisali tudi `defaultdict`.\n",
    "\n",
    "`Counter` je v sorodu z `defaultdict`-om in ga včasih nadomešča. Trenutno nimamo pri roki dobrega primera za njegovo uporabo, oziroma, točneje, da bi ga učinkovito uporabljali, bi morali znati nekaj, česar še ne znamo. Vseeno pa lahko pokažemo, kaj počne.\n",
    "\n",
    "Recimo, da imamo seznam imen oseb, ki jim je nekdo telefoniral."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "442c8a2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "klici = [\"Ana\", \"Ana\", \"Berta\", \"Cilka\", \"Ana\", \"Cilka\", \"Dani\", \"Ema\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ec943ff",
   "metadata": {},
   "source": [
    "Seveda želimo prešteti, kolikokrat je poklical koga. To bi znali kar trivialno narediti z `defaultdict`-om, s `Counter` pa je še trivialneje:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "bf9146e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'Ana': 3, 'Cilka': 2, 'Berta': 1, 'Dani': 1, 'Ema': 1})"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "stevci = Counter(klici)\n",
    "\n",
    "stevci"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fff266e4",
   "metadata": {},
   "source": [
    "Pogosto nas bo zanimalo, koga je klical največkrat - ali pa katere tri - in za to obstaja metoda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "614f1a01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Ana', 3), ('Cilka', 2), ('Berta', 1)]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stevci.most_common(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ca1e2dc",
   "metadata": {},
   "source": [
    "Tole je seznam, urejen po pogostosti."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c06211e",
   "metadata": {},
   "source": [
    "## Modul `csv`\n",
    "\n",
    "Tale vam bo všeč. Datoteke, ki vsebujejo podatke, ločene z vejicami, tako kot jih je naš `zapisnik.txt`, so kar pogoste. Tej obliki zapisa rečemo *comma separated values* ali, s kratico, csv. V to obliko zna shranjevati tudi Excel - ob opozorilu, da se bo ob tem izgubilo vse oblikovanje in še kaj. (Enkrat sem obljubil, da se bomo učili brati Excelove datoteke. To še ni to. Brali bomo tudi .xlsx. Ampak še ne.) V tej obliki je bil tudi naš zapisnik dražbe in vse druge datoteke.\n",
    "\n",
    "Python ima zato modul csv, ki zna brati take reči.\n",
    "\n",
    "### `reader`\n",
    "\n",
    "Nas zanimajo imena vseh udeležencev dražbe?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "59965a8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanči', 'Greta', 'Helga'}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import csv\n",
    "\n",
    "udelezenci = set()\n",
    "for predmet, oseba, cena in csv.reader(open(\"../domace-naloge/04-analiza-drazbe/zapisnik.txt\")):\n",
    "    udelezenci.add(oseba)\n",
    "\n",
    "udelezenci"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4795b467",
   "metadata": {},
   "source": [
    "Funkciji `csv.reader` podamo datoteko (ne le imena, potrebno je poklicati tudi `open`). Vrne nekaj, čez kar lahko gremo z zanko `for`, pa dobivamo podatke iz vrstic. Nobenega `split`.\n",
    "\n",
    "`csv.reader` privzame, da so podatki ločeni z vejico. Če so s čim drugim, mu to povemo z dodatnim argumentom `delimiter`. Ločilo v datoteki \"kolesa.txt\" iz pete domače naloge je bil `-`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "91b34c27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cube', '5031', '159', 'Janez', '2017']\n",
      "['Stevens', '3819', '1284', 'Ana', '2012']\n",
      "['Focus', '3823', '1921', 'Benjamin', '2019']\n"
     ]
    }
   ],
   "source": [
    "ime_dat = \"../domace-naloge/05-druzabno-omrezje-drazbe/kolesa.txt\"\n",
    "\n",
    "for v in csv.reader(open(ime_dat), delimiter=\"-\"):\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccf17dad",
   "metadata": {},
   "source": [
    "Poleg ločila ima datoteka lahko še kup drugih lastnosti. Recimo, da na dražbi prodajajo komplet *žlica, nož in vilice Ludvika XIV.* V datoteki bi tako dobili vrstico\n",
    "\n",
    "```\n",
    "žlica, nož in vilice Ludvika XIV,Ana,12945\n",
    "```\n",
    "\n",
    "in `s.split(\",\")` bi vrnil štiri stvari, namesto treh, pač zaradi vejice med žlico in nožem. Excel, recimo, bi v tem primeru napisal nekaj v slogu\n",
    "\n",
    "```\n",
    "\"žlica, nož in vilice Ludvika XIV\",Ana,12945\n",
    "```\n",
    "\n",
    "S tem, ko bi zaprl prvo polje v narekovaje, bi povedal, da gre tu za eno samo reč in da je potrebno vejico znotraj tega ignorirati. Različni programi in sistemi imajo različna pravila; temu se v jeziku funkcije `csv.reader` reče `dialect`. Privzeti dialekt je `\"excel\"` in ta bo za datoteke iz Excela navadno delal. Za ostale lahko uporabite `Sniffer`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "62f8ac94",
   "metadata": {},
   "outputs": [],
   "source": [
    "sniffer = csv.Sniffer()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "861ae172",
   "metadata": {},
   "source": [
    "Z metodo `.read()` preberemo celotno vsebino datoteke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "36764378",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cube-5031-159-Janez-2017\\nStevens-3819-1284-Ana-2012\\nFocus-3823-1921-Benjamin-2019\\n'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "open(ime_dat).read()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9eff043",
   "metadata": {},
   "source": [
    "`sniffer` ima metodo `sniff`, ki ji kot argument damo vsebino datoteke (ali vsaj dovolj velik kos, da je iz njega razvidno, kako je datoteka oblikovana). Sniffer bo uganil, v kakšnem slogu je napisana datoteka."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "a2edf04c",
   "metadata": {},
   "outputs": [],
   "source": [
    "dialect = sniffer.sniff(open(ime_dat).read())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff615053",
   "metadata": {},
   "source": [
    "Nato pokličemo `csv.reader` in mu poleg datoteke podamo še dialekt.\n",
    "\n",
    "Da bo lažje vidno, naredimo vse še enkrat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "ba02d033",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cube', '5031', '159', 'Janez', '2017']\n",
      "['Stevens', '3819', '1284', 'Ana', '2012']\n",
      "['Focus', '3823', '1921', 'Benjamin', '2019']\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "\n",
    "ime_dat = \"../domace-naloge/05-druzabno-omrezje-drazbe/kolesa.txt\"\n",
    "sniffer = csv.Sniffer()  # vrne novega \"snifferja\"\n",
    "dialect = sniffer.sniff(open(ime_dat).read())  # preberemo vsebino datoteke in jo damo posniffati :)\n",
    "for v in csv.reader(open(ime_dat), dialect):\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "421ee1cf",
   "metadata": {},
   "source": [
    "### `DictReader`\n",
    "\n",
    "Recimo, da bi imeli takšno datoteko s kolesi:\n",
    "\n",
    "```\n",
    "kolo,razdalja,višina,lastnik,leto nakupa\n",
    "Cube,5031,159,Janez,2017\n",
    "Stevens,3819,1284,Ana,2012\n",
    "Focus,3823,1921,Benjamin,2019\n",
    "```\n",
    "\n",
    "Za razliko od prejšnjih datotek (in vseh, ki smo jih videli doslej) ima ta datoteka v prvi vrstici imena stolpcev. Zato jo lahko namesto z `reader` beremo z `DictReader`, ki za vsako vrstico ne vrne seznama temveč slovar, katerega ključi so imena stolpcev. To je imenitno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "5fefd27a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cube : 2017\n",
      "Stevens : 2012\n",
      "Focus : 2019\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "\n",
    "for vrstica in csv.DictReader(open(\"kolesa-z-glavo.txt\")):\n",
    "    print(vrstica[\"kolo\"], \":\", vrstica[\"leto nakupa\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7cd7196",
   "metadata": {},
   "source": [
    "Ker bodo imele vaše datoteke zelo pogosto glavo, boste pretežno uporabljali `DictReader`. To je praktično, saj je s slovarji lažje delati kot s seznami. Imena stolpcev, kot so *kolo*, *lastnik* in *leto nakupa* je lažje brati kot indekse 0, 3 in 4, pa še zmotili se ne bomo pri štetju."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a07b8140",
   "metadata": {},
   "source": [
    "## Modul `statistics`\n",
    "\n",
    "O modulu `statistics` se ne bomo preveč razgovorili. Osebno ga nikoli ne uporabljam, saj se vse to in še veliko več najde v modulih knjižnice `numpy`, s katero se da tudi veliko preprosteje narediti veliko več - a le če znaš. Python ima ta modul zgolj zato, ker je `numpy` pač ogromna dodatna knjižnica, ki je ne dobimo s Pythonom. (Po drugi strani pa si vsak resen uporabnik pythona namesti tudi `numpy`.)\n",
    "\n",
    "Skratka: `statistics` vsebuje funkcije `mean`, `median`, `mode`, `stdev` in še kup drugih, ki znajo za podani seznam izračunati poprečje, mediano, modus, standardno deviacijo in še kup drugega."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "8b136a3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import statistics\n",
    "\n",
    "visine = [185, 192, 160, 173, 180]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "f206d80a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "178"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "statistics.mean(visine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "435cca90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.227019260637483"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "statistics.stdev(visine)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "054587de",
   "metadata": {},
   "source": [
    "Ve tudi za korelacijo in linearno regresijo, tu pa se neha. Kdor bi rad izvedel več, naj pogleda v [dokumentacijo modula `statistics`](https://docs.python.org/3/library/statistics.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22de0781",
   "metadata": {},
   "source": [
    "## Moduli `time`, `datetime`, `calendar`\n",
    "\n",
    "Pri delu boste najbrž pogosto naleteli na razne datume, čase in podobno. Funkcije, povezane s tem, so razmetane po treh modulih. Vse skupaj je prilična zmešnjava. Zanjo niti ni toliko kriv Python, kot, predvsem, dejstvo, da se tu navezuje na različne standardizirane funkcije različnih sistemov. Nekatere stvari na Windows delujejo drugače kot na macOS ali na Linuxu in potem dobimo, kar imamo.\n",
    "\n",
    "### `time`\n",
    "\n",
    "Modul `time` ([dokumentacija](https://docs.python.org/3/library/time.html)) se ukvarja s trenutnim časom in drugimi časi in pretvarjanjem med njimi.\n",
    "\n",
    "Glavna funkcija je `time`, ki vrne število sekundo, minevših od 1. januarja 1970 po Greenwichu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "336ed7eb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1707583016.433111"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "954c4d0e",
   "metadata": {},
   "source": [
    "To je uporabno, če bi radi merili (realen) čas, ki je minil med dvema dogodkoma v programu. Vendar ... no, ne zelo. Za to obstajajo boljše funkcije.\n",
    "\n",
    "Za naše potrebe sta morda bolj uporabni `gmtime` in `localtime`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "3e8264c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time.struct_time(tm_year=2024, tm_mon=2, tm_mday=10, tm_hour=16, tm_min=36, tm_sec=56, tm_wday=5, tm_yday=41, tm_isdst=0)\n",
      "time.struct_time(tm_year=2024, tm_mon=2, tm_mday=10, tm_hour=17, tm_min=36, tm_sec=56, tm_wday=5, tm_yday=41, tm_isdst=0)\n"
     ]
    }
   ],
   "source": [
    "print(time.gmtime())\n",
    "print(time.localtime())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6debccd4",
   "metadata": {},
   "source": [
    "Obe vrnete čudo istega tipa. Imenuje se `struct_time`. Tako ime kot oblika izhajata iz jezika C. Ime ni pomembno, pomembna so imena polj, ki vsebujejo trenutno leto, mesec in dan, uro, minute in sekunda, pa dan v tednu in letu, za zraven pa še polje, ki pove, ali gre za letni čas (1) ali ne (0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "6e68dc02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Danes je 10. 2. 2024.\n"
     ]
    }
   ],
   "source": [
    "zdaj = time.localtime()\n",
    "\n",
    "print(\"Danes je \", zdaj.tm_mday, \". \", zdaj.tm_mon, \". \", zdaj.tm_year, \".\", sep=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6fdd093",
   "metadata": {},
   "source": [
    "Modul vsebuje tudi funkcijo za oblikovanje datumov. Uporabimo jo takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "4adc3646",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes je 10. 02. 2024, ura pa je 17.36'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.strftime(\"Danes je %d. %m. %Y, ura pa je %H.%M\", zdaj)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fafabdd",
   "metadata": {},
   "source": [
    "Podamo ji niz, ki vsebuje znake, kot so `%d`, `%m`, `%Y` in tako naprej, ter čas. Funkcija bo te znake zamenjala z ustreznimi vrednostmi.\n",
    "\n",
    "Celoten seznam možnih znakov najdete na [https://docs.python.org/3/library/time.html#time.strftime](https://docs.python.org/3/library/time.html#time.strftime)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "564d71a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes je Saturday, 10. February 2024'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.strftime(\"Danes je %A, %d. %B %Y\", zdaj)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14262d41",
   "metadata": {},
   "source": [
    "Tole ni izpadlo najboljše. Očitno se ni odločil za slovenščino. K temu bi se ga sicer dalo pripraviti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "ba5db4b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sl_SI'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import locale\n",
    "\n",
    "locale.setlocale(locale.LC_ALL, \"sl_SI\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77949757",
   "metadata": {},
   "source": [
    "Zdaj pa bo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "347827f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes je sobota, 10. februar 2024'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.strftime(\"Danes je %A, %d. %B %Y\", zdaj)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65464198",
   "metadata": {},
   "source": [
    "Tule smo mimogrede uporabili še module `locale`, ki vsebuje vse živo povezano z različnimi navadami različnih jezikov - od imen dni in mesecev, do tega, ali uporabljajo decimalno vejico ali piko in načina zapisa valut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "44a629a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42,19 SIT'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "locale.currency(42.19)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6983ed1",
   "metadata": {},
   "source": [
    "(haha, tolarji!)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bda93f58",
   "metadata": {},
   "source": [
    "### `datetime`\n",
    "\n",
    "Bistvo modula `datetime` ([dokumentacija](https://docs.python.org/3/library/datetime.html)) je manipulacija z datumi. Z njim lahko odštejete dva časa in izveste, koliko let, mesecev, dni, ur, minut, sekund je med njima. Ali pa pripravite objekt vrste `timedelta`, ki bo, recimo, dve meseca in tri dni, ter to prištejete k nekemu datumu.\n",
    "\n",
    "Še pomembneje: modul zna pretvarjati čase iz nizov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "25a6e8b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2023, 11, 13, 21, 14)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "datetime.strptime(\"13. november 2023, 21:14\", \"%d. %B %Y, %H:%M\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33eb0916",
   "metadata": {},
   "source": [
    "Najprej čudni import: iz modula `datetime` uvozimo \"funkcijo\" `datetime`. (V resnici ni funkcija, temveč tip, vendar za tole zdaj ni časa. :)\n",
    "\n",
    "Funkcija `strptime` zahteva niz, v katerem je zapisan datum, in niz, ki pove obliko niza - spet s črkami, kot smo jih videli v `strftime`. Do delov rezultata spet dostopamo z imeni polj."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "dfffd4b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "cas = datetime.strptime(\"13. november 2023, 21:14\", \"%d. %B %Y, %H:%M\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "7016fa5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cas.day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "ff3333da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cas.hour"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "514a2160",
   "metadata": {},
   "source": [
    "Tole vam bo znalo razkopati datum v prilično poljubni obliki. Takole opravimo z Američani."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "7d559c26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2023, 11, 13, 0, 0)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.strptime(\"11/13/2023\", \"%m/%d/%Y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e3cfe86",
   "metadata": {},
   "source": [
    "Takole pa z Američani, ki pišejo leto brez stoletij."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "5e9c8ee7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2023, 11, 13, 0, 0)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.strptime(\"11/13/23\", \"%m/%d/%y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a30a872",
   "metadata": {},
   "source": [
    "### `calendar`\n",
    "\n",
    "Zadnji od treh modulov, povezanih s časom, je preprosti `calendar` ([dokumentacije](https://docs.python.org/3/library/calendar.html)). Ta vsebuje stvari kot so imena dni, mesecev in podobno."
   ]
  }
 ],
 "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
}