2_tipovi_podataka.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"hs.png\" width=\"200\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Uvod u Python (2 od 3)\n",
    "\n",
    "U ovom ćemo notebooku istražiti neke standardne strukture podataka u Pythonu 3. Za početak ćemo početi s brojevima, pa preko stringova i parova doći do lista i rječnika."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Brojevi\n",
    "\n",
    "Python ima dva tipa brojeva, *int* i *float*. *Ints* ili cijeli brojevi su brojevi oblika ...,-3,-2,-1,0,1,2,3,..., dok su *floats* brojevi s decimalnom točkom, poput 13.45 ili 12.0. U Pythonu 3 se brojevi lijepo ponašaju, na način da 10/3 daje 3.3333, ali u Pythonu 2 (koji je još uvijek aktualan i čest) ovo iznosi 3, jer se uzima samo cijeli broj ako se dijeli 10 i 3. Ako želimo dobiti 3.33333, moramo operaciju pokrenuti s decimalnim brojevima kao 10.0/3.0. Kao što smo rekli, u Pythonu 3 je ovo bolje riješeno, ali je ovo važno znati, jer je čest izvor bugova. Iskoristimo ovo kao motivaciju da krenemo (Shift+Enter na donju ćeliju):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "kao što vidimo, ugrađena funkcija **float()** pretvara broj koji je dobila u float. Probajmo ga pretvoriti u string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(float(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da bismo provjerili tip podatka imamo na raspolaganju ugrađenu funkciju **isinstance()**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "podatak = str(float(3))\n",
    "isinstance(podatak, str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uočimo jednu zanjimljivost:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(3.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mogli bismo pomisliti da ovo možemo koristiti za zaokruživanje, ali pogledajmo što se dogodi kada uzmemo drugi broj:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(9.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ono što funkcija **int()** radi, je da vraća cijeli broj, odbacujući decimalni dio. Za zaokruživanje moramo koristiti funkciju **round()**. Funkcija **round** ima dva argumenta, prvi koji joj moramo dati je broj koji zaokružuje, a drugi je na koliko decimalnih mjesta zaokružuje. Po *defaultu* je to 0, pa ako ne specificiramo neku vrijednost, Python će uzeti 0, odnosno zaokruživat će na cijeli broj:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(9.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pogledajmo kako ide kada joj damo broj znamenki:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "round(4.7896546, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pogledajmo kako možemo davati defaultne vrijednosti funkcijama koje mi definiramo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def neka_fja(broj, drugi_broj=2):\n",
    "    return broj*drugi_broj\n",
    "print(neka_fja(4))\n",
    "print(neka_fja(10,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za usporedbu probajte izvrsiti istu funkciju bez **=2**, i zatim bez **drugi_broj=2**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def neka_fja(broj, drugi_broj):#probajte ovako izvrsiti, a onda skroz maknite iz definicije drugi_broj (drugo izvrsavanje)\n",
    "    return broj*drugi_broj #za kraj, maknite *drugi_broj i iz ovog (trece izvrsavanje)\n",
    "print(neka_fja(4))\n",
    "print(neka_fja(10,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za kraj ovog dijela, trebamo dati osnovni pregled aritmetike u Pythonu. Ove operacije se jednako primjenjuju na **ints** kao i na **floats**. Zbrajanje je +, oduzimanje -, množenje \\*, dijeljenje /, eksponenciranje \\*\\*, i ostatak dijeljenja %. Istražimo ovu zadnju operaciju:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(10%3)\n",
    "print(49%7)\n",
    "print(4%5)\n",
    "print(9.8%3.4)\n",
    "print(5.5%8.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stringovi\n",
    "\n",
    "Stringovi su nakon brojeva najjednostavniji podatkovni tip u Pythonu. Postoje tri važne funkcije nad njima:\n",
    "\n",
    "* konkatenacija **+** koju smo već vidjeli\n",
    "* funkcija duljine, **len()**\n",
    "* dohvaćanje pojedine komponente stringa s **[n]**\n",
    "\n",
    "Pogledajmo kako to funkcionira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prvi_dio = \"korisnicko_ime\"\n",
    "email = prvi_dio + \"@\" +\"org.com\"\n",
    "email"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"k\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"org.com\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pogledajmo sada kako dohvatiti pojedine komponente stringa (slova) s **[n]**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prvi_dio = \"korisnicko_ime\"\n",
    "email = prvi_dio + \"@\" +\"org.com\"\n",
    "email"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "email[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "email[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "email[len(prvi_dio)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "email[9%2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "email[1000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Možemo pitati je li neko slovo dio nekog stringa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"g\" in \"Zagreb\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ovo nas vodi pojmu metode. Metoda je funkcija koja je asocirana uz neki tip objekta. Pokažimo metodu **find** na stringovima, na konkretnom primjeru stringa **\"Zagreb\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hrvatska\".find(\"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vidimo da metoda find nalazi prvo slovo te vrste (prvo \"a\") u stringu, i vraća njegovu poziciju u stringu, a ova se \"pozicija\" službeno zove **indeks**. Python uvijek počinje brojati od 0, tako da je to četvrto slovo ali ima indeks 3. \n",
    "\n",
    "Ako tražimo slovo kojeg nema, Python vraća -1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Hrvatska\".find(\"g\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ako treba zamjeniti ili umetnuti slovo u string, to zahtjeva dosta posla. Definirajmo prvo string (**\"stanica\"**), iz njega ćemo htjeti dobiti string **\"satnica\"**: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "izv_rijec = \"stanica\"\n",
    "prvi = izv_rijec[:1]\n",
    "drugi = izv_rijec[3:]\n",
    "srednji = izv_rijec[1:3]\n",
    "srednji2 = srednji[::-1]\n",
    "prvi + srednji2 + drugi #ovaj redak sastavlja *novi* string. Uocite da je string izv_rijec jos uvijek isti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Komentirajmo što smo napravili:\n",
    "1. u prvom retku smo pridružili početni string varijabli **izv_rijec**\n",
    "\n",
    "2. u drugom retku smo odsjekli podstring izvornog stringa, i to od njegovog početka do člana stringa s indeksom 1 (ne uključivši njega samog). Da smo stavili **[:]**, to bi vratilo podstring od prvog do zadnjeg znaka, a da želimo od prvog do predzadnjeg (a da ne znamo koliko je dug), utipkali bismo **izv_rijec[:-1]** (da želimo do predpredzadnjeg pisali bismo **[:-2]**).\n",
    "\n",
    "3. treći redak je sličan drugom, ali sada želimo uhvatiti u varijablu **drugi** podstring izvornog stringa od člana stringa s indeksom 3 do kraja.\n",
    "\n",
    "4. u četvrtom retku želimo uhvatiti dio početnog stringa od indeksa 1 (uključivši onog s indeksom 1) do onog s indeksom 3 (bez tog člana s indeksom 3), i spremamo ga u varijablu **srednji**.\n",
    "\n",
    "5. peti redak je poseban. Ovdje se događa čarolija i **\"ta\"** se pretvara u **\"at\"**. Znači string na koji pokazuje varijabla **srednji** hvatamo cijeli, znači kao da je **[:]**, s time da dodajemo **:-1** unutra. Naredba **[:]** ima defaultne vrijednosti *početak* i *kraj* (znači izgleda ovako [*početak*:*kraj*]), ali ima i treću defaultnu vrijednost koja specificira način na koji se čita string, odnosno korak, tako da je puni izgled [*početak*:*kraj*:*korak*]. Korak je po defaultu 1, odnosno hvata se string koji ide jedan korak udesno. Par primjera će to bolje prikazati:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "st = \"0123456789\"\n",
    "print(st[::2])\n",
    "print(st[::3])\n",
    "print(st[2:6:2])\n",
    "print(st[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za kraj, uočimo što se događa kada tražimo podstring stringa od početka do pozicije koja odgovara duljini stringa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=\"qwerty\"\n",
    "s[:len(s)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parovi (tuple)\n",
    "\n",
    "Parovi su tip podataka koji zajedno objedinjuju više podataka. To ne mora nužno biti dva podatka, može ih biti više:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "par = (1,2)\n",
    "len(par)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vise = (1, \"s\", \"adda\", (13.5,\"dd\"), True)\n",
    "vise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vise[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vise[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vise[999]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parovi se ponasaju jako slično stringovima, i sve što se može sa stringovima se može i s parovima. Liste i rječnici su puno fleksibilniji."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Liste\n",
    "\n",
    "Liste su slične parovima, ali su bolje i ugodnije za koristiti. Bolje su zato što se mogu azurirati. Sve što možemo s parovima možemo s listama i još puno više. Izvršite ćeliju ispod:\n",
    "\n",
    "[**NAPOMENA**: Zato što su liste izmjenjive, ćelije u poglavlju \"Liste\" morate izvršavati redom (isto će vrijediti i za rječnike u sljedećem poglavlju), jer u protivnom postoji velika šansa da vas zbuni ono što dobijete (kao test možete nakon što završite dio s listama još jednom izvršiti ćeliju direktno ispod ovog teksta pa ćete vidjeti što ćete dobiti)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [21,45,4125, 99.4, \"d\", [[\"y4\",\"ppt\"],\"rr\"]]\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uočimo da ova lista ima 6 članova. Zadnji član liste je *lista listi* (bonus pitanje: koliko ovaj član ima elemenata?):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uočimo kako se ponaša operator **in** u listama:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"d\" in lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za razliku od parova i stringova, liste možemo modificirati, ne moramo stvarati novu listu. Recimo da nam se ne sviđa član liste **\"d\"** i da tamo želimo vidjeti broj **6**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pozicija_uljeza = lista.index(\"d\") #ovo vraca broj indeksa za \"d\", mozete isprintati pa vidjeti\n",
    "lista[pozicija_uljeza] = 6\n",
    "lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uočimo da smo modificirali početnu listu **lista**, a nismo stvorili novu listu (kao što je bio slučaj kod stringova). Isto to ne možemo napraviti s parovima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pseudolista = (21,45,4125, 99.4, \"d\", [[\"y4\",\"pop\"],\"rr\"])\n",
    "pozicija_uljeza = pseudolista.index(\"d\") #ova metoda index() radi osim za liste i za parove. Provjerite!\n",
    "pseudolista[pozicija_uljeza] = 6\n",
    "pseudolista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste imaju neke zanimljive metode, i prikazujemo neke:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.append(\"X\")\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lista.pop(2))\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda **append** dodaje listi na kraj element koji se specificira. Ovaj element može biti bilo što, čak i neka druga lista. \n",
    "\n",
    "**NAPOMENA**: izraz tipa\n",
    "\n",
    "*nova_lista = lista.append(\"Y\")*\n",
    "\n",
    "ne znači ništa, jer je **append** metoda koja mijenja (mutira) listu, ali nakon toga **ne** vraća listu. Možete sami probati i vidjeti što će vam dati van **print(nova_lista)**.\n",
    "\n",
    " Metoda **pop** uzima indeks nekog člana, makne ga sa liste i vraća ga (znači vraća element s tim indeksom, i dodatno mutira listu tako da više nema taj element). \n",
    " \n",
    " Metoda nalik **append** koja mutira listu tako da izbacuje element s određenim imenom se zove **remove**. Isprobajte je sami, sintaksa (\"sintaksa\" znači: način na koji se piše i koristi) je ista kao kod **append**. \n",
    " \n",
    " Ako lista sadrži liste, onda možemo s *ugnježdenim* (eng. *nested*) **[n]** operatorima doći do bilo koje razine. Isprobajte to u ćeliji ispod:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lista)\n",
    "print(lista[4][0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Izraz **lista[4][0][1]** se čita: \"drugi element u prvom elementu petog elementa liste **lista**\". \n",
    "\n",
    "Zapamtimo da Python indeksi počinju s 0, tako da prvi element ima indeks 0, drugi element indeks 1, a peti element ima indeks 4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inicijalizacija\n",
    "\n",
    "Python ima \"prazne\" instance i \"pune\" instance. Prazne instance tipova su prazan string (\"\" ili ''), prazna lista ([]), prazni rječnik ({}), nula u brojevima (0 ili 0.0), ili neistina u bulovskim varijablama (False). Uz pomoć prazne liste i praznog rječnika se često *inicijaliziraju* liste i rječnici koji će se dopunjavati, a 0 se često koristi kao brojač, što ćemo detaljnije vidjeti u sljedećem Notebooku."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rječnici\n",
    "\n",
    "Liste su strukture u kojima se podatci hvaćaju uz pomoć indeksa. Njihova generalizacija da se može ručno staviti \"ključ\" kojim se dolazi do podatka se zove rječnik. Dajemo primjer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [\"Zagreb\", \"Split\", \"Rijeka\", \"Osijek\"]\n",
    "lista[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rjecnik = {\"prvi\":\"Zagreb\", \"drugi\":\"Split\", \"treci\":\"Rijeka\",\"cetvrti\":\"Osijek\"}\n",
    "rjecnik[\"treci\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Članovi rječnika imaju oblik \"ključ\":\"vrijednost\". Naravno, ako napravimo rječnik s brojevima, dobijemo isto kao listu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rjecnik2 = {0:\"Zagreb\", 1:\"Split\", 2:\"Rijeka\", 3:\"Osijek\"}\n",
    "rjecnik2[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uočimo kako se ponaša operator **in** kod rječnika:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rjecnik = {\"prvi\":\"Zagreb\", \"drugi\":\"Split\", \"treci\":\"Rijeka\",\"cetvrti\":\"Osijek\"}\n",
    "print(\"prvi\" in rjecnik)\n",
    "print(\"Zagreb\" in rjecnik)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ista sintaksa se koristi i za dodavanje i za ažuriranje, s razlikom što ako se stavi ključ koji već postoji, vrijednost će se ažurirati, a ako se stavi novi ključ onda će se par \"novi_ključ\":\"vrijednost\" dodati u rječnik:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rjecnik[\"prvi\"] = \"Krk\"\n",
    "rjecnik"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rjecnik[\"deseti\"] = \"Krk\"\n",
    "rjecnik"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jedna metoda koja je svojstvena rječnicima je **keys()**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rjecnik.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Druga metoda je **values()**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rjecnik.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ako želimo ovo pretvoriti u običnu listu, koristimo *castanje* u listu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(rjecnik.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rječnik je moguće inicijalizirati praznog i onda dodavati parove:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "novi = {}\n",
    "novi[\"post\"] = \"Hello!\"\n",
    "novi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ili uz pomoć liste ključeva:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kljucevi = [\"ime\",\"prezime\",\"dob\"]\n",
    "novi2 = dict.fromkeys(kljucevi, \"N/A\")\n",
    "novi2"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}