pn/predavanja/08b Numpy - naslednji koraki.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c5c19fc3",
   "metadata": {},
   "source": [
    "## Večdimenzionalne tabele\n",
    "\n",
    "Tabele so lahko tudi večdimenzionalne. \"Več-\" naj bo, za začetek, kar \"dvo-\". (Ker je dve ravno število dimenzij, ki jih imajo sodobni zasloni in projektorji, se dvodimenzionalne tabele ravno še dobro vidi. Za tridimenzionalne bi potrebovali posebna očala, za štiri pa drugačno vesolje.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e0be5f16",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "19d36dfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[2, -7, 2], [5, 9, 1], [1, -0, 0], [-1, -2, -8]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f1811c47",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7,  2],\n",
       "       [ 5,  9,  1],\n",
       "       [ 1,  0,  0],\n",
       "       [-1, -2, -8]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4777ebf1",
   "metadata": {},
   "source": [
    "V Pythonu bi bil to seznam seznamov. Do tretje vrstice bi prišli z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0bc944fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1, -2, -8])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9505779d",
   "metadata": {},
   "source": [
    "in do drugega elementa v njej z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ab9802f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-8"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d17bbdb3",
   "metadata": {},
   "source": [
    "Numpyjeve tabele lahko indeksiramo z več indeksi v istih oklepajih. Namesto `a[3][2]` lahko pišemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a51946ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-8"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ed7828b",
   "metadata": {},
   "source": [
    "Za oba indeksa veljajo enake čarovnije kot za Pythonove indekse sicer. Tako lahko dobimo vse vrstice od druge do četrte in stolpce do zadnjega:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f7e03844",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  0],\n",
       "       [-1, -2]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:4, :-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a575708",
   "metadata": {},
   "source": [
    "Ali pa, recimo, vse vrstice drugega stolpca - z drugimi besedami, drugi stolpec."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6bd2d48d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  1,  0, -8])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac76fc29",
   "metadata": {},
   "source": [
    "Ker je stolpec enodimenzionalna reč, ga je Python pač prevrnil v enodimenzionalno tabelo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c78cf48",
   "metadata": {},
   "source": [
    "Ko smo ravno pri prevračanju, omenimo še splošno prevračanje: tabela ima \"metodo\" `T`, ki vrne transponirano tabelo. Narekovaji so potrebni, ker `T` v resnici ni metoda temveč nekaj drugega, o čemer se pri predmetu niti slučajno ne bomo učili. `T`-ja ni potrebno poklicati. Malo zato, ker bi oklepaji vzeli več prostora kot samo ime funkcije, malo zato, ker T prihaja iz matematike, kjer bi transponirano matriko $\\matrix{A}$ zapisali kot $\\matrix{A}^T$.\n",
    "\n",
    "Če je torej `a` takšna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ad0e86a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7,  2],\n",
       "       [ 5,  9,  1],\n",
       "       [ 1,  0,  0],\n",
       "       [-1, -2, -8]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5f4c7da",
   "metadata": {},
   "source": [
    "je `a.T` takšna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "08cc6074",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  5,  1, -1],\n",
       "       [-7,  9,  0, -2],\n",
       "       [ 2,  1,  0, -8]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2352287",
   "metadata": {},
   "source": [
    "Stolpci so postali vrstice, vrstice stolpci. Tabelo bomo presenetljivo pogosto takole zasukali, saj bo določene reči lažje narediti z vrsticami, kot bi jih bilo s stolpci.\n",
    "\n",
    "Tridimenzionalne tabele se vedejo podobno kot dvodimenzionalne. Imajo pač en indeks več, pa izpišejo se bolj nerodno. In štiri- ali petdimenzionalne enako. `.T` pa obrne vrstni red dimenzij. (Vendar ga pri takih tabelah vsaj jaz še nisem uporabil. No, pa take tabele tudi.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c15e381a",
   "metadata": {},
   "source": [
    "## Še par načinov sestavljanja tabel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51bdc2e1",
   "metadata": {},
   "source": [
    "Tabele smo doslej sestavljali tako, da smo poklicali `np.array` in podali pripravljen seznam (ali seznam seznamov, če smo želeli dve dimenziji) v Pythonu. (Prejšnji teden pa tudi tako, da smo poklicali `np.genfromtxt`, ki je prebral datoteko v tabelo, še več tabel pa smo dobili z raznimi načini indeksiranja tako prebrane tabele.)\n",
    "\n",
    "Včasih si moramo pripraviti prazno tabelo - tabelo ničel, enic ali česa drugega. Kot argument podamo terko z dimenzijami. Če terka vsebuje dva elementa, bo tabela dvodimenzionalna. Če pet, bo petdimenzionalna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1740e20f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((2, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4f935e91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((2, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a81152d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[42, 42, 42, 42],\n",
       "       [42, 42, 42, 42]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((2, 4), 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae01b00a",
   "metadata": {},
   "source": [
    "Pogosto potrebujemo tudi tabelo zaporednih števil."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "183c7261",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adefb479",
   "metadata": {},
   "source": [
    "Ali, recimo, 15 enako razmaknjenih števil med 0 in 3.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3fc12a14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  , 1.25, 1.5 , 1.75, 2.  , 2.25, 2.5 ,\n",
       "       2.75, 3.  , 3.25, 3.5 ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 3.5, 15)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1f7555f",
   "metadata": {},
   "source": [
    "Mimogrede spoznajmo še en način za ustvarjanje tabele: pripravimo tabelo s petimi vrsticami in tremi stolpci naključnih števil med -1 in 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "25f4a7b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.28957304, -0.35546214],\n",
       "       [-0.05671772,  0.26460191],\n",
       "       [ 0.69538276, -0.47511787],\n",
       "       [-0.97905431,  0.60535218],\n",
       "       [-0.07506103, -0.55767802]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = np.random.uniform(-1, 1, (5, 2))\n",
    "\n",
    "r"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cfa1be2",
   "metadata": {},
   "source": [
    "V gornjih tabelah so bili `int`-i ali `float`-i; kdaj se je zgodilo kaj, vidimo iz izpisa. Če sestavimo tabelo iz seznama ali z `np.full`, je tip odvisen od argumenta. Če je v seznamu kak `float`, bo to tabela `float`-ov, če sami `int`-i, tabela `int`-ov.\n",
    "\n",
    "Seveda pa\n",
    "\n",
    "1. Lahko o tem sami odločamo\n",
    "2. `numpy` ne pozna samo enega `int`-a in enega `float`-a.\n",
    "\n",
    "Čas za nov mednaslov. :)\n",
    "\n",
    "## Lastnosti tabele"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6870c0d",
   "metadata": {},
   "source": [
    "Spomnimo se na `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4714a250",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7,  2],\n",
       "       [ 5,  9,  1],\n",
       "       [ 1,  0,  0],\n",
       "       [-1, -2, -8]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "53e4f1b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ecdc18b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "813bd81c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c6a03a97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8a99d433",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.itemsize"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a095f59e",
   "metadata": {},
   "source": [
    "`ndim` je povedal, da je tabela dvodimenzionalna, `shape` pove njeno obliko (dolžina `shape` je ravno `ndim`) in `size` pove število elementov (kar je ravno produkt tega, kar imamo v `shape`). Če tako pogledamo, bi bilo dovolj imeti `shape`, saj je možno vse drugo izračunati iz njega. Da, vendar `size` včasih potrebujemo in `ndim` včasih preverimo, zato je čisto praktično, da obstajata.\n",
    "\n",
    "Bolj zanimivi sta zadnji stvari. `dtype` pove podatkovni tip elementov. Numpy ima svoje podatkovne tipe, tako številske kot ... druge. Elementi tabele `a` so tipa `int64`, kar pomeni `int`, shranjen s 64 biti. `itemsize` je število bajtov, ki jih zasede posamezni element. Ker je vsaj bajt sestavljen iz 8 bitov (kar se zdi danes logično, zgodovina računalništva pa beleži tudi drugačne modele), je 64 bitov 8 bajtov.\n",
    "\n",
    "Zakaj ravno `int64`? Zakaj ne `int40`? (Ker ne obstaja. :) Zakaj ne `int32`? V osnovi so v tabeli `int`-i, katera različica (*širina*) `int`-a bo privzeta, pa je odvisno od, hm, operacijskega sistema oziroma vedenja `numpy`-ja na posameznem operacijskem sistemu. Na MS Windows so bili privzeti `int`-i še nedavno (ali pa še vedno?) 32-bitni, četudi je operacijski sistem že davno 64-biten. Na macOS in Linux so 64-bitni. (Kako vem? Ker nam je že povzročalo veselje pri programiranju programov, ki bi morali delovati tudi na MS Windows, vendar so skrivnostno crkovali.)\n",
    "\n",
    "Najboljše je, da se glede tega ne vznemirjate preveč, saj bo za vaše potrebe dovolj, da se delate, da so tabele bodisi `int` ali `float`.\n",
    "\n",
    "Kakšnega tipa bo tabela, je odvisno od tega, kaj zapišemo vanjo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a19a215c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([2, 8, -1]).dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "eca8b49b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([2, 1, 3.14, 8]).dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e72619b8",
   "metadata": {},
   "source": [
    "Tabele, ki jih sestavimo z `zeros` in `ones` so praviloma `float`, razen če zahtevamo drugače. Prav tako lahko eksplicitno zahtevamo drugačen tip, kadar tabelo sestavimo z `np.array` ali katero drugo funkcijo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "db3485e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1.])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "72f8d09a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(4, dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "3831ee86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1.])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(4, dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b31223b1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(4, dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f6f43faa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3], dtype=float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f16cbe88",
   "metadata": {},
   "source": [
    "## Spreminjanje lastnosti tabele\n",
    "\n",
    "Spremenimo lahko obliko tabele ali njen tip. Točneje: iz tabele lahko naredimo drugo tabelo, ki ima drugačno obliko ali tip elementov.\n",
    "\n",
    "Obliko spreminjamo z `reshape`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9a60457b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7,  2],\n",
       "       [ 5,  9,  1],\n",
       "       [ 1,  0,  0],\n",
       "       [-1, -2, -8]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c0e02640",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7,  2,  5,  9,  1],\n",
       "       [ 1,  0,  0, -1, -2, -8]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.reshape(2, 6)\n",
    "\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17b6afd8",
   "metadata": {},
   "source": [
    "In tu se začne numpy-jeva magija. `b` je le drugačen pogled na pomnilnik, v katerem je shranjen `a`. Podatki se tu niso kopirali, torej nismo izgubljali ne časa ne dodatnega pomnilnika. A to za nas ni posebej pomembno - vsaj dokler te tabele ne spreminjamo. Spreminjanje `b`-ja bi namreč spremenilo tudi `a`.\n",
    "\n",
    "Ko obliko tabele, mora imeti nova tabela enako število elementov. Tabelo 3x4 lahko spremenimo v 2x6 ali celo 1x12, ne pa v 3x5.\n",
    "\n",
    "Eno od dimenzij lahko nastavimo na `-1` pa bo numpy sam izračunal, kakšna mora biti. Če hočemo spraviti `a` v dva stolpca in se nam danes ne da računati, koliko je 3 x 4 / 2, napišemo kar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "ad80f3f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7],\n",
       "       [ 2,  5],\n",
       "       [ 9,  1],\n",
       "       [ 1,  0],\n",
       "       [ 0, -1],\n",
       "       [-2, -8]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(-1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e87acbe",
   "metadata": {},
   "source": [
    "`a` se pri tem seveda ni spremenil. To je nova tabela (oz. nov pogled na obstoječo tabelo).\n",
    "\n",
    "Tip spreminjamo z `astype`. Tu dobimo novo tabelo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "24806404",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7,  2],\n",
       "       [ 5,  9,  1],\n",
       "       [ 1,  0,  0],\n",
       "       [-1, -2, -8]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "24eb778f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2., -7.,  2.],\n",
       "       [ 5.,  9.,  1.],\n",
       "       [ 1.,  0.,  0.],\n",
       "       [-1., -2., -8.]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.astype(float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "095394e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True, False, False],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.astype(bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e4699c0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['2', '-7', '2'],\n",
       "       ['5', '9', '1'],\n",
       "       ['1', '0', '0'],\n",
       "       ['-1', '-2', '-8']], dtype='<U5')"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.astype(\"U5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5fb346a",
   "metadata": {},
   "source": [
    "Ups, kakšen tip je `U5`? Niz (U kot Unicode) z največ petimi znaki.\n",
    "\n",
    "Dovolj naštevanja, čas je za primer.\n",
    "\n",
    "## Numpy na dražbi brez anonimnosti\n",
    "\n",
    "Najprej preberimo podatke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f5f591c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "zapisnik = np.genfromtxt(\n",
    "    \"../domace-naloge/03-drazba-brez-anonimnosti/zapisnik.txt\",\n",
    "    delimiter=\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "734c431f",
   "metadata": {},
   "source": [
    "Funkciji `np.getfromtxt` lahko podamo bodisi ime datoteke bodisi odprto datoteko. Slednje je posebej praktično, če smo na Windows in moramo še določati `encoding`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "026c9986",
   "metadata": {},
   "outputs": [],
   "source": [
    "zapisnik = np.genfromtxt(\n",
    "    open(\"../domace-naloge/03-drazba-brez-anonimnosti/zapisnik.txt\",\n",
    "         encoding=\"utf-8\"),\n",
    "    delimiter=\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0ff9d27",
   "metadata": {},
   "source": [
    "Začetek tabele je tak."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "97aa385c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[nan, nan, 31.],\n",
       "       [nan, nan, 33.],\n",
       "       [nan, nan, 35.],\n",
       "       [nan, nan, 37.],\n",
       "       [nan, nan, 40.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zapisnik[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc4b02a5",
   "metadata": {},
   "source": [
    "`nan`? `nan` pomeni *not a number*. Da, seveda, prva dva stolpca vsebujeta imena predmetov in ljudi, not a number.\n",
    "\n",
    "Določimo, naj bo `dtype` niz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "047c7125",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['slika', 'Berta', '31'],\n",
       "       ['slika', 'Ana', '33'],\n",
       "       ['slika', 'Berta', '35'],\n",
       "       ['slika', 'Fanči', '37'],\n",
       "       ['slika', 'Ana', '40']], dtype='<U21')"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zapisnik = np.genfromtxt(\n",
    "    \"../domace-naloge/03-drazba-brez-anonimnosti/zapisnik.txt\",\n",
    "    delimiter=\",\",\n",
    "    dtype=str)\n",
    "\n",
    "zapisnik[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a244abc4",
   "metadata": {},
   "source": [
    "(Preden nadaljujemo: numpy pravi `dtype='U12'`. To pomeni niz z največ 20 znaki.)\n",
    "\n",
    "Pa imamo dvodimenzionalno tabelo. Vendar bi bilo pravzaprav bolj praktično imeti tri spremenljivke, `predmeti`, `osebe` in `cene`, vsaka bi imela svoj stolpec.\n",
    "\n",
    "Lahko bi se šli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "cb1ca123",
   "metadata": {},
   "outputs": [],
   "source": [
    "predmeti = zapisnik[:, 0]\n",
    "osebe = zapisnik[:, 1]\n",
    "cene = zapisnik[:, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4732212",
   "metadata": {},
   "source": [
    "vendar obstaja prikladen trik: tabelo s tremi stolpci in bogvekoliko vrsticami prevrnimo v tabelo s tremi vrsticami in bogveliko stolpci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "4511ccf9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['slika', 'slika', 'slika', 'slika', 'slika'],\n",
       "       ['Berta', 'Ana', 'Berta', 'Fanči', 'Ana'],\n",
       "       ['31', '33', '35', '37', '40']], dtype='<U21')"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zapisnik.T[:, :5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4558231d",
   "metadata": {},
   "source": [
    "Da ne bi bilo predolgo, smo, tako kot prej pet vrstic, zdaj izpisali le pet stolpcev. (Poglej kako! Prvi indeks je `:`, da dobimo vse tri vrstice, drugi `:5`, da dobimo le prvih pet stolpcev."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b537bef",
   "metadata": {},
   "source": [
    "V tako prevrnjeni tabeli je `zapisnik.T[0]` prva vrstica, `zapisnik.T[1]` druga in `zapisnik.T[2]` tretja. To je imenitno, ker lahko te tri vrstice preprosto razpakiramo v tri spremenljivke!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "ec26f34f",
   "metadata": {},
   "outputs": [],
   "source": [
    "predmeti, osebe, cene = zapisnik.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "cd4134ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['slika', 'slika', 'slika', 'slika', 'slika', 'slika',\n",
       "       'pozlačen dežnik', 'Meldrumove vaze', 'Meldrumove vaze',\n",
       "       'Meldrumove vaze', 'Meldrumove vaze', 'Meldrumove vaze',\n",
       "       'Meldrumove vaze', 'Meldrumove vaze', 'Meldrumove vaze'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predmeti[:15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "3b233706",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Berta', 'Ana', 'Berta', 'Fanči', 'Ana', 'Fanči', 'Ema', 'Greta',\n",
       "       'Ana', 'Greta', 'Ana', 'Fanči', 'Ana', 'Greta', 'Ana'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "osebe[:15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "a5b09267",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['31', '33', '35', '37', '40', '45', '29', '44', '46', '48', '53',\n",
       "       '57', '60', '61', '63'], dtype='<U21')"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cene[:15]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9338f852",
   "metadata": {},
   "source": [
    "Aha, cene so nizi, potrebno jih bo spremeniti v številke. Zamahnemo s čarobno paličko numpyja, pa je."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "07a49098",
   "metadata": {},
   "outputs": [],
   "source": [
    "cene = cene.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "0edc6fd0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 31,  33,  35,  37,  40,  45,  29,  44,  46,  48,  53,  57,  60,\n",
       "        61,  63,  67,  71,  76,  78,  50,  55,  60,  61,  62,  65,  68,\n",
       "        70,  74,  76,  80,  83,  30,  32,  37,  39,  43,  44,  45,  50,\n",
       "        53,  55,  58,  61,  63,  68,  72,  76,  77,  81,  85,  86,  90,\n",
       "        92,  94,  97,  98,  99, 100, 103, 107,  15,  27,  30,  35,  39,\n",
       "        40,  45,  47,  49,  53,  55,  58,  59,  62,  63,  16,  21])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cene"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74d024cb",
   "metadata": {},
   "source": [
    "Zdaj pa le po domači nalogi.\n",
    "\n",
    "### 1. Izpiši, kateri predmet je dosegel najvišjo ceno, kakšno in kdo ga je kupil.\n",
    "\n",
    "Najvišjo ceno je trivialno najti,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "f0cb1e59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "107"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(cene)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fa6c353",
   "metadata": {},
   "source": [
    "Nas pa zanima tudi, za kateri predmet gre in kdo ga je kupil. Zanima nas torej, kaj je v tabelah `predmeti` in `osebe` na tistem mestu, kjer je v `cene` številka 107. Torej ne potrebujemo (ali pa vsaj: ne potrebujemo samo) največjega števila v `cene` temveč tudi (in predvsem) njegov indeks.\n",
    "\n",
    "Pomnite li, kako smo pisali funkcijo `argmax`? Python je nima, Numpy pač."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "32fd00bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(cene)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f247fd5f",
   "metadata": {},
   "source": [
    "Potem pa ni problema:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "a19dba2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Najdražji predmet, kip, je za 107 kupila Dani.\n"
     ]
    }
   ],
   "source": [
    "naj_i = np.argmax(cene)\n",
    "\n",
    "print(f\"Najdražji predmet, {predmeti[naj_i]}, je za {cene[naj_i]} kupila {osebe[naj_i]}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea150c91",
   "metadata": {},
   "source": [
    "### 2. Izpiši končne cene vseh predmetov\n",
    "\n",
    "Prejšnji teden je bilo preprosto: imeli smo le seznam cen in cene različnih predmetov so bile razmejene z `-1`. Zdaj imamo seznam predmetov in ugotoviti je treba, v katerih vrsticah se predmet zamenja.\n",
    "\n",
    "Trik poznamo že od prejšnjič: zadnjič smo računali razlike med zaporednimi vrsticami (ko nas je zanimalo, za koliko se kolesar dvigne ali spusti med dvema zaporednima meritvama). Zdaj nas zanima preprosto, ali sta dve zaporedni vrstici različni."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "592d6380",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False,  True,  True, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "        True, False, False, False, False, False, False, False, False,\n",
       "       False, False, False,  True, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False,  True,  True, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True, False])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predmeti[1:] != predmeti[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ce1b6c7",
   "metadata": {},
   "source": [
    "Poiščimo indekse, kjer pride do sprememb."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "6d4648d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6, 18, 30, 59, 60, 74])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spremembe = np.flatnonzero(predmeti[1:] != predmeti[:-1])\n",
    "\n",
    "spremembe"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2354b3e7",
   "metadata": {},
   "source": [
    "Ker smo izpustili prvo vrstico, so tole v bistvu indekse *zadnjih* vrstic vsakega predmeta. Manjka le zadnji indeks; ta je pač `len(predmeti) - 1`.\n",
    "\n",
    "Če k spremembam prištejemo `1`, pa dobimo *prve* vrstice za vsak predmet. Zdaj nam zmanjka prva vrstica prvega predmeta; te ja preprosto `0`.\n",
    "\n",
    "Pripravimo tabeli z indeksi začetnih (ki jih bomo potrebovali kasneje) in končnih (ker jih bomo potrebovali zdaj) vrstic, ki opisujejo posamezni predmet. Manjkajoči prvi in zadnji element pripnemo z `np.hstack`. Spet ne spreglejmo: `hstack` kot argument pričakuje terko s tabelami, ki naj jih spne, zato dvojni oklepaji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "06791ab2",
   "metadata": {},
   "outputs": [],
   "source": [
    "zacetni = np.hstack(([0], spremembe + 1))\n",
    "koncni = np.hstack((spremembe, [len(predmeti) - 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18f836ce",
   "metadata": {},
   "source": [
    "Zdaj, ko imamo končne indekse, vemo, da so končne cene"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "fb179694",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 45,  29,  78,  83, 107,  15,  63,  21])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cene[koncni]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad822294",
   "metadata": {},
   "source": [
    "Pripadajoči predmeti pa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "ed6f10b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['slika', 'pozlačen dežnik', 'Meldrumove vaze', 'skodelice', 'kip',\n",
       "       'čajnik', 'srebrn jedilni servis', 'perzijska preproga'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predmeti[koncni]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54401545",
   "metadata": {},
   "source": [
    "Tako lahko izpišemo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "28af816e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "slika                      45\n",
      "pozlačen dežnik            29\n",
      "Meldrumove vaze            78\n",
      "skodelice                  83\n",
      "kip                       107\n",
      "čajnik                     15\n",
      "srebrn jedilni servis      63\n",
      "perzijska preproga         21\n"
     ]
    }
   ],
   "source": [
    "for predmet, cena in zip(predmeti[koncni], cene[koncni]):\n",
    "    print(f\"{predmet:25} {cena:3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15cd8c6e",
   "metadata": {},
   "source": [
    "Seveda bi lahko poprej pripravili tabelo končnih predmetov in cen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "9dad18af",
   "metadata": {},
   "outputs": [],
   "source": [
    "konpred = predmeti[koncni]\n",
    "koncene = cene[koncni]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ba44ed1",
   "metadata": {},
   "source": [
    "To malo poenostavi `zip`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "346f95f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "slika                      45\n",
      "pozlačen dežnik            29\n",
      "Meldrumove vaze            78\n",
      "skodelice                  83\n",
      "kip                       107\n",
      "čajnik                     15\n",
      "srebrn jedilni servis      63\n",
      "perzijska preproga         21\n"
     ]
    }
   ],
   "source": [
    "for predmet, cena in zip(predmeti[koncni], cene[koncni]):\n",
    "    print(f\"{predmet:25} {cena:3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b133c999",
   "metadata": {},
   "source": [
    "Kaj pa, če bi želeli te predmete urediti po cenah?\n",
    "\n",
    "Urediti cene - znamo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "216028f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 15,  21,  29,  45,  63,  78,  83, 107])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(koncene)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03772e93",
   "metadata": {},
   "source": [
    "Vendar je problem, da bi zdaj radi preuredili imena predmetov enako, kot so tu preurejene cene. Se pravi, morali bi, hm, poznati indekse, ki preslikajo te številke iz originalne tabele, `koncene` v takole preurejeno tabelo, da bi potem enako preslikali imena predmetov.\n",
    "\n",
    "Ne razumemo gornjega stavka? Ne? OK, gremo počasi.\n",
    "\n",
    "Pomnite li imenitno našo funkcijo `argmax`, ki namesto največjega elementa vrne njegov indeks. Enako - in še bolj - imeniten je `argsort`, ki namesto urejene tabele vrne indekse, ki uredijo tabelo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "826b9333",
   "metadata": {},
   "outputs": [],
   "source": [
    "red = np.argsort(koncene)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "c7949780",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 1, 0, 6, 2, 3, 4])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "red"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96ec3203",
   "metadata": {},
   "source": [
    "Primerjajmo to s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "7449a1ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 45,  29,  78,  83, 107,  15,  63,  21])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncene"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc9fabaf",
   "metadata": {},
   "source": [
    "`red` nam pove tole: če hočeš seznam z urejenimi elementi `koncene`, moraš najprej vzeti element z indeksom `5`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "f1df1d3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncene[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f107080",
   "metadata": {},
   "source": [
    "nato tistega z indeksom 7,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "c0c6765b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncene[7]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af7d6eb3",
   "metadata": {},
   "source": [
    "potem onega z indeksom 1,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "5b9aea22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncene[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df90eb49",
   "metadata": {},
   "source": [
    "... ali, če skrajšamo zgodbo tako, da se spomnimo, da lahko tabelo indeksiramo z indeksi iz druge tabele:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "81e75611",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 15,  21,  29,  45,  63,  78,  83, 107])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncene[red]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b97fcc70",
   "metadata": {},
   "source": [
    "Ker so predmeti v `konpred` našteti tako, da jim pripadajo istoležne cene, moramo po enakem vrstnem redu pobrati še predmete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "77bf3074",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['čajnik', 'perzijska preproga', 'pozlačen dežnik', 'slika',\n",
       "       'srebrn jedilni servis', 'Meldrumove vaze', 'skodelice', 'kip'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "konpred[red]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1602abbe",
   "metadata": {},
   "source": [
    "Če želimo urediti padajočo, pač obrnemo vrstni `red`.\n",
    "\n",
    "Pa imamo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "9d38d8e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kip                       107\n",
      "skodelice                  83\n",
      "Meldrumove vaze            78\n",
      "srebrn jedilni servis      63\n",
      "slika                      45\n",
      "pozlačen dežnik            29\n",
      "perzijska preproga         21\n",
      "čajnik                     15\n"
     ]
    }
   ],
   "source": [
    "red = np.argsort(koncene)[::-1]\n",
    "\n",
    "for predmet, cena in zip(konpred[red], koncene[red]):\n",
    "    print(f\"{predmet:25} {cena:3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b11e274",
   "metadata": {},
   "source": [
    "### 3. Izpiši, koliko ponudb je bil deležen vsak izmed predmetov\n",
    "\n",
    "K nalogi dodajmo še, da morajo biti predmeti izpisani po padajočem številu ponudb.\n",
    "\n",
    "Če vemo, da so prve vrstice, ki se nanašajo na določen predmet v `koncni`, začetne pa v `zacetni`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "e6863834",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  6 18 30 59 60 74 76]\n",
      "[ 0  6  7 19 31 60 61 75]\n"
     ]
    }
   ],
   "source": [
    "print(koncni)\n",
    "print(zacetni)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e8fb2dd",
   "metadata": {},
   "source": [
    "nam je le odšteti tidve tabeli in prišteti 1, pa imamo število ponudb za vsak predmet. Število ponudb arguredimo in potem nadaljujemo tako kot prej."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "1b20e345",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kip                        29\n",
      "srebrn jedilni servis      14\n",
      "skodelice                  12\n",
      "Meldrumove vaze            12\n",
      "slika                       6\n",
      "perzijska preproga          2\n",
      "čajnik                      1\n",
      "pozlačen dežnik             1\n"
     ]
    }
   ],
   "source": [
    "ponudb = koncni - zacetni + 1\n",
    "\n",
    "red = np.argsort(ponudb)[::-1]\n",
    "\n",
    "for predmet, pon in zip(konpred[red], ponudb[red]):\n",
    "    print(f\"{predmet:25} {pon:3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e6fd4ce",
   "metadata": {},
   "source": [
    "### 4. Izpiši, za kateri predmet je bilo največ ponudb. Če si prvo mesto deli več predmetov, izpiši vse.\n",
    "\n",
    "Tole smo skoraj že naredili, pa še malo več. Le tisti del o izpisu več predmetov, ki si deli prvo mesto bi lahko dodali. Pa bomo zdaj naredili drugače: poiskali bomo predmet z največ ponudbami in izpisali vse, ki imajo toliko ponudb. To bo sicer le eden, a iz programa bo očitno, da bi jih lahko bilo več."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "8efdfde0",
   "metadata": {},
   "outputs": [],
   "source": [
    "ponudbe = koncni - zacetni + 1\n",
    "\n",
    "maska = ponudbe == np.max(ponudbe)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b67850e",
   "metadata": {},
   "source": [
    "Zdaj vsebuje `maska` `True` za vse elemente, ki imajo toliko ponudb, kolikor je `np.max(ponudbe)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "d63fdd59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6,  1, 12, 12, 29,  1, 14,  2])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ponudbe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "daa55a05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False,  True, False, False, False])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maska"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c977c86",
   "metadata": {},
   "source": [
    "Sicer je `True` le eden (tam, kjer je 29), lahko pa bi jih bilo tudi več.\n",
    "\n",
    "Zdaj izpišimo te predmete: masko, ki smo jo sestavili iz `ponudbe`, uporabimo na `predmeti`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "35500d6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kip\n"
     ]
    }
   ],
   "source": [
    "for predmet in konpred[maska]:\n",
    "    print(predmet)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af9084c4",
   "metadata": {},
   "source": [
    "## Še malo numpy-ja: osi\n",
    "\n",
    "Nazaj k dvodimenzionalni matriki `a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "136bf68c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7,  2],\n",
       "       [ 5,  9,  1],\n",
       "       [ 1,  0,  0],\n",
       "       [-1, -2, -8]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8253c396",
   "metadata": {},
   "source": [
    "Kaj vrnejo funkcije, kot sta `np.max` in `np.sum`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "35c95998",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "9a54e91a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60d8e952",
   "metadata": {},
   "source": [
    "To je včasih v resnici uporabno, vendar redko. Pogosteje želimo vsoto po vrsticah ali po stolpcih.\n",
    "\n",
    "Matrika ima dve osi. Prva gre dol, po vrsticah (pač: prvi indeks so vrstice), druga po stolpcih (ker: drugi indeks). Funkcije `np.max`, `np.sum` in druge, kjer je to smiselno (pri `argsort`, recimo, ni) sprejmejo dodatni argument `axis`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "395290ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 9, 2])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(a, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "a5243f19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  9,  1, -1])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a82360e",
   "metadata": {},
   "source": [
    "Prva, `axis=0`, poišče največji element vzdolž indeksa `0`, torej vrne tabelo z največjim elementom v vsakem stolpcu. Druga poišče največje element vsake vrstice, torej vzdolž indeksa `1`.\n",
    "\n",
    "Enako `sum`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "73afdb11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  0, -5])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(a, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "7af3e234",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -3,  15,   1, -11])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "799c6d85",
   "metadata": {},
   "source": [
    "Kaj pa tole: obdržati želimo le vrstice, ki vsebujejo same nenegativne elemente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "f5b602d5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2, -7,  2],\n",
       "       [ 5,  9,  1],\n",
       "       [ 1,  0,  0],\n",
       "       [-1, -2, -8]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "822ba24f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True,  True,  True],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a >= 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57d33c24",
   "metadata": {},
   "source": [
    "`np.all(a >= 0)` nam pove, ali so *vsi* elementi `a` nenegativni. (Niso.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "50b6bfc9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(a >= 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04645651",
   "metadata": {},
   "source": [
    "Vendar nas to zanima v smeri stolpcev, v smeri 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "07285d44",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True, False])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(a >= 0, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d0b259c",
   "metadata": {},
   "source": [
    "To uporabimo kot masko za vrstice `a`-ja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "02c60ea3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 9, 1],\n",
       "       [1, 0, 0]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[np.all(a >= 0, axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6348d57d",
   "metadata": {},
   "source": [
    "Bi znali prešteti, koliko pozitivnih elementov vsebuje posamični stolpec?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "ab4db357",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 1, 2])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(a > 0, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d31bc249",
   "metadata": {},
   "source": [
    "## Numpy, koliko je $\\pi$?\n",
    "\n",
    "Če slučajno pozabimo, koliko je $\\pi$, je to preprosto izračunati.\n",
    "\n",
    "Predstavljamo si krog s središčem v (0, 0) in polmerom 1. Ploščina tega kroga je $\\pi r^2 = \\pi 1^2 = \\pi$.\n",
    "\n",
    "Potem si predstavljamo kvadrat, ki ga očrtamo temu krogu. Postavimo ga vzporedno s koordinatami, z drugimi besedami, po x in y gre ta kvadrat od -1 do 1. Njegova stranica je 2 in ploščina, očitno 4.\n",
    "\n",
    "Zdaj naključno izžrebamo $N$ (recimo 1000) točk znotraj kvadrata. Kakšen delež teh točk je znotraj kroga? Ker je razmerje med ploščino kroga in kvadrata $\\pi / 4$, je pričakovati, da bo v krogu $k = N \\pi / 4$ točk.\n",
    "\n",
    "Če smo torej pozabili $\\pi$, sprogramiramo takšen poskus. Naključno izžrebamo koordinate $N$ točk, pogledamo koliko jih je v krogu (to označimo s $k$) in potem iz gornje formule izrazimo $\\pi$: $\\pi = 4 k / N$. \n",
    "\n",
    "Gremo. Točke bomo izžrebali z `np.random.uniform(-1, 1, (N, 2))`, ki bo vrnil tabelo velikosti (N, 2) z naključnimi števili med -1 in 1.\n",
    "\n",
    "Da bo pregledneje bomo za začetek delali z desetimi točkami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "bec2c248",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.11995016,  0.09098891],\n",
       "       [-0.81012809, -0.79357372],\n",
       "       [-0.85570538,  0.35303725],\n",
       "       [ 0.85267372, -0.36440988],\n",
       "       [ 0.27940679, -0.63779546],\n",
       "       [-0.91855011, -0.89444881],\n",
       "       [-0.85184532, -0.74527486],\n",
       "       [-0.9410507 , -0.09879938],\n",
       "       [ 0.54732715, -0.13532082],\n",
       "       [-0.98596715, -0.71856324]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 10\n",
    "\n",
    "tocke = np.random.uniform(-1, 1, (N, 2))\n",
    "\n",
    "tocke"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60ea91f5",
   "metadata": {},
   "source": [
    "Prvi stolpec so koordinate x, druge y. Razdaljo od točke do središča koordinatnega sistema (in s tem kroga) dobimo tako, da seštejemo kvadrate x in y ter to korenimo. Hvala, $\\pi$tagora."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "38735de4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.02266702, 1.28606678, 0.856867  , 0.85984703, 0.48485121,\n",
       "       1.64377297, 1.28107507, 0.89533775, 0.31787873, 1.48846435])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(tocke ** 2, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1c8cb23",
   "metadata": {},
   "source": [
    "Vidimo? `np.sum(..., axis=1)` sešteva \"vodoravno\", dobimo torej ravno vsoto (kvadratov) prvega in drugega stolpca.\n",
    "\n",
    "To korenimo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "4c36fdde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.15055571, 1.13404884, 0.92567111, 0.92727937, 0.69631258,\n",
       "       1.2820971 , 1.13184587, 0.94622288, 0.56380735, 1.22002637])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(np.sum(tocke ** 2, axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d43f970",
   "metadata": {},
   "source": [
    "Točka je znotraj kroga s polmerom `1`, če je njena razdalja od izhodišča manjša od 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "57464869",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True,  True, False, False,  True,  True,\n",
       "       False])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(np.sum(tocke ** 2, axis=1)) < 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8044330a",
   "metadata": {},
   "source": [
    "(Na tem mestu opazimo, da je korenjenje nepotrebno. Koren je manjši od 1 natančno takrat, ko je število že samo manjše od 1.)\n",
    "\n",
    "In zdaj samo preštejemo, koliko `True`-jev imamo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "9b0f8726",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(np.sum(tocke ** 2, axis=1) < 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dba5430f",
   "metadata": {},
   "source": [
    "To je naš `k`. Ponovimo na 1000 točkah in izračunajmo $\\pi$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "b24b5585",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.188"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 1000\n",
    "\n",
    "k = np.sum(np.sum(np.random.uniform(-1, 1, (N, 2)) ** 2, axis=1) < 1)\n",
    "\n",
    "4 * k / N"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5c01bfc",
   "metadata": {},
   "source": [
    "No, recimo. Brez težav lahko ponovimo reč z več točkami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "acf234f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.143676"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 1000000\n",
    "\n",
    "k = np.sum(np.sum(np.random.uniform(-1, 1, (N, 2)) ** 2, axis=1) < 1)\n",
    "\n",
    "4 * k / N"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "334418c1",
   "metadata": {},
   "source": [
    "## Unikatni elementi\n",
    "\n",
    "Spoznajmo še eno zanimivo funkcijo: `np.unique` vrne tabelo vseh različnih elementov neke tabele. Takole, recimo, dobimo tabelo vseh, ki so sodelovale na dražbi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "2fa95f61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanči', 'Greta', 'Helga'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(osebe)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f48761b",
   "metadata": {},
   "source": [
    "Funkcija je posebej zanimiva zaradi tega, kar lahko vrne poleg te tabele. Če ji dodamo argument `return_counts=True`, vrne še število pojavitev vsakega od teh imen - torej, kolikokrat je posamična oseba dvigovala ceno (vštevši prvo ponudbo)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "9ce42757",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array(['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanči', 'Greta', 'Helga'],\n",
       "       dtype='<U21'),\n",
       " array([ 6, 11, 13, 13, 11,  5, 15,  3]))"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(osebe, return_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8f8c54e",
   "metadata": {},
   "source": [
    "Ker vrne dve stvari, je to najbolj praktično razpakirati v dve spremenljivki. In že lahko povemo, kdo je bil najbolj zagret."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "32e23ec7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Greta'"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena, visanja = np.unique(osebe, return_counts=True)\n",
    "\n",
    "imena[np.argmax(visanja)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db3b7dd1",
   "metadata": {},
   "source": [
    "Drug zanimiv dodatni argument je `return_inverse=True`. Klic `np.unique(a, return_inverse=True)` bo poleg tabele unikatov vrnil tabelo, ki bo imela toliko elementov kot `a`. Vsak element pove, na katero mesto unikatne tabele se preslika posamični element `a`-ja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "1e7d91fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "imena, indeksi = np.unique(osebe, return_inverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "6232cd62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Berta', 'Ana', 'Berta', 'Fanči', 'Ana', 'Fanči', 'Ema', 'Greta',\n",
       "       'Ana', 'Greta', 'Ana', 'Fanči', 'Ana', 'Greta', 'Ana', 'Cilka',\n",
       "       'Greta', 'Fanči', 'Cilka', 'Dani', 'Berta', 'Dani', 'Berta',\n",
       "       'Dani', 'Berta', 'Dani', 'Berta', 'Dani', 'Berta', 'Dani', 'Berta',\n",
       "       'Cilka', 'Ema', 'Berta', 'Ema', 'Cilka', 'Berta', 'Cilka', 'Dani',\n",
       "       'Cilka', 'Greta', 'Dani', 'Cilka', 'Dani', 'Greta', 'Cilka',\n",
       "       'Greta', 'Ema', 'Dani', 'Greta', 'Cilka', 'Dani', 'Greta', 'Ema',\n",
       "       'Dani', 'Ema', 'Greta', 'Ema', 'Greta', 'Dani', 'Berta', 'Ema',\n",
       "       'Helga', 'Ema', 'Cilka', 'Helga', 'Greta', 'Ema', 'Cilka', 'Ema',\n",
       "       'Greta', 'Cilka', 'Greta', 'Cilka', 'Greta', 'Fanči', 'Helga'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "osebe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "0fb653f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 1, 5, 0, 5, 4, 6, 0, 6, 0, 5, 0, 6, 0, 2, 6, 5, 2, 3, 1, 3,\n",
       "       1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 4, 1, 4, 2, 1, 2, 3, 2, 6, 3, 2, 3,\n",
       "       6, 2, 6, 4, 3, 6, 2, 3, 6, 4, 3, 4, 6, 4, 6, 3, 1, 4, 7, 4, 2, 7,\n",
       "       6, 4, 2, 4, 6, 2, 6, 2, 6, 5, 7])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indeksi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "bd7b6864",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanči', 'Greta', 'Helga'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8256de0e",
   "metadata": {},
   "source": [
    "Z `imena` in `indeksi` lahko (če bi želeli, a nam seveda ni treba) rekonstruiramo osebe. Prvi trije elementi `indeksi` so 1, 0, 1, 5. Pripadajoči elementi `imena` so (prvi) Berta, (ničti) Ana, prvi (Berta) in (peti) Fanči - kar so natančno prvi elementi `osebe`. Torej "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "dcc2d45e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Berta', 'Ana', 'Berta', 'Fanči', 'Ana', 'Fanči', 'Ema', 'Greta',\n",
       "       'Ana', 'Greta', 'Ana', 'Fanči', 'Ana', 'Greta', 'Ana', 'Cilka',\n",
       "       'Greta', 'Fanči', 'Cilka', 'Dani', 'Berta', 'Dani', 'Berta',\n",
       "       'Dani', 'Berta', 'Dani', 'Berta', 'Dani', 'Berta', 'Dani', 'Berta',\n",
       "       'Cilka', 'Ema', 'Berta', 'Ema', 'Cilka', 'Berta', 'Cilka', 'Dani',\n",
       "       'Cilka', 'Greta', 'Dani', 'Cilka', 'Dani', 'Greta', 'Cilka',\n",
       "       'Greta', 'Ema', 'Dani', 'Greta', 'Cilka', 'Dani', 'Greta', 'Ema',\n",
       "       'Dani', 'Ema', 'Greta', 'Ema', 'Greta', 'Dani', 'Berta', 'Ema',\n",
       "       'Helga', 'Ema', 'Cilka', 'Helga', 'Greta', 'Ema', 'Cilka', 'Ema',\n",
       "       'Greta', 'Cilka', 'Greta', 'Cilka', 'Greta', 'Fanči', 'Helga'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[indeksi]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cce5058",
   "metadata": {},
   "source": [
    "Tega seveda ne počnemo, saj osebe že imamo. Indekse uporabimo za kaj drugega."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e0b1d06",
   "metadata": {},
   "source": [
    "## Numpy na dodatni dražbi\n",
    "\n",
    "### 5. Za vsako osebo izpiši, koliko je porabila na dražbi\n",
    "\n",
    "Tole bo zahtevalo nekaj norega indeksiranja. Dovolj norega - in, predvsem, zelo potratnega - da bi to nalogo v praksi rešili s slovarji in zanko v Pythonu. Vendar bo poučno z vidika numpyja.\n",
    "\n",
    "Pripravimo si tabelo ničel, ki ima toliko vrstic, kolikor je prodanih predmetov, in toliko stolpcev, kolikor je oseb. Torej: za vsako osebo drug stolpec."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "20a423b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena, indeksi = np.unique(osebe, return_inverse=True)\n",
    "\n",
    "nakupi = np.zeros((len(koncni), len(imena)), dtype=int)\n",
    "nakupi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33e61d50",
   "metadata": {},
   "source": [
    "In zdaj nori del. Unique je vsaki osebi priredil indeks. Ana je 0, Berta je 1 in tako naprej. `indeksi` za vsako vrstico iz podatkov pove, kakšen je indeks osebe, na katero se vrstica nanaša. `imena[indeksi]` so, vemo, pač kar imena oseb. Tabela `koncni` vsebuje indekse tistih vrstic, ki se nanašajo na končne cene. `indeksi[koncni]` so potem indeksi imen oseb, ki so dejansko kupile posamični predmet. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "d3d54a97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 4, 2, 1, 3, 1, 6, 7])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "indeksi[koncni]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ed7891d",
   "metadata": {},
   "source": [
    "Prvi predmet je kupila oseba 5, drugega oseba 4 in tako naprej. Oseba 1 je kupila dva predmeta. Kdo je to? Berta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "10339a89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Berta'"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6af6bdf",
   "metadata": {},
   "source": [
    "Sicer pa so končni kupci, po vrsti po predmetih,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "2fb840a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Fanči', 'Ema', 'Cilka', 'Berta', 'Dani', 'Berta', 'Greta',\n",
       "       'Helga'], dtype='<U21')"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[indeksi[koncni]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4948b5e7",
   "metadata": {},
   "source": [
    "V `cene[koncni]` najdemo, kot vemo že dolgo, končne cene predmetov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "0cfa24f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 45,  29,  78,  83, 107,  15,  63,  21])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cene[koncni]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9bb9d3b",
   "metadata": {},
   "source": [
    "Zdaj pa izpolnimo tabelico nakupi. Vsaka vrstica se nanaša na nek predmet. Ti so unikatni in jih oštevilčimo kar od `0` do `len(koncni)` (brez `len(koncni)`). Vsak stolpec se nanaša na neko osebo. Za vsako številko od 0 do len(koncni) in osebo v `indeksi[koncni]` (indeksi oseb, ki so kupile nek predmet) v pripadajočo celico vpišemo ceno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "789100bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   0,   0,   0,   0,  45,   0,   0],\n",
       "       [  0,   0,   0,   0,  29,   0,   0,   0],\n",
       "       [  0,   0,  78,   0,   0,   0,   0,   0],\n",
       "       [  0,  83,   0,   0,   0,   0,   0,   0],\n",
       "       [  0,   0,   0, 107,   0,   0,   0,   0],\n",
       "       [  0,  15,   0,   0,   0,   0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,  63,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,  21]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nakupi[np.arange(len(koncni)), indeksi[koncni]] = cene[koncni]\n",
    "\n",
    "nakupi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17a35fb0",
   "metadata": {},
   "source": [
    "Prvi stolpec je Anin. Ta ni kupila ničesar. Drugi je Bertin: kupila je nekaj za 83 in nekaj za 15. In tako naprej. Koliko je zapravil kdo, izvemo, če seštejemo stolpce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "3aba3a4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 45,  29,  78,  83, 107,  15,  63,  21])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poraba = np.sum(nakupi, axis=1)\n",
    "\n",
    "poraba"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5465fcdf",
   "metadata": {},
   "source": [
    "Imena, ki pripadajo stolpcem, dobimo v `imena`. In že lahko izpišemo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "b1412d46",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana       45\n",
      "Berta     29\n",
      "Cilka     78\n",
      "Dani      83\n",
      "Ema      107\n",
      "Fanči     15\n",
      "Greta     63\n",
      "Helga     21\n"
     ]
    }
   ],
   "source": [
    "for ime, pora in zip(imena, poraba):\n",
    "    print(f\"{ime:8}{pora:4}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4d52dfb",
   "metadata": {},
   "source": [
    "Še enkrat: uporabiti tako veliko tabelo za tako malo dela je nesmisel. Če bi vsaka oseba kupila več stvari in če bi lahko vsak izdelek prodali več osebam, pa bi posta(ja)lo smiselno. Vendar smo se tega dvojnega, vzporednega indeksiranja naučili, ker nam bo prišlo prav kasneje."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "020afabd",
   "metadata": {},
   "source": [
    "### 6. Za vsak predmet izpiši, za koliko je bila končna cena višja od prve\n",
    "\n",
    "Po telovadbi iz prejšnjega razdelka je to trivialno. Začetne cene so v `cene[zacetni]`, koncne v `cene[koncni]`. Odštejemo ju, pa dobimo razlike, po katerih sprašuje naloga."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "55ba4f95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 45  29  78  83 107  15  63  21]\n",
      "[31 29 44 50 30 15 27 16]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([14,  0, 34, 33, 77,  0, 36,  5])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(cene[koncni])\n",
    "print(cene[zacetni])\n",
    "\n",
    "cene[koncni] - cene[zacetni]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3207004",
   "metadata": {},
   "source": [
    "Imena predmetov najdemo v `predmeti[zacetni]` ali `predmeti[koncni]` (oboje bo enako). Ker dobra vaga pomaga v nebesa, bomo dodali še število ponudb in ponovili, kako oblikujemo izpis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "9d5164d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predmet                  ponudb    zvišanje\n",
      "-------------------------------------------\n",
      "slika                         6          14\n",
      "pozlačen dežnik               1           0\n",
      "Meldrumove vaze              12          34\n",
      "skodelice                    12          33\n",
      "kip                          29          77\n",
      "čajnik                        1           0\n",
      "srebrn jedilni servis        14          36\n",
      "perzijska preproga            2           5\n"
     ]
    }
   ],
   "source": [
    "ponudb = koncni - zacetni + 1\n",
    "zvisanja = cene[koncni] - cene[zacetni]\n",
    "\n",
    "print(f\"{'Predmet':25}{'ponudb':6}{'zvišanje':>12}\")\n",
    "print(\"-\" * (25 + 6 + 12))\n",
    "for predmet, pon, zvis in zip(predmeti[koncni], ponudb, zvisanja):\n",
    "    print(f\"{predmet:25}{pon:6}{zvis:12}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9328234e",
   "metadata": {},
   "source": [
    "### Kdo največkrat viša za Berto?!\n",
    "\n",
    "V neki naloga je Berta ugotovila, da ima najbrž sovražnika, ki vedno viša njeno ponudbo. Morali smo ji ga pomagati razkrinkati. V osnovi bi šlo tako:\n",
    "\n",
    "- najprej ugotovimo, v katerih vrsticah se oglaša Berta. Zadnjo vrstico odstranimo: če je tam slučajno Berta, bi nam to kasneje (videli bomo, kdaj) povzročalo sitnosti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "0b66fada",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True, False,  True, False,  True, False,  True,\n",
       "       False,  True, False,  True, False, False,  True, False, False,\n",
       "        True, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False,  True, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "osebe[:-1] == \"Berta\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "fe053f96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2, 20, 22, 24, 26, 28, 30, 33, 36, 60])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.flatnonzero(osebe[:-1] == \"Berta\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22054403",
   "metadata": {},
   "source": [
    "Zanimala nas bodo imena v vrsticah, ki so *za* temi vrsticami. K indeksom torej prištejemo `1` (in to je razlog, da smo odstranili zadnjo vrstico - če bi bila v zadnji vrstici slučajno Berta, bi dobili prevelik indeks)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "c520d376",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3, 21, 23, 25, 27, 29, 31, 34, 37, 61])"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.flatnonzero(osebe[:-1] == \"Berta\") + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "5888af18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Ana', 'Fanči', 'Dani', 'Dani', 'Dani', 'Dani', 'Dani', 'Cilka',\n",
       "       'Ema', 'Cilka', 'Ema'], dtype='<U21')"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "osebe[np.flatnonzero(osebe[:-1]== \"Berta\") + 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2974352",
   "metadata": {},
   "source": [
    "In zdaj le še preštejemo, kolikokrat se na tem spisku pojavi posamično ime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "0768e29c",
   "metadata": {},
   "outputs": [],
   "source": [
    "imena, za_berto = np.unique(osebe[np.flatnonzero(osebe[:-1] == \"Berta\") + 1], return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "f1b8a207",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Ana', 'Cilka', 'Dani', 'Ema', 'Fanči'], dtype='<U21')"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "9f161ad5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 5, 2, 1])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "za_berto"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb91003d",
   "metadata": {},
   "source": [
    "Največji je števec na indeksu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "b3c8dc0d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(za_berto)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd1f7ac2",
   "metadata": {},
   "source": [
    "In pripadajoče ime - ha, pa jo imamo, sovražnico Berte - je"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "e1f7a5e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dani'"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[np.argmax(za_berto)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c588a522",
   "metadata": {},
   "source": [
    "### Logične operacije na tabelah in popravek: kdo je res Bertina sovražnica?\n",
    "\n",
    "Vendar žal ni tako preprosto. Berta je kupila dva izdelka. Za njima je nekdo ponudil prvo ceno za naslednji izdelek, mi pa smo ga prišteli k Bertinim sovražnikom. Vrniti se bo treba malo nazaj.\n",
    "\n",
    "Tole je maska, ki predstavlja vrstice, v katerih se je oglašala Berta (brez zadnje)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "9302e5ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True, False,  True, False,  True, False,  True,\n",
       "       False,  True, False,  True, False, False,  True, False, False,\n",
       "        True, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False,  True, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(osebe == \"Berta\")[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df95ea15",
   "metadata": {},
   "source": [
    "Tole so vrstice, ki ne predstavljajo zadnje ponudbe za nek izdelek - spet brez zadnje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "eb773415",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True, False, False,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "       False,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True, False,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True, False, False,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True, False,  True])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predmeti[1:] == predmeti[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90855d72",
   "metadata": {},
   "source": [
    "Da smo naredili pravilno, se prepričamo, če pogledamo zapisnik: ta se začne z\n",
    "\n",
    "```\n",
    "slika,Berta,31\n",
    "slika,Ana,33\n",
    "slika,Berta,35\n",
    "slika,Fanči,37\n",
    "slika,Ana,40\n",
    "slika,Fanči,45\n",
    "pozlačen dežnik,Ema,29\n",
    "Meldrumove vaze,Greta,44\n",
    "Meldrumove vaze,Ana,46\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4fabd5f",
   "metadata": {},
   "source": [
    "Šesti in sedmi element gornje tabele sta `False`; pripadajoči vrstici sta zadnji ponudbi, torej tisti, v katerih Bertine vrstice ne smemo šteti kot ponudbo, ki jo je nekdo kasneje zviševal.\n",
    "\n",
    "Zanimajo nas torej le vrstice, kjer se oglaša Berta in so ne-zadnja ponudba, torej, v bistvu `(osebe == \"Berta\")[:-1] and predmeti[1:] == predmeti[:-1]`. Žal `and` nad tabelami ne deluje po elementih; razlogi so tehnični in zgodovinski. Uporabiti moramo operator `&`, ki ga poznamo iz množic. Vlogo `or` in `not` pa prevzameta `|` in `~`. Na hitro jih preverimo na preprostem primeru."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "974558dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False, False, False])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([True, True, False, False])\n",
    "b = np.array([True, False, False, True])\n",
    "\n",
    "a & b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "a9940aba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False,  True])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a | b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "cee53d8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True,  True, False])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "~b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b46c8608",
   "metadata": {},
   "source": [
    "Če bi kdaj prišlo prav, je tu še \"ekskluzivni ali\", ki vrne `True`, če je `True` natanko eden od elementov, ne pa oba."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "a36907cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False,  True])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ^ b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3431963",
   "metadata": {},
   "source": [
    "S temi operatorji je povezana še ena komplikacija: premočni so. Previsoko prioriteto imajo. Izraz `a == b and c == d` bi seveda pomeni `(a == b) and (c == d)`, saj `==` veže močneje kot `and`. Operator `&` pa je močnejši `a == b & c == d` bi pomenilo `a == (b & c) == d`. (Zakaj jih niso naredili šibkejših? Ker prihajajo iz drugega vica. Če bi nas zanimalo, ali je presek množic `a` in `b` enak `c`, bi napisali `a & b == c` in zdelo bi se nam logično, da to pomeni `(a & b) == c`. Sploh pa `&` izvorno niti ni operacija nad množicami, temveč nad števili. O tem nismo in ne bomo govorili, vendar je to (in ne množice) razlog, da med tabelami v numpyju uporabljamo `&`.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "553b5096",
   "metadata": {},
   "source": [
    "Izvedši torej vse o tem, kako izračunati konjunkcijo tabel, brž sestavimo pravo masko:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "9b750cc2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False,  True, False,  True, False,  True, False,  True,\n",
       "       False,  True, False, False, False, False,  True, False, False,\n",
       "        True, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False, False, False, False, False, False,\n",
       "       False, False, False, False])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(osebe == \"Berta\")[:-1] & (predmeti[1:] == predmeti[:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "226c8523",
   "metadata": {},
   "source": [
    "In odtod vse steče po prejšnji poti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "6f15797b",
   "metadata": {},
   "outputs": [],
   "source": [
    "imena, za_berto = np.unique(\n",
    "    osebe[np.flatnonzero((osebe == \"Berta\")[:-1] & (predmeti[1:] == predmeti[:-1])) + 1],\n",
    "    return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "fd9e4b9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 5, 1, 1])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "za_berto"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f0860f6",
   "metadata": {},
   "source": [
    "Da, da, prej je bilo `[1, 2, 5, 2, 1]`. Ampak najhujša je pa še vedno Dani."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5efda897",
   "metadata": {},
   "source": [
    "### Najvišje zvišanje v času zadnjih sedem ponudb\n",
    "\n",
    "V neki domači nalogi je bilo potrebno ugotoviti, za koliko se je cena posamičnega predmeta dvignila v zadnjih sedmih ponudbah; če je bilo ponudb manj, pa pač v zadnjih toliko, kolikor jih je bilo.\n",
    "\n",
    "Če so indeksi vrstic z zadnjo ponudb v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "6ea006bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6, 18, 30, 59, 60, 74, 76])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncni"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0a284ac",
   "metadata": {},
   "source": [
    "potem moramo za vsakega za sedem vrstic nazaj,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "a6308ada",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2, -1, 11, 23, 52, 53, 67, 69])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncni - 7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cffc5164",
   "metadata": {},
   "source": [
    "Seveda pa je to narobe, ker za nekatere predmete niti nimamo sedmih ponudb. Da je tako, nas posebej ostro opozorita prva izdelka, ki nas potisneta celo v negativne indekse. Indekse z vrsticami končnih ponudb moramo \"omejiti\" z indeksi vrstic s prvo ponudbo. Vzeti moramo tisto od njiju, ki je večja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "3147613c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2 -1 11 23 52 53 67 69]\n",
      "[ 0  6  7 19 31 60 61 75]\n"
     ]
    }
   ],
   "source": [
    "print(koncni - 7)\n",
    "print(zacetni)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc396293",
   "metadata": {},
   "source": [
    "Kako to storiti? Preprosto; pravzaprav čisto očitno iz tega, kako smo ju izpisali v zgornji celici: zložimo ju v eno samo tabelo in izračunamo maksimum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "c4c1ca1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2, -1, 11, 23, 52, 53, 67, 69],\n",
       "       [ 0,  6,  7, 19, 31, 60, 61, 75]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([koncni - 7, zacetni])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "56cfde16",
   "metadata": {},
   "outputs": [],
   "source": [
    "koncni_7 = np.max([koncni - 7, zacetni], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "5532d23c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  6, 11, 23, 52, 60, 67, 75])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "koncni_7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8585051b",
   "metadata": {},
   "source": [
    "Za vsak slučaj preverimo, da se vrstice `koncni` in `koncni_7` res nanašajo na iste predmete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "1fcd172d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['slika', 'pozlačen dežnik', 'Meldrumove vaze', 'skodelice', 'kip',\n",
       "       'čajnik', 'srebrn jedilni servis', 'perzijska preproga'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predmeti[koncni]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "db37ce08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['slika', 'pozlačen dežnik', 'Meldrumove vaze', 'skodelice', 'kip',\n",
       "       'čajnik', 'srebrn jedilni servis', 'perzijska preproga'],\n",
       "      dtype='<U21')"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predmeti[koncni_7]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eada4ad",
   "metadata": {},
   "source": [
    "Ah, čemu bi to primerjali sami! Naj nam to naredi `numpy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "84b43a95",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predmeti[koncni] == predmeti[koncni_7]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "486a46eb",
   "metadata": {},
   "source": [
    "Če smo še bolj leni, pa kar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "7a2f62b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(predmeti[koncni] == predmeti[koncni_7])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52d21e27",
   "metadata": {},
   "source": [
    "Zdaj nam `cene[koncni]` pove končne cene, `cene[koncni-7]` pa cene za sedem ponudb prej. Zanima pa nas razlika."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "450f76b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14,  0, 21, 21, 15,  0, 16,  5])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cene[koncni] - cene[koncni_7]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f05569c3",
   "metadata": {},
   "source": [
    "In izpišimo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "5b165322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "slika                     14\n",
      "pozlačen dežnik            0\n",
      "Meldrumove vaze           21\n",
      "skodelice                 21\n",
      "kip                       15\n",
      "čajnik                     0\n",
      "srebrn jedilni servis     16\n",
      "perzijska preproga         5\n"
     ]
    }
   ],
   "source": [
    "for predmet, razlika in zip(predmeti[koncni], cene[koncni] - cene[koncni_7]):\n",
    "    print(f\"{predmet:25}{razlika:3}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b930ae",
   "metadata": {},
   "source": [
    "#### Funkcija kar tako: `clip`\n",
    "\n",
    "Tole je za vtis. Ko sem programiral gornji primer, sem naredil, kot sem naredil. Ko sem ga predeloval v zapiske, pa sem se spomnil na funkcijo `clip`. Ta prejme tabelo in meji; vse elemente, ki so pod spodnjo mejo, nastavi na spodnjo mejo in te, ki so nad zgornjo, potlači do zgornje.\n",
    "\n",
    "Nek profesor izračuna oceno tako, da dosežene odstotke na pisnem izpitu deli z 10 in prišteje 1. Odstotki so lahko tudi večji kot 100, ker lahko študenti rešujejo dodatne naloge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "a38a9ebf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  9,  5,  3, 13,  9])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odstotki = np.array([63, 82, 45, 25, 125, 89])\n",
    "\n",
    "ocene = odstotki // 10 + 1\n",
    "ocene"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a291ce58",
   "metadata": {},
   "source": [
    "Pravila UL velevajo, da študentom ne dajemo ocen manjših od 5 in večjih od 10. In tu uporabimo `np.clip`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "dcc68242",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7,  9,  5,  5, 10,  9])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.clip(ocene, 5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ffb82e4",
   "metadata": {},
   "source": [
    "Za funkcijo sem vedel, ni pa mi prišlo na misel, da bi lahko bili meji tudi tabeli. Recimo, da so študenti poleg tega delali domače naloge in iz nekega razloga končna ocena ne more biti višja od ocen domačih nalog. In, tako kot prej, ne more biti nižja od 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "c5a7047d",
   "metadata": {},
   "outputs": [],
   "source": [
    "domace = np.array([8, 6, 5, 5, 9, 10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "9474bb47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7  9  5  3 13  9]\n",
      "[ 8  6  5  5  9 10]\n",
      "[7 6 5 5 9 9]\n"
     ]
    }
   ],
   "source": [
    "print(ocene)\n",
    "print(domace)\n",
    "print(np.clip(ocene, 5, domace))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "044fc341",
   "metadata": {},
   "source": [
    "Potem bi lahko zgoraj namesto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "0ee36667",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  6, 11, 23, 52, 60, 67, 75])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max([koncni - 7, zacetni], axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14ff9cb1",
   "metadata": {},
   "source": [
    "napisali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "dc0c0c9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  6, 11, 23, 52, 60, 67, 75])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.clip(koncni - 7, zacetni, None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ea7943f",
   "metadata": {},
   "source": [
    "Zgornje meje ni, zato `None`.\n",
    "\n",
    "Je to bistveno krajše, boljše? Če bi bili tabeli veliki in bi nam bilo to mar, bi lahko s tem prihranili precej pomnilnika. Poleg tega je iz imena funkcije `np.clip` bolj jasno, kaj tule počnemo; `np.max` je pač ... nek maksimum.\n",
    "\n",
    "Sicer pa tole pišem z drugim namenom: da pokažem, da ima numpy res ogromno funkcij, ki jih poznamo ali pa tudi ne in se nanje spomnimo ali pa tudi ne. Dalj kot ga uporabljamo, bolj bomo spretni in bolj elegantni bodo naši programi. Sicer pa pravzprav enako velja tudi za Python."
   ]
  }
 ],
 "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
}