p1/predavanja/03a seznami, terke in zanka for.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Na prvih dveh predavanjih smo se pogovarjali predvsem o logiki, o tem, kako \"usmerjati\" program, da se bo vrtel in skakal. Mimogrede smo spoznali tri tipe podatkov, cela števila (`int`), realna števila (`float`), logične vrednosti (`bool`) in nizi (`str`).\n",
    "\n",
    "Za te, ki že znate programirati: na predavanju bomo spoznali sezname, vendar bom karseda dolgo zamolčal, da lahko do njihovih elementov dostopamo z indeksi. Namerno. Ideja je v tem, da prej spoznate, kako se do njih dostopa z zanko in na ta način povečamo možnost, da ne boste prevečkrat uporabljali indeksov takrat, ko jih ni treba.\n",
    "\n",
    "\n",
    "### Seznami\n",
    "\n",
    "Recimo, da smo zbrali teže šestih študentov. Seznam tež zapišemo takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "teze = [74, 82, 58, 66, 61, 84]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seznam (angl. *list*) je zaporedje česarkoli, recimo števil, lahko pa tudi česa drugega. Števila ali kaj drugega naštejemo, vmes pišemo vejice in vse skupaj zapremo v oglate oklepaje (`[` in `]`). Za primer sestavimo še seznam imen študentov:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "imena = [\"Anze\", \"Benjamin\", \"Cilka\", \"Dani\", \"Eva\", \"Franc\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in seznam, ki bo povedal, ali gre za študenta ali študentko"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "studentka = [False, False, True, False, True, False]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seznami lahko vsebujejo tudi še hujšo eksotiko. Imamo lahko, recimo, seznam seznamov - vanj bomo, prikladno, stlačili (pod)sezname teža-ime-spol:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "podatki = [\n",
    "    [74, \"Anze\", False],\n",
    "    [82, \"Benjamin\", False],\n",
    "    [58, \"Cilka\", True],\n",
    "    [66, \"Dani\", False],\n",
    "    [61, \"Eva\", True],\n",
    "    [84, \"Franc\", False],\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To sicer navadno delamo malo drugače (pogosto celo precej drugače), a dokler tega še ne znamo, bo dobro tudi tako. Mimogrede opazimo še dve stvari: seznam lahko, če želimo, raztegnemo v več vrst, preprosto tako, da ne zapremo oklepaja. Naredili bi lahko tudi tole"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "teze = [74, 82, 58,\n",
    "        66, 61, 84]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V takih primerih je v naslednjih vrsticah vseeno, koliko presledkov damo na začetek. Toliko pač, da dobro izgleda. (Se spomnite, ko smo na čisto prvem predavanju povedali, da python ve, da izraza še ni konec, če še niso zaprti vsi oklepaji? Zdaj vidimo, zakaj je to prikladno.)\n",
    "\n",
    "Druga opazka: za zadnjim elementom v prejšnjem primeru smo naredili vejico. Ni treba, lahko pa jo. To pride prav, če bi kdaj kasneje spreminjali vrstni red elementov, na primer dali Franca na čelo vrste. V tem primeru bi le skopirali vrstico, vejice pa bi bile že OK.\n",
    "\n",
    "Seznami lahko vsebujejo še hujšo eksotiko. V resnici lahko vsebujejo karkoli, celo, recimo, funkcije:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *\n",
    "par_funkcij = [sin, cos, radians]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Čemu bi kdo hotel narediti seznam funkcij?! Ne boste verjeli, kolikokrat pride to prav!\n",
    "\n",
    "Nikjer tudi ne piše, da morajo biti vsi elementi seznama istega tipa. To smo pravzaprav že izkoristili: podseznami s težo, imenom in spolom so vsebovali število, niz in logično vrednost. Navrgli bi lahko še dve funkciji in en seznam; pa ne bomo, to se ne dela. Seznamov, ki imajo elemente različnih tipov, ne bomo tako pogosto videvali. (Če obratno parafraziramo Andreja Bauerja: *seznami z elementi različnih tipov se morda komu zdijo dobra ideja. V resnici je to zelo sla  ba ideja.* Če želimo sezname različnih tipov, raje uporabimo terke. Kaj so terke, bomo izvedeli vsak čas.)\n",
    "\n",
    "Seznam je lahko tudi prazen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "prazen = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ali pa ima en sam element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "samo_edini = [42]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ali pa je poln praznih seznamov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "polnoprazen = [[], [], [], [], [], []]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Terka\n",
    "\n",
    "Terka (angl. *tuple*) je podobna seznamu. Kakšna je pomembna razlika, bomo še videli, manj pomembna pa je ta, da pri terki namesto oglatih oklepajev uporabljamo kar okrogle. (Skoraj) vse ostalo ostane enako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "teze = (74, 82, 58, 66, 61, 84)\n",
    "imena = (\"Anze\", \"Benjamin\", \"Cilka\", \"Dani\", \"Eva\", \"Franc\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pri terkah se nam - zaradi tega, kje in kako jih uporabljamo, pogosteje zgodi, da vsebuje elemente različnih tipov. Recimo takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "student = (74, \"Anze\", False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tudi seznam teža-ime-spol bi raje naredili takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "podatki = [\n",
    "    (74, \"Anze\", False),\n",
    "    (82, \"Benjamin\", False),\n",
    "    (58, \"Cilka\", True),\n",
    "    (66, \"Dani\", False),\n",
    "    (61, \"Eva\", True),\n",
    "    (84, \"Franc\", False),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tako kot seznami so tudi terke lahko prazne (`()`) ali pa imajo po en sam element. Tu imamo težavo pri terki z enim samim elementom: če bi napisali `(42)` to ni seznam, temveč le 42 v oklepaju (odvečnem, seveda). Da bi povedali, da gre za terko, moramo dodati še vejico:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "samo_en = (42, )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Terko smemo, zanimivo, pisati tudi brez oklepajev."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "t = 1, 2, 3, 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Ker to ni preveč pregledno, pa to počnemo le v posebnih primerih, na katere bomo sproti opozorili.\n",
    "\n",
    "### Razpakiranje v elemente\n",
    "\n",
    "Kako pridemo do elementov seznama ali terke? Se pravi, kako bi shranili elemente terke v posamezne spremenljivke? Recimo, da imamo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "student = (74, \"Anze\", False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če želimo podatke prirediti spremenljivkam `teza`, `ime` in `je_zenska`, terko *razpakiramo*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "teza, ime, je_zenska = student"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Doslej smo imeli pri prirejanju na levi strani vedno eno samo spremenljivko, ki smo ji želeli prirediti vrednost na desni strani enačaja. Tu pa smo na levi našteli več imen spremenljivk (tri), na desni pa mora biti za to terka z enakim številom elementov (tremi). Terka? No, lahko je tudi seznam ali niz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "a, b, c = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "a, b, c = \"xyz\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'x'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'y'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'z'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Več ko boste programirali v Pythonu, bolj boste čutili moč terk. Omenimo, recimo, da je z njimi mogoče napisati funkcijo, ki ne vrača ene, temveč več stvari. Vzemimo funkcijo `splitext`, ki ji damo ime datoteke, pa vrne njeno osnovno ime in njeno končnico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from os.path import *\n",
    "\n",
    "film = \"Babylon 5 - 3x04 - Passing through Gethsemane.avi\"\n",
    "zac, konc = splitext(film)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Babylon 5 - 3x04 - Passing through Gethsemane'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zac"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'.avi'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "konc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "V resnici funkcija `splitext` vrne terko,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Babylon 5 - 3x04 - Passing through Gethsemane', '.avi')"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splitext(film)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "ki pa smo jo kar mimogrede razpakirali v `zac` in `konc`.\n",
    "\n",
    "Seveda bi lahko rezultat funkcije priredili tudi eni sami spremenljivki - v tem primeru bi bila ta spremenljivka terka."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "t = splitext(film)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Babylon 5 - 3x04 - Passing through Gethsemane', '.avi')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "In seveda bi lahko terko nato še razpakirali."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "ime, koncnica = t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kako v Pythonu zamenjamo vrednosti dveh spremenljivk?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "a = \"Alenka\"\n",
    "b = \"Tina\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Želeli bi, da bi `a` postal \"Tina\" in `b` \"Alenka\". Naivnež bi napisal\n",
    "tale nesmisel:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "a = b\n",
    "b = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "To seveda ne deluje. V prvi vrstici `a`-ju priredimo `b`, se pravi, \"Tina\", v drugi vrstici pa `b`-ju `a`, ki pa je medtem postal \"Tina\". Tako sta po tem `a` in `b` enaka \"Tina\".\n",
    "\n",
    "V drugih jezikih se navadno rešimo tako, da vrednost `a`-ja spravimo na varno, preden ga povozimo."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "tmp = a\n",
    "a = b\n",
    "b = tmp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "V Pythonu pa to ni potrebno. Spremenljivki preprosto zapakiramo v terko, ki jo takoj razpakiramo nazaj, a v obratnem vrstnem redu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "a, b = (b, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tina'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Alenka'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "V resnici navadno ne pišemo tako, temveč izpustimo oklepaje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "a, b = b, a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Oklepaje okrog terke izpuščamo preprosto zato, ker je takšno prirejanje tako pogosto, da ga programer vajen Pythona takoj prepozna. Pri tem tudi ne razmišljamo o terkah, temveč prirejanje preberemo preprosto tako, da `a`-ju priredimo `b` in `b`-ju `a`.\n",
    "\n",
    "\n",
    "### Zanka for\n",
    "\n",
    "Python ima dve vrsti zank: zanki `while`, ki jo že poznamo, dela družbo `for`.\n",
    "\n",
    "**(Medklic za tiste, ki že znate programirati)**\n",
    "\n",
    "V C-ju in jezikih, izpeljanih iz njega (C++, C\\#, Java...) imamo običajno dve vrsti zank. Mogoče mislite, da so tri, ampak v resnici sta dve: `while` in `do`-`while`. C-jevski `for` je samo malo bolj zgoščeno zapisan `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "for(zacetek; pogoj; korak) {\n",
    "    koda;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "je isto kot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "zacetek;\n",
    "while(pogoj) {\n",
    "    koda;\n",
    "    korak;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V C, C++, C\\#, Javi sta zanka `for` in `while` le dva načina, na katera povemo eno in isto. Pa tudi med `while` in `do`-`while` ni tako velike razlike, čeprav je slednja včasih - a redko - praktična.\n",
    "\n",
    "Pač pa obstajajo tudi [druge različice zanke for (http://en.wikipedia.org/wiki/For_loop#Kinds_of_for_loops), ki so v resnici drugačne od `while`. Novejši jeziki imajo - in starejši jeziki dobivajo - drugačno obliko zanke `for`, ki je v današnjih časih, ko vedno več uporabljamo funkcijske jezike, bolj uporabna. Nekateri, recimo C#, jo poznajo pod imenom `foreach`. Pythonov `for` vas bo spominjal nanj in ne na C-jevski `for`.\n",
    "\n",
    "**(Konec medklica)**\n",
    "\n",
    "Zastavimo si preprosto nalogo (in ne čisto smiselno) nalogo: izpišimo teže in kvadrate tež vseh študentov v seznamu. Se pravi (po slovensko):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "za vsako težo s seznama teze stori tole:\n",
    "    izpiši težo in težo na kvadrat\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V Pythonu pa prav tako, samo brez sklonov:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "74 5476\n",
      "82 6724\n",
      "58 3364\n",
      "66 4356\n",
      "61 3721\n",
      "84 7056\n"
     ]
    }
   ],
   "source": [
    "for teza in teze:\n",
    "    print(teza, teza ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V zanki `for` se skriva prirejanje. Zanka najprej *priredi* spremenljivki `teza` prvi element seznama `teze`. Nato se izvrši vsa koda bloka znotraj bloka `for` - tako, kot se je dogajalo v zanki `while`. V naslednji rundi priredi spremenljivki `teza` drugi element in spet izvede kodo znotraj bloka, ... ter tako naprej do konca seznama.\n",
    "\n",
    "Zanka `for` je torej nekoliko podobna zanki `while`. Razlika je v tem,\n",
    "-  da se `while` izvede tolikokrat, dokler ji dopušča pogoj, `for` pa se izvede enkrat za vsak element seznama,\n",
    "- da `for` v vsaki ponovitvi (po tuje: *iteraciji*) priredi spremenljivki vrednost naslednjega elementa seznama.\n",
    "\n",
    "V zvezi z obojim je potrebno še nekaj pripomniti, da nas ne bodo držali za besedo, češ da učimo polresnice. Zanka `for` ne gre nujno le prek seznamov, temveč tudi prek terk, nizov in še drugih reči, med katerimi so tudi kake tako imenitne, da si jih zdajle ne moremo niti predstavljati.\n",
    "\n",
    "Glede *prirejanja vrednosti spremenljivkam* pa se moramo popraviti, da Python ne prireja vrednosti spremenljivkam, temveč daje imena rečem. Za tiste, ki jim ta razlika kaj pomeni. Tistim, ki jim ne, pa še bo.\n",
    "\n",
    "Zdaj pa izpišimo vse teže, ki so večje od 70."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "74\n",
      "82\n",
      "84\n"
     ]
    }
   ],
   "source": [
    "for teza in teze:\n",
    "    if teza > 70:\n",
    "        print(teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Napišimo program, ki pove, kako težak je najlažji študent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "58\n"
     ]
    }
   ],
   "source": [
    "najlazji = 1000\n",
    "for teza in teze:\n",
    "    if teza < najlazji:\n",
    "        najlazji = teza\n",
    "print(najlazji)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Je potrebno prevesti v slovenščino? Pa dajmo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "za začetek naj bo najlažja teža 1000 (ker vemo, da je to preveč)\n",
    "za vsako težo iz seznama tež:\n",
    "    če je teža manjša od najmanjše  doslej:\n",
    "        najlažja je ta teža\n",
    "izpiši najmanjšo težo\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deluje ta program samo na seznamih števil? Ali pa bi znal poiskati tudi najmanjši niz? Kako pravzaprav primerjamo nize? Nize primerja, seveda, po abecedi. In, da: program deluje tudi na nizih, vrne \"najmanjši\" niz - prvi niz po abecedi. Le v začetku moramo napisati `najlazji = \"ŽŽŽŽŽŽŽŽŽŽŽŽ\"` namesto `najlazji = 1000`. (Tole se da sprogramirati tudi tako, da deluje za nize in za števila. A ne ubijajmo začetnikov s prezapletenimi programi.)\n",
    "\n",
    "Mimogrede, Python ima že vdelano funkcijo `min`, ki vrne najmanjši element seznama.\n",
    "\n",
    "Kako bi izračunali vsoto elementov seznama?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 0\n",
    "for teza in teze:\n",
    "    s += teza"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pa poprečno vrednost? Za to moramo poznati dolžino seznama. Pove nam jo funkcija `len` (okrajšava za *length*, če ji kot argument podamo nek seznam)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70.83333333333333\n"
     ]
    }
   ],
   "source": [
    "s = 0\n",
    "for teza in teze:\n",
    "    s += teza\n",
    "s /= len(teze)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Samo... malo previdni moramo biti. Seznam bi lahko bil tudi prazen. Dogovorimo se, da bo poprečna vrednost v tem primeru 0. Pravilno delujoč program bi bil takšen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70.83333333333333\n"
     ]
    }
   ],
   "source": [
    "s = 0\n",
    "for teza in teze:\n",
    "    s += teza\n",
    "if len(teze) > 0:\n",
    "    s /= len(teze)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zanka `for` ne deluje le na seznamih. Kot smo omenili, jo lahko naženemo tudi prek terk, nizov in še prek mnogih drugih reči. V Pythonu celo za branje datotek pogosto uporabimo `for`, kot se bomo kmalu naučili."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "i\n",
      "l\n",
      "k\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "ime = \"Cilka\"\n",
    "for crka in ime:\n",
    "    print(crka)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Najdi takšnega, ki...\n",
    "\n",
    "Zdajle, bolj proti začetku ure, ko smo še sveži, brž naskočimo najtežji oreh današnjega predavanja. Kar bomo počeli zdaj, boste srečali v sto in eni preobleki, na koncu pa skoraj gotovo tudi kot najpreprostejšo nalogo na izpitu.\n",
    "\n",
    "Kako bi ugotovili, ali vsebuje seznam kako sodo število?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam vsebuje sodo število\n"
     ]
    }
   ],
   "source": [
    "s = [11, 13, 5, 12, 5, 16, 7]\n",
    "imamo_sodo = False\n",
    "for e in s:\n",
    "    if e % 2 == 0:\n",
    "        imamo_sodo = True\n",
    "\n",
    "if imamo_sodo:\n",
    "    print(\"Seznam vsebuje sodo število\")\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje sodega števila\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V začetku si rečemo, da nimamo nobenega sodega števila. Nato gremo prek vseh števil in čim naletimo na kakega sodega, zabeležimo, da smo, aleluja, našli sodo število.\n",
    "\n",
    "(\n",
    "\n",
    "Kak duhovitež bi gotovo raje napisal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "ostanki = 0\n",
    "for e in s:\n",
    "    ostanki += e % 2\n",
    "if ostanki != len(s):\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in nam tako pokvaril lekcijo. Ignorirajmo ga. :)\n",
    "\n",
    ")\n",
    "\n",
    "Ne naredite klasične napake. Tole je narobe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam ne vsebuje sodega števila\n"
     ]
    }
   ],
   "source": [
    "s = [11, 13, 5, 12, 5, 16, 7]\n",
    "imamo_sodo = False\n",
    "for e in s:\n",
    "    if e % 2 == 0:\n",
    "        imamo_sodo = True\n",
    "    else:\n",
    "        imamo_sodo = False\n",
    "\n",
    "if imamo_sodo:\n",
    "    print(\"Seznam vsebuje sodo število\")\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje sodega števila\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta program se bo ob vsakem lihem številu delal, da doslej ni bilo še nobenega sodega - zaradi `imamo_sodo = False` bo pozabil, da je kdajkoli videl kako sodo število. V gornjem seznamu bo, recimo, pregledal vsa števila, končal bo s 7 in si ob tem rekel `imamo_sodo = False`. Rezultat bo tako napačen.\n",
    "\n",
    "Kako pa ugotovimo, ali ima seznam *sama soda števila*?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam ne vsebuje samo sodih števil\n"
     ]
    }
   ],
   "source": [
    "sama_soda = True\n",
    "for e in s:\n",
    "    if e % 2 != 0:\n",
    "        sama_soda = False\n",
    "\n",
    "if sama_soda:\n",
    "    print(\"Seznam vsebuje sama soda število\")\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje samo sodih števil\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(\n",
    "\n",
    "Duhovitež ne lenari in napiše:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "ostanki = 0\n",
    "for e in s:\n",
    "    ostanki += e % 2\n",
    "if ostanki == 0:\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ")\n",
    "\n",
    "Spet bomo naredili podobno napako kot prej, če bomo pisali:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = [11, 13, 5, 12, 5, 16, 72]\n",
    "sama_soda = True\n",
    "for e in s:\n",
    "    if e % 2 != 0:\n",
    "        sama_soda = False\n",
    "    else:\n",
    "        sama_soda = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Program že takoj, ko vidi 1, ugotovi, da niso vsa števila v seznamu soda, in postavi `sama_soda = False`. Vendar melje seznam naprej in ob vsakem koraku znova nastavlja `sama_soda`. Ko pride do 72, postavi `sama_soda` na `True`. To pa je ravno zadnje število; `sama_soda` ostane `True`... pa smo tam.\n",
    "\n",
    "### Prekinjanje zank\n",
    "\n",
    "Ko smo prejšnji teden pisali zanko `while`, smo postavili pogoj, do kdaj naj se izvaja. Zanka for bo, če se vmes ne pripeti kaj posebnega, šla vedno od začetka do konca seznama (terke, niza, datoteke...)\n",
    "\n",
    "Včasih to ni potrebno. Pravzaprav smo pravkar videli takšen primer: rezultat gornjega programa je znan že, čim naletimo na prvo liho število. Torej bi bilo čisto vseeno, če računalnik v tistem trenutku konča pregledovanje. To mu v resnici lahko naročimo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam ne vsebuje samo sodih števil\n"
     ]
    }
   ],
   "source": [
    "sama_soda = True\n",
    "for e in s:\n",
    "    if e % 2 != 0:\n",
    "        sama_soda = False\n",
    "        break\n",
    "\n",
    "if sama_soda:\n",
    "    print(\"Seznam vsebuje sama soda število\")\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje samo sodih števil\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ukaz `break` pomeni, da želimo prekiniti zanko. Program skoči \"ven\" iz zanke in nadaljuje z izvajanjem ukazov, ki sledijo zanki.\n",
    "\n",
    "Na podoben način lahko prekinemo tudi `while` - kot ste nekateri uspešno  počeli že prejšnji teden.\n",
    "\n",
    "Tule je bil `break` bolj zaradi lepšega - da računalnik ne izgublja časa brez potrebe, češ elektrika je draga, pa globalno segrevanje pa te stvari. Poskusimo napisati program, ki takrat, ko seznam ni vseboval samo sodih števil, izpiše prvo liho število."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam ne vsebuje samo sodih števil:  prvo liho število je 5\n"
     ]
    }
   ],
   "source": [
    "sama_soda = True\n",
    "for e in s:\n",
    "    if e % 2 != 0:\n",
    "        sama_soda = False\n",
    "        liho = e\n",
    "\n",
    "if sama_soda:\n",
    "    print(\"Seznam vsebuje samo soda števila\")\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje samo sodih števil:\",\n",
    "          \" prvo liho število je\", liho)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Brez `break` tole ne deluje: namesto prvega izpiše zadnje liho število. Rešimo se lahko z dodatnim pogojem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam ne vsebuje samo sodih števil:  prvo liho število je 11\n"
     ]
    }
   ],
   "source": [
    "sama_soda = True\n",
    "for e in s:\n",
    "    if e % 2 != 0 and sama_soda:\n",
    "        sama_soda = False\n",
    "        liho = e\n",
    "\n",
    "if sama_soda:\n",
    "    print(\"Seznam vsebuje samo soda števila\")\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje samo sodih števil:\",\n",
    "          \" prvo liho število je\", liho)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S tem, ko smo dodali `and sama_soda` smo poskrbeli, da se bosta `sama_soda = False` in `liho = e` izvedla le prvič. Ko bomo postavili `sama_soda` na `False`, bomo dosegli, da pogoj ne bo nikoli nikoli več resničen.\n",
    "\n",
    "(Mimogrede opozorimo: napisali smo `and sama_soda` in ne `and sama_soda == True`. Rezultat izraza `sama_soda == True` je enak `True` natančno takrat, ko je `sama_soda` enak `True`. Torej tisti `== True` ne naredi ničesar. Če kdo ne razume, naj raje razmisli, ali bi bilo smiselno pisati `(sama_soda == True) == True)` ali celo `((sama_soda == True) == True) == True`. Če meni, da ne, potem naj tudi `sama_soda == True` ne piše, saj je enak nesmiselno.)\n",
    "\n",
    "Namesto dodatnega pogoja lahko napišemo `break`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam ne vsebuje samo sodih števil:  prvo liho število je 11\n"
     ]
    }
   ],
   "source": [
    "sama_soda = True\n",
    "for e in s:\n",
    "    if e % 2 != 0:\n",
    "        sama_soda = False\n",
    "        liho = e\n",
    "        break\n",
    "\n",
    "if sama_soda:\n",
    "    print(\"Seznam vsebuje samo soda števila\")\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje samo sodih števil:\",\n",
    "          \" prvo liho število je\", liho)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S tem se program lahko pravzaprav še bolj poenostavi. Ko zanko prekinemo, `e` ostane, kar je bil. Torej ne potrebujemo več spremenljivke `liho`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam ne vsebuje samo sodih števil:  prvo liho število je 11\n"
     ]
    }
   ],
   "source": [
    "sama_soda = True\n",
    "for e in s:\n",
    "    if e % 2 != 0:\n",
    "        sama_soda = False\n",
    "        break\n",
    "\n",
    "if sama_soda:\n",
    "    print(\"Seznam vsebuje samo soda števila\")\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje samo sodih števil:\",\n",
    "          \" prvo liho število je\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Else po zanki\n",
    "-------------\n",
    "\n",
    "Medtem, ko je ukaz `break` zelo običajna žival v vseh programskih jezikih, ima Python še eno posebnost, povezano z zankami. V večini programskih jezikov lahko `else` uporabimo le kot alternativo `if`-u. V Pythonu pa lahko `else` sledi tudi zanki `for` ali `while`. V pogojnem stavku (`if`) se koda v `else` izvede, če pogoj ni bil resničen. Po zanki se `else` izvede, če se zanka *ni prekinila* zaradi `break`. Torej, `else` se izvede pri zankah, ki so se iztekle \"po naravni poti\".\n",
    "\n",
    "Oglejmo si še enkrat gornji program. Kar smo počeli v njem, je kar pogosto: v zanki nekaj iščemo (recimo kako liho število). Če to reč najdemo, nekaj storimo (ga izpišemo) in prekinemo zanko. Sicer (torej, če ga ne najdemo), storimo kaj drugega (izpišemo, da ga nismo našli).\n",
    "\n",
    "Zgornji odstavek se približno, a ne čisto povsem prilega zadnjemu kosu programa. V resnici je napisan po spodnjem programu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam ne vsebuje samo sodih števil: prvo liho število je 11\n"
     ]
    }
   ],
   "source": [
    "for e in s:\n",
    "    if e % 2 != 0:\n",
    "        print(\"Seznam ne vsebuje samo sodih števil:\",\n",
    "              \"prvo liho število je\", e)\n",
    "        break\n",
    "else:\n",
    "    print(\"Seznam vsebuje samo soda števila\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pravi: če najdemo liho število, napišemo, da seznam vsebuje liho število in prekinemo zanko. Ta del je jasen. Ne spreglejte pa, kje je `else`: poravnan je s `for` ne z `if`! Ta `else` se torej nanaša na `for`. Kar napišemo v `else`-u za `for`, se zgodi, če se zanka ni prekinila z `break`om.\n",
    "\n",
    "\n",
    "### Razpakiranje v zanki `for` in še malo telovadbe\n",
    "\n",
    "Nekoč na začetku predavanja smo imeli seznam študentov in njihovih tež:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "podatki = [\n",
    "    (74, \"Anze\", False),\n",
    "    (82, \"Benjamin\", False),\n",
    "    (58, \"Cilka\", True),\n",
    "    (66, \"Dani\", False),\n",
    "    (61, \"Eva\", True),\n",
    "    (84, \"Franc\", False),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recimo, da bi radi izpisali imena študentov in njihove teže.\n",
    "\n",
    "Če gremo prek seznama z zanko `for`, bomo dobivali terke. Te lahko, vemo, razpakiramo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anze :  74\n",
      "Benjamin :  82\n",
      "Cilka :  58\n",
      "Dani :  66\n",
      "Eva :  61\n",
      "Franc :  84\n"
     ]
    }
   ],
   "source": [
    "for student in podatki:\n",
    "    teza, ime, spol = student\n",
    "    print(ime, \": \", teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gre pa še dosti elegantneje: razpakiranje lahko opravimo kar znotraj glave zanke, brez (nepotrebne) terke `student`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anze :  74\n",
      "Benjamin :  82\n",
      "Cilka :  58\n",
      "Dani :  66\n",
      "Eva :  61\n",
      "Franc :  84\n"
     ]
    }
   ],
   "source": [
    "for teza, ime, je_zenska in podatki:\n",
    "    print(ime, \": \", teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Program torej pravi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "za vsako trojko (teza, ime, je_zenska) iz seznama podatki:\n",
    "    izpisi ime in tezo\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lahko pa se tudi malo igramo in izrišemo graf:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anze **************************************************************************\n",
      "Benjamin **********************************************************************************\n",
      "Cilka **********************************************************\n",
      "Dani ******************************************************************\n",
      "Eva *************************************************************\n",
      "Franc ************************************************************************************\n"
     ]
    }
   ],
   "source": [
    "for teza, ime, je_zenska in podatki:\n",
    "    print(ime + \" \" + \"*\" * teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Skoraj, ampak ne čisto. Vse skupaj bi radi še poravnali. O tem, kako se v resnici oblikuje izpis, se bomo pogovarjali drugič, danes pa bomo s tem opravili nekoliko po domače. Predpostavimo, da so imena dolga največ 15 znakov. Pred vsako ime bomo dopisali toliko presledkov, da bo skupna dolžina enaka 15. (Mimogrede bom izdal, da tudi dolžino niza, ne le seznamov, dobimo s funkcijo `len`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           Anze **************************************************************************\n",
      "       Benjamin **********************************************************************************\n",
      "          Cilka **********************************************************\n",
      "           Dani ******************************************************************\n",
      "            Eva *************************************************************\n",
      "          Franc ************************************************************************************\n"
     ]
    }
   ],
   "source": [
    "for teza, ime, je_zenska in podatki:\n",
    "    print(\" \" * (15 - len(ime)) + ime + \" \" + \"*\" * teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Zanka po dveh seznamih\n",
    "\n",
    "Zdaj pa izpišimo imena in teže, pri tem, da se le-te nahajajo v ločenih seznamih."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "teze = [74, 82, 58, 66, 61, 84]\n",
    "imena = [\"Anze\", \"Benjamin\", \"Cilka\", \"Dani\", \"Eva\", \"Franc\"]\n",
    "studentka = [False, False, True, False, True, False]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naivno bi se lotili takole"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (864839162.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[60], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m    print(ime, \":\", ????\u001b[0m\n\u001b[0m                    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "for ime in imena:\n",
    "    print(ime, \":\", ????"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "in potem obstali, ker na tem mestu ne moremo priti do teže študenta s tem imenom. Do običajne in zelo zelo zelo napačne rešitve nas pripelje ta zgrešeni premislek: zanko moramo speljati prek imen in prek tež, torej"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anze :  74\n",
      "Anze :  82\n",
      "Anze :  58\n",
      "Anze :  66\n",
      "Anze :  61\n",
      "Anze :  84\n",
      "Benjamin :  74\n",
      "Benjamin :  82\n",
      "Benjamin :  58\n",
      "Benjamin :  66\n",
      "Benjamin :  61\n",
      "Benjamin :  84\n",
      "Cilka :  74\n",
      "Cilka :  82\n",
      "Cilka :  58\n",
      "Cilka :  66\n",
      "Cilka :  61\n",
      "Cilka :  84\n",
      "Dani :  74\n",
      "Dani :  82\n",
      "Dani :  58\n",
      "Dani :  66\n",
      "Dani :  61\n",
      "Dani :  84\n",
      "Eva :  74\n",
      "Eva :  82\n",
      "Eva :  58\n",
      "Eva :  66\n",
      "Eva :  61\n",
      "Eva :  84\n",
      "Franc :  74\n",
      "Franc :  82\n",
      "Franc :  58\n",
      "Franc :  66\n",
      "Franc :  61\n",
      "Franc :  84\n"
     ]
    }
   ],
   "source": [
    "for ime in imena:\n",
    "    for teza in teze:\n",
    "        print(ime, \": \", teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rezultat je nepričakovan za vse tiste, ki ga niso pričakovali. Program namreč izpiše"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Anze : 74\n",
    "Anze : 82\n",
    "Anze : 58\n",
    "Anze : 66\n",
    "Anze : 61\n",
    "Anze : 84\n",
    "Benjamin : 74\n",
    "Benjamin : 82\n",
    "Benjamin : 58\n",
    "Benjamin : 66\n",
    "Benjamin : 61\n",
    "Benjamin : 84\n",
    "Cilka : 74\n",
    "Cilka : 82\n",
    "... in tako naprej"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Računalniki imajo to nadležno navado, da vedno naredijo natanko tisto, kar jim naročimo. In v tem primeru smo mu naročili tole:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "za vsako ime na seznamu ime stori tole:\n",
    "    za vsako tezo na seznamu tez stori tole:\n",
    "        izpisi ime in tezo\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kdor ne razume, kaj se je zgodilo in zakaj, naj to nujno premisli, da se ne bo kasneje učil na lastnih napakah.\n",
    "\n",
    "Ko bo to opravljeno, bo razumel: potrebujemo samo eno zanko, ki gre istočasno po obeh seznamih. Aha, takole?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block after 'for' statement on line 1 (3741743949.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[62], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m    for teza in teze:\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block after 'for' statement on line 1\n"
     ]
    }
   ],
   "source": [
    "for ime in imena:\n",
    "for teza in teze:\n",
    "    print(ime, \": \", teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ummm, ne. Ena zanka je ena zanka. To sta dve.\n",
    "\n",
    "Nekaterim študentom so tule prišli na misel indeksi. (Nekateri zanje ne vejo, kar je dobro zanje. Odstavek lahko preskočijo.) Ta rešitev je slaba. V modernih jezikih razmišljamo na malo drugačen način, zato se ji, če se le da, izognemo, saj vodi v manj pregledne, manj učinkovite, slabše programe.\n",
    "\n",
    "To je tako pomembno, da bom kar še enkrat ponovil: tega **ne rešujemo z** `for i in range(len(imena)):`.\n",
    "\n",
    "Funkcija `zip` združi dva seznama (ali več seznamov) v seznam terk."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    ">>> zip(teze, imena)\n",
    "[(74, 'Anze'), (82, 'Benjamin'), (58, 'Cilka'), (66, 'Daniel'), (61, 'Eva'), (84, 'Franc')]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    ">>> zip(teze, imena, studentka)\n",
    "[(74, 'Anze', False), (82, 'Benjamin', False), (58, 'Cilka', True),\n",
    "(66, 'Daniel', False), (61, 'Eva', True), (84, 'Franc', False)]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    ">>> zip(teze, imena, studentka, teze)\n",
    "[(74, 'Anze', False, 74), (82, 'Benjamin', False, 82),\n",
    "(58, 'Cilka', True, 58), (66, 'Daniel', False, 66),\n",
    "(61, 'Eva', True, 61), (84, 'Franc', False, 84)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "**Opomba**: tule goljufam. Tak izpis dobimo v starejših Pythonih. Od različice 3.0 naprej si lahko le predstavljamo, da `zip` dela takole. V resnici naredi nekaj majčkeno drugačnega (kaj, je za nas ta mesec še prezapleteno), rezultat pa je za nas (ta mesec) isti.\n",
    "\n",
    "Zipamo lahko vse, prek česar lahko naženemo zanko `for`.  Torej ne le seznamov, temveč tudi nize, terke in še kaj."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "editable": true,
    "raw_mimetype": "",
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    ">>> zip(\"abcd\", \"ABCD\")\n",
    "[('a', 'A'), ('b', 'B'), ('c', 'C'), ('d', 'D')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Rešimo torej nalogo: izpišimo imena in teže iz ločenih seznamov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anze :  74\n",
      "Benjamin :  82\n",
      "Cilka :  58\n",
      "Dani :  66\n",
      "Eva :  61\n",
      "Franc :  84\n"
     ]
    }
   ],
   "source": [
    "for ime, teza in zip(imena, teze):\n",
    "    print(ime, \": \", teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Za konec pa izpišimo še poprečno težo študentk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59.5\n"
     ]
    }
   ],
   "source": [
    "skupna_teza = 0\n",
    "studentk = 0\n",
    "for teza, je_zenska in zip(teze, studentka):\n",
    "    if je_zenska:\n",
    "        skupna_teza += teza\n",
    "        studentk += 1\n",
    "print(skupna_teza / studentk)  # ... ob predpostavki, da studentk > 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "(Tisti, ki so prejšnjo uro slišali tale trik, ne potrebujejo predpostavke, da imamo kakšno študentko, saj napišejo `skupna_teza / (studentk or 1)`.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Zanka prek parov zaporednih elementov\n",
    "\n",
    "Recimo, da imam seznam in bi rad naredil seznam razlik zaporednih elementov.\n",
    "Torej, če imam seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "s = [5, 3, 8, 2, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "bi rad pridelal\n",
    "seznam `[2, -5, 6, 1]` (ker je 5 - 3 = 2, 3 - 8 = -6, 8 - 2 = 6,\n",
    "2 - 1 = 1).\n",
    "\n",
    "Neučakani naredijo tole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = []\n",
    "for i in range(1, len(s)):\n",
    "    t.append(s[i - 1] - s[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To je pravilno, ni pa elegantno in ne vodi daleč. Obstaja boljši način: funkcija `pairwise`, ki jo pričaramo iz modula `itertools`. Podamo ji seznam (ali kaj podobnega) pa nam vrača pare zaporednih elementov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 3)\n",
      "(3, 8)\n",
      "(8, 2)\n",
      "(2, 1)\n"
     ]
    }
   ],
   "source": [
    "from itertools import pairwise\n",
    "\n",
    "for x in pairwise(s):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Torej nam je sestaviti seznam tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = []\n",
    "for prej, potem in pairwise(s):\n",
    "    t.append(prej - potem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, -5, 6, 1]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če znamo razmišljati tako, bomo kasneje, ko pride na vrsto, tudi lažje\n",
    "razumeli krajšo rešitev:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = [prej - potem for prej, potem in pairwise(s)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Funkcijo `pairwise` je Python dobil v različici 3.10. Kako dobiti pare zaporednih elementov v starejših različicah, bomo izvedeli naslednji teden, v naslednjih zapiskih."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "### Dolžina seznama, terke, niza\n",
    "\n",
    "Seznami, terke in naši stari znanci nizi imajo nekaj skupnega. Pravzaprav veliko skupnega. Razlikujejo se le v podrobnostih. Skupno jim je, recimo, da imajo vsi trije dolžino. Gornji seznami šestih tež, šestih imen in šestih indikatorjev spola so dolžine 6. Terka `(1, 2, 3, 4)` ima dolžino 4 in niz \"Benjamin\" je dolžine 8. Dolžine reči, ki imajo dolžino, nam pove funkcija `len`. To sem napisal tako imenitno, da bom moral še enkrat, da bo sploh kdo razumel: funkcija `len`sprejme en argument, recimo seznam, terko ali niz in kot rezultat vrne dolžino tega seznama, terke ali niza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 'Benjamin'\n",
    "len(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(podatki)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len((1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax. Perhaps you forgot a comma? (303441268.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[74], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m    Traceback (most recent call last):\u001b[0m\n\u001b[0m               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax. Perhaps you forgot a comma?\n"
     ]
    }
   ],
   "source": [
    ">>> len(12)\n",
    "Traceback (most recent call last):\n",
    "File \"\", line 1, in TypeError: object of type 'int' has no len()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Morda je koga presenetilo zadnje: številka 12 bi lahko bila dolga 12, ne? Ali pa 2, ker ima dve števki? Ne. Funkcija `len` v bistvu pove *število elementov, ki jih vsebuje podani argument*. Niz \"Benjamin\" vsebuje 8 znakov, seznam `podatki` vsebuje 6 podseznamov in terka `(1, 2, 3)` ima tri elemente. Število 12 pa nima elementov.\n",
    "\n",
    "Še ena prikladna značilnost seznamov (nizov, terk in še česa): prazni seznami so, tako kot prazni nizi, neresnični. Seznam lahko uporabimo v pogoju."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Seznam s ni prazen\n"
     ]
    }
   ],
   "source": [
    "if s:\n",
    "    print(\"Seznam s ni prazen\")\n",
    "else:\n",
    "    print(\"Seznam s je prazen\")"
   ]
  }
 ],
 "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.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}