p1/predavanja/03b indeksi in rezine.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Štetje z zanko `for`\n",
    "\n",
    "V programih pogosto potrebujemo še dva tipa zank. Pogosto bomo želeli\n",
    "nekaj ponoviti vnaprej predpisano (ali pred zanko izračunano) število\n",
    "ponovitev, recimo petkrat ali desetkrat. Prav tako bomo pogosto želeli,\n",
    "da program \"šteje\" od 10 do 20, od 0 do 100 ali kaj takega.\n",
    "\n",
    "Za oboje bo poskrbela kar zanka for, ob pomoči priročne funkcije\n",
    "`range`.\n",
    "\n",
    "Funkcija `range` je na prvi pogled povsem neimpresivna. Vrača sezname\n",
    "zaporednih števil.\n",
    "\n",
    "V Pythonu 3.0 je ta funkcija narejena boljše kot v različicah pred njim,\n",
    "vendar je nova oblika za začetnika manj očitna, zato bomo za trenutek\n",
    "skočili v stari Python 2.7. Kar sledi, v novem Pythonu namreč ne bi dalo\n",
    "enakih izpisov - imelo pa bi (praktično) ekvivalenten učinek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> range(5, 10)\n",
    "[5, 6, 7, 8, 9]\n",
    ">>> range(10, 20)\n",
    "[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
    ">>> range(7)\n",
    "[0, 1, 2, 3, 4, 5, 6]\n",
    ">>> range(16)\n",
    "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj dela, je očitno. In očitno ... čudno. `range(a, b)` vrne seznam\n",
    "celih števil od `a` do `b`, vključno s prvim, a brez zadnjega. Če podamo\n",
    "le en argument, pa začne z ničlo. Zakaj vključi prvega, zadnjega pa ne?\n",
    "Mogoče je bil tisti, ki je to programiral, malo šlampast? Ni dobro razmislil? Ali pa je preveč razmišljal in se ni\n",
    "mogel odločiti, zato se je odločil za čuden kompromis?\n",
    "\n",
    "Niti ne. Funkcija `range` je narejena točno tako, kot je treba. Najprej:\n",
    "če si na morju od 17 do 22 julija, koliko dni si bil na morju? Kadar se\n",
    "znajdem pred takšno uganko (in pred njo se znajdem vsakič, ko moram\n",
    "fakulteti napisati poročilo s službene poti), štejem na prste. Ja, vem,\n",
    "22 - 17 + 1, ampak ... zihr je zihr.\n",
    "\n",
    "V Pythonu je to preprosteje. Koliko elementov ima seznam, ki ga vrne\n",
    "`range(17, 22)`? 22 - 17 = 5. Zato, ker seznam vsebuje prvi element, ne\n",
    "pa tudi zadnjega. (Temu lahko, z vidika počitnic, rečemo hotelski\n",
    "izračun: spat si šel 17, 18, 19, 20 in 21, ne pa tudi 22. Pet noči.\n",
    "\n",
    "Koliko elementov ima seznam, ki ga vrne `range(7)`? Sedem. Zato ker\n",
    "vsebuje prvi element in ne zadnjega, in ker se začne z 0.\n",
    "\n",
    "Funkcija `range` je torej narejena praktično, ker se težko zmotimo glede\n",
    "tega, koliko elementov bo vrnila.\n",
    "\n",
    "Lepo se tudi sešteva. `range(10, 15) + range(15, 20)` so ravno vsa\n",
    "števila od 10 do 20. Če bi bil `range(10, 15)` enak\n",
    "`[10, 11, 12, 13, 14, 15]`, bi se v `range(10, 15) + range(15, 20)`\n",
    "število 15 ponovilo dvakrat.\n",
    "\n",
    "Vem, da vas (najbrž) nisem prepričal. Da je res dobro, da je `range`\n",
    "tako čuden, boste zares razumeli ob nečem v zvezi s seznami. In še to\n",
    "šele takrat, ko vam zlezejo bolj pod kožo. Do takrat se zanesimo na\n",
    "argument avtoritete: to je dobro zato, ker je Demšar tako rekel.\n",
    "\n",
    "Funkcija ima lahko še en, tretji argument. Ta predstavlja korak."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> range(5, 15, 2)\n",
    "[5, 7, 9, 11, 13]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Korak je lahko tudi negativen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> range(10, 0, -1)\n",
    "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
    ">>> range(10, 0, -3)\n",
    "[10, 7, 4, 1]\n",
    ">>> range(10, 0, -5)\n",
    "[10, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcijo `range` uporabljamo skoraj izključno v zankah `for`.\n",
    "\n",
    "V prvi zanki `while`, ki smo jo napisali, smo izpisali števila od 1 do\n",
    "10, takole nekako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i < 11:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z zanko `for` je preprostejši."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seveda ostaja odprto vprašanje, zakaj bi si kdo tako želel izpisati\n",
    "števila od 1 do 10. Štetje je kljub temu uporabno tudi za kaj drugega,\n",
    "ne le za izpisovanje.\n",
    "\n",
    "### Praštevila\n",
    "\n",
    "Napisati želimo program, ki pove, ali je dano število praštevilo. Za to\n",
    "bomo preverili vsa števila od `2` do `n - 1`: če katerokoli od njih deli `n`,\n",
    "potem `n` ni praštevilo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input(\"Vpiši število\"))\n",
    "\n",
    "je_prastevilo = True\n",
    "for i in range(2, n):\n",
    "    if n % i == 0:\n",
    "        je_prastevilo = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V začetku predpostavimo, da je število praštevilo\n",
    "(`je_prastevilo = True`). Če nato med števili med 2 in n\n",
    "(`for i in range(2, n)`) naletimo na njegov delitelj (`if n % i == 0`),\n",
    "pa presodimo, da število pač ne more biti praštevilo\n",
    "(`je_prastevilo = False`). Mimogrede naj opozorimo na napako, na katero\n",
    "stalno opozarjamo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input(\"Vpiši število\"))\n",
    "\n",
    "je_prastevilo = True\n",
    "for i in range(2, n):\n",
    "    if n % i == 0:\n",
    "        je_prastevilo = False\n",
    "    else:\n",
    "        je_prastevilo = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ko je število enkrat obsojeno kot sestavljeno, ga ne moremo več\n",
    "\"pomilostiti\" nazaj v praštevilo. Če je tako, pa tudi ni potrebe, da\n",
    "bi po tem, ko enkrat odkrijemo delitelj, sploh še preverjali naslednje\n",
    "potencialne delitelje. Zdaj že vemo: `break`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input(\"Vpiši število\"))\n",
    "\n",
    "je_prastevilo = True\n",
    "for i in range(2, n):\n",
    "    if n % i == 0:\n",
    "        je_prastevilo = False\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indeksiranje\n",
    "\n",
    "Do elementov seznamov, terk in nizov ne pridemo le z zanko for. Dobimo\n",
    "jih lahko tudi tako, da preprosto zahtevamo element na tem in tem mestu.\n",
    "Vzemimo za primer seznam imen. Spomnimo se, kako je videti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena = ['Anze', 'Benjamin', 'Cilka', 'Dani', 'Eva', 'Franc']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spremenljivka `imena` vsebuje šest elementov. Če hočemo dostopati do\n",
    "posameznega elementa - recimo izpisati njegovo vrednost - povemo njegov\n",
    "indeks, \"zaporedno številko\". Zapišemo jo v oglate oklepaje za imenom\n",
    "spremenljivke, takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena[2]\n",
    "'Cilka'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pravi, `imena[2]` vrne drugi element seznama.\n",
    "\n",
    "Emmm, drugi?! Mar ni drugi element Benjamin, ne Cilka? Drži, ampak kakor\n",
    "šteje python, je drugi element Cilka. Anže je pa ničti. Ne le v pythonu,\n",
    "skoraj v vseh jezikih štejemo od 0. Prvi element ima *indeks* 0, drugi\n",
    "element 1 in tretji 2. Zakaj? Razlogi so tehnični in praktični.\n",
    "Tehničnega boste razumeli, če boste kdaj programirali v C-ju. Tradicionalno indeks pomeni \"odmik od začetka\": ko je odmik 0,\n",
    "dobimo prvi element in ko je odmik 2, se odmaknemo dva elementa, torej\n",
    "pristanemo na tretjem (torej: tistem, ki mu normalni ljudje rečejo tretji). Medtem ko je v Cju (in še nižjih jezikih) ta,\n",
    "tehnični, argument morda smiseln, upravičimo štetje od ničle v Pythonu\n",
    "in drugih višjih jezikih s praktičnostjo: reči se na ta način lepše izidejo.\n",
    "Boste videli.\n",
    "\n",
    "Če je koga zmedlo, povejmo na glas: oglati oklepaji imajo dve vlogi.\n",
    "Prej smo jih uporabljali, da smo vanje zaprli seznam, zdaj vanje\n",
    "zapiramo indekse. Naj vas to ne vznemirja, python bo že pravilno\n",
    "razumel, kaj mislite, celo v tako hecnih situacijah, kot je tale:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> [3, 1, 4, 1, 5, 9][2]\n",
    "4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prvi oklepaji definirajo seznam, drugi zaprejo indeks, 2, ki pove,\n",
    "kateri element tega seznama nas zanima. [Taka raba je nenavadna, ni pa neuporabna. Kako se vam zdi tole: `[\"moski\", \"zenska\"][spol]`, kjer je `spol` enak `True`, če gre za žensko in `False`, če za moškega? In tole: `\"MŽ\"[spol]`?\n",
    "\n",
    "Tako kot sezname indeksiramo tudi terke in nize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Benjamin'[0] \n",
    "'B'\n",
    ">>> 'Benjamin'[2]\n",
    "'n'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kadar seznam vsebuje sezname, bomo včasih uporabljali dvojne indekse.\n",
    "\n",
    "V neki dodatni domači nalogi smo sestavili spiralo iz 10000 števil. Mislim, da noben študent ni bil tako zagnan, da bi res sestavil celotno spiralo in jo zapisal v kak seznam seznamov. Lahko pa si privoščimo zapisati spiralo iz primera."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spirala = [\n",
    "    [37, 36, 35, 34, 33, 32, 31],\n",
    "    [38, 17, 16, 15, 14, 13, 30],\n",
    "    [39, 18,  5,  4,  3, 12, 29],\n",
    "    [40, 19,  6,  1,  2, 11, 28],\n",
    "    [41, 20,  7,  8,  9, 10, 27],\n",
    "    [42, 21, 22, 23, 24, 25, 26],\n",
    "    [43, 44, 45, 46, 47, 48, 49]\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do tretje vrstice pridemo tako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spirala[3]\n",
    "[40, 19,  6,  1,  2, 11, 28]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In drugi element iz tretje vrstice je potem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> spirala[3][2]\n",
    "6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ni razloga, da bi se bali dvojnih ali celo trojnih indeksov. Samo potem postane program nekoliko nepregleden. (V kost za glodanje C-jašem pa naj vprašam, ali `\"Benjamin\"[3][0][0][0][0]` kaj izpiše ali se pritoži, da je tu nekaj narobe. Ampak to je pa *res* neuporabno.)\n",
    "\n",
    "Kaj se zgodi, če je indeks prevelik? Nič lepega."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> \"Benjamin\"[100]\n",
    "Traceback (most recent call last): File \"\",\n",
    "line 1, in IndexError: string index out of range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kako velik pa je lahko indeks? Če ima niz osem črk in je prva ničta, je\n",
    "zadnja sedma. Indeks mora biti torej manjši od dolžine - največji\n",
    "dovoljeni indeks je tisto, kar vrne funkcija `len`, minus 1.\n",
    "\n",
    "Python (in še marsikateri današnji jezik) ima še en trik: indeksiranje s\n",
    "konca: -1 je zadnji element, -2 predzadnji in tako naprej. (Če koga\n",
    "srbi, da bi vprašal, čemu ni zadnji element -0, naj se ugrizne v jezik,\n",
    "ali pa ga zatožim fakultetnim matematikom!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'Benjamin'[-1]\n",
    "'n'\n",
    ">>> 'Benjamin'[-2]\n",
    "'i'\n",
    ">>> 'Benjamin'[-3]\n",
    "'m'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V domačih nalogah in na izpitih pogosto videvam reči, kot je\n",
    "`s[len(s) - 5]`. To je pohvalno, saj pomeni, da zna študent programirati\n",
    "tudi v drugih jezikih, kjer bi moral pisati `s[strlen(s) - 5]` (C in\n",
    "podobni) ali, recimo, `s[count(s) - 5]` (php). V pythonu naj se pa kar\n",
    "lepo navadi, da lahko napiše `s[-5]`.\n",
    "\n",
    "\n",
    "## Rezanje\n",
    "\n",
    "Poleg indeksiranja, ki vrača elemente nizov, seznamov, terk (in še\n",
    "česa), pozna Python še rezanje (*slice*), ki vrača dele nizov, seznamov,\n",
    "terk (in še česa). Rezino opišemo z indeksom prvega elementa in indeksom\n",
    "prvega elementa, ki ga ne želimo več vključiti v rezino. Med indeksa\n",
    "postavimo dvopičje. Se pravi, rezina 2:5 pomeni vse elemente od onega z\n",
    "indeksom 2 do tistega z indeksom 4 (ne 5!).\n",
    "\n",
    "Smo to že kje videli? Smo, seveda. Funckija `range` uporablja natančno\n",
    "isto logiko. Tako kot pri `range` je tudi pri rezanju to odlična ideja.\n",
    "\n",
    "Če študentom od drugega do petega, ki sedijo v prvi vrsti, naj vstanejo:\n",
    "koliko študentov bo vstalo? V običajnem svetu štirje, namreč drugi,\n",
    "tretji, četrti in peti. Štirje, čeprav je 5 - 2 pravzaprav enako 3. V\n",
    "svetu Pythonovih rezin vstanejo samo trije, namreč drugi, tretji in\n",
    "četrti (oziroma tretji, četrti in peti, če štejemo od ena, ne od nič).\n",
    "\n",
    "Še en primer - kasneje bomo videli, zakaj je priročen: kaj, če naročim,\n",
    "naj vstanejo vsi od drugega do petega, čez pol minute pa še vsi od\n",
    "petega do osmega? Koliko jih stoji? In predvsem, kolikokrat stoji peti?\n",
    "Dvakrat? Na prstih? V Pythonu je vstal samo drugič: prvič so vstali\n",
    "študenti 2, 3, in 4, drugič pa 5, 6 in 7. Skupaj jih stoji 5-2=3 iz prve\n",
    "runde in 8-5=3 iz druge. Skupaj šest.\n",
    "\n",
    "Sicer pa smo prav tadva primera obdelovali že pri `range`.\n",
    "\n",
    "Oglejmo si, kaj na to pravi Benjamin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> b[2:5]\n",
    "'nja'\n",
    ">>> b[5:8]\n",
    "'min'\n",
    ">>> b[2:5]+b[5:8]\n",
    "'njamin'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spodnjo ali zgornjo mejo smemo tudi izpustiti. V tem primeru dobimo vse\n",
    "elemente od začetka oz. do konca. Tu bosta izkazali svojo moč prav obe\n",
    "navidez neintuitivni pravili - štetje od 0 in to, da rezina ne vključuje\n",
    "zadnjega elementa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> b[:5]\n",
    "'Benja'\n",
    ">>> b[5:]\n",
    "'min'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`b[:5]` vrne prvih pet elementov. `b[5:]` vrne vse od petega naprej; ker\n",
    "štejemo od 0, to pomeni, da izpustimo prvih pet. Se pravi, če želimo\n",
    "nizu `s` odbiti prvih pet znakov, bomo rekli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = s[5:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da peti študent vstane le enkrat, nam pride prav, če želimo v niz kaj\n",
    "vriniti. Če bi radi za petim znakom niza vrinili X, to storimo takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> b[:5] + \"X\" + b[5:]\n",
    "'BenjaXmin'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ste opazili, da nam sploh ni bilo treba pomisliti na to, da štejemo od\n",
    "0? Vidite, kako naravno je to. Če bi šteli od 1, bi bilo tole precej\n",
    "bolj zapleteno.\n",
    "\n",
    "Še dodatne možnosti prinese indeksiranje od zadaj. Iz niza lahko\n",
    "poberemo, recimo, elemente od predpredpredzadnjega (-5) do predzadnjega\n",
    "(-2). Koliko jih bo? Trije, seveda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> b[-5:-2]\n",
    "'jam'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No, tegale najbrž ne uporabimo velikokrat. Pač pa nas pogosto zanimajo,\n",
    "recimo, zadnji štirje znaki. Ali pa vsi razen zadnjih štirih."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> film = \"Babylon 5 - 3x04 - Passing through Gethsemane.avi\"\n",
    ">>> film[-4:]\n",
    "'.avi'\n",
    ">>> film[:-4]\n",
    "'Babylon 5 - 3x04 - Passing through Gethsemane'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mimogrede, tole sicer varneje delamo s funkcijo, ki smo jo že omenili,\n",
    "namreč `splitext`, ki prejme kot argument ime datoteke in vrne terko z\n",
    "dvema elementoma, imenom datoteke brez končnice in končnico.\n",
    "\n",
    "Kako pa bi od niza odbili prve tri in zadnja dva znaka? Takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "attributes": {
     "classes": [
      "pythnon"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    ">>> b[3:-2]\n",
    "'jam'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Že tale primer pokaže, zakaj je štetje od 0 in čudno pravilo, po katerem\n",
    "je prvi element rezine vključen, zadnji pa ne, tako smiselno in\n",
    "uporabno.\n",
    "\n",
    "Vendar še nismo končali. Izpustimo lahko tudi zgornjo in spodnjo mejo.\n",
    "Kaj dobimo v tem primeru? Cel niz. Je to uporabno? Na nizih pravzaprav\n",
    "ne. Pri čem drugem pa nam bo prišlo še prav.\n",
    "\n",
    "Poleg meja rezine lahko podamo tudi *korak*. Namesto vsakega znaka lahko\n",
    "zahtevamo, recimo, vsak drugi znak, tako da dodamo še eno dvopičje, ki\n",
    "mu sledi velikost koraka."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> '0123456789'[2:9]\n",
    "'2345678'\n",
    ">>> '0123456789'[2:9:2]\n",
    "'2468'\n",
    ">>> '0123456789'[2:9:3]\n",
    "'258'\n",
    ">>>\n",
    "'0123456789'[2:9:4]\n",
    "'26'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Korak je lahko, tako kot pri `range` tudi negativen. V tem primeru je\n",
    "potrebno zamenjati meji - prva mora biti višja od druge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> '0123456789'[9:2:-1]\n",
    "'9876543'\n",
    ">>> '0123456789'[9:2:-2]\n",
    "'9753'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Meje smemo seveda spet tudi izpuščati:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> '0123456789'[9::-1]\n",
    "'9876543210'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Takole obrnemo predavatelja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 'demšar janez'[::-1]\n",
    "'zenaj rašmed'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vse tole je videti nekoliko zapleteno in tuje. In morda je: povaditi bo\n",
    "treba, pa se bo udomačilo. Pa se splača? Za odbijanje znakov od nizov?\n",
    "Se! Lepota je v tem, da se natanko enako kot indeksiranje in rezanje\n",
    "nizov obnaša tudi indeksiranje seznamov in vsega drugega. Pa še kaj -\n",
    "zanke `for`, recimo, ki jih bomo vsak čas spoznali.\n",
    "\n",
    "Poglejmo si torej še rezanje seznamov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena = [\"Anze\", \"Benjamin\", \"Cilka\", \"Dani\", \"Eva\", \"Franc\"]\n",
    ">>> imena[2:5]\n",
    "['Cilka', 'Dani', 'Eva']\n",
    ">>> imena[2:]\n",
    "['Cilka', 'Dani', 'Eva', 'Franc']\n",
    ">>> imena[:2]\n",
    "['Anze', 'Benjamin']\n",
    ">>> imena[:-2]\n",
    "['Anze', 'Benjamin', 'Cilka', 'Dani']\n",
    ">>> imena[-2:]\n",
    "['Eva', 'Franc']\n",
    ">>> imena[::-1]\n",
    "['Franc', 'Eva', 'Dani', 'Cilka', 'Benjamin', 'Anze']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Že videno. Rezanje seznamov se vede enako kot rezanje nizov. Rezanje terk pa prav tako."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Z zip-om prek parov zaporednih elementov\n",
    "\n",
    "Recimo, da imam seznam in bi rad naredil seznam razlik zaporednih elementov.\n",
    "Torej, če imam seznam `s = [5, 3, 8, 2, 1]`, 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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = []\n",
    "for i in range(1, len(s)):\n",
    "    t.append(s[i - 1] - s[i])</xmp>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To je pravilno, ni pa elegantno in ne vodi daleč. Obstaja boljši način.\n",
    "\n",
    "Vemo, da `s[1:]` odbije prvi element seznama. Imamo torej\n",
    "\n",
    "```\n",
    ">>> s\n",
    "[5, 3, 8, 2, 1]\n",
    ">>> s[1:]\n",
    "[3, 8, 2, 1]\n",
    "```\n",
    "\n",
    "Seznama zazipamo.\n",
    "\n",
    "```\n",
    ">>> zip(s, s[1:])\n",
    "[(5, 3), (3, 8), (8, 2), (2, 1)]\n",
    "```\n",
    "\n",
    "Dobili smo seznam parov zaporednih elementov. Z zanko gremo čez te pare,\n",
    "jih razpakiramo, odštevamo in zlagamo v nov seznam. Obljubljena boljša rešitev\n",
    "te naloge je torej:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = []\n",
    "for e1, e2 in zip(s, s[1:]):\n",
    "    t.append(e1 - e2)"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = [e1 - e2 for e1, e2 in zip(s, s[1:])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Spreminjanje seznamov z indeksiranjem in rezanjem\n",
    "\n",
    "Tole je preprosto. Vsak element seznama se vede na nek način kot\n",
    "spremenljivka: lahko mu priredimo vrednost in s tem \"povozimo\"\n",
    "prejšnjo vrednost."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena\n",
    "['Anze', 'Benjamin', 'Cilka', 'Dani', 'Eva', 'Franc']\n",
    ">>> imena[3] = \"Daniel\"\n",
    ">>> imena ['Anze', 'Benjamin', 'Cilka', 'Daniel', 'Eva', 'Franc']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tako kot prej lahko tudi zdaj indeksiramo od spredaj ali od zadaj.\n",
    "\n",
    "Pa rezine? Glede na to, da je rezina podseznam, moramo tudi pri\n",
    "prirejanju rezin prirejati podsezname."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena\n",
    "['Anze', 'Benjamin', 'Cilka', 'Daniel', 'Eva', 'Franc']\n",
    ">>> imena[1:4] = [\"Ben\", \"Cecilija\", \"Dani\"]\n",
    ">>> imena\n",
    "['Anze', 'Ben', 'Cecilija', 'Dani', 'Eva', 'Franc']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mora biti seznam, ki ga prirejamo, enako dolg kot rezina, ki jo bomo\n",
    "povozili? Ne, čemu? Takole zamenjamo tri z dvema:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena[1:4] = [\"Ben-Cecil\", \"Daniel\"]\n",
    ">>> imena\n",
    "['Anze', 'Ben-Cecil', 'Daniel', 'Eva', 'Franc']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ali pa nobenega s tremi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena[2:2] = [\"D2\", \"D3\", \"D4\"]\n",
    ">>> imena\n",
    "['Anze', 'Ben-Cecil', 'D2', 'D3', 'D4', 'Daniel', 'Eva', 'Franc']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z rezinami lahko tudi pobrišemo del seznama."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena\n",
    "['Anze', 'Ben-Cecil', 'D2', 'D3', 'D4', 'Daniel', 'Eva', 'Franc']\n",
    ">>> imena[2:5]\n",
    "['D2', 'D3', 'D4']\n",
    ">>> imena[2:5] = []\n",
    ">>> imena\n",
    "['Anze', 'Ben-Cecil', 'Daniel', 'Eva', 'Franc']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za brisanje obstaja še veliko drugih načinov, recimo tale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> imena\n",
    "['Anze', 'Ben-Cecil', 'Daniel', 'Eva', 'Franc']\n",
    ">>> del imena[2]\n",
    ">>> imena\n",
    "['Anze', 'Ben-Cecil', 'Eva', 'Franc']\n",
    ">>> del imena[1:3]\n",
    ">>> imena\n",
    "['Anze', 'Franc']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če kdo pričakuje, da bomo zdaj povedali še, da enako delamo tudi z nizi\n",
    "in terkami ... se moti. Nizov in terk ne moremo spreminjati!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> b = 'Benjamin'\n",
    ">>> b[2]='a'\n",
    "Traceback (most recent call last):\n",
    "File \"\", line 1, in TypeError: 'str' object does not support item assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tu je torej osnovna razlika med seznamom in terko: seznam je\n",
    "spremenljiv, terka ne. Tudi niza ne moremo spreminjati, kakor smo\n",
    "pravkar videli. Kako pa bi potem zamenjali tretji znak niza b s črko\n",
    "'a'?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> b = b[:2] + 'a' + b[3:]\n",
    ">>> b\n",
    "'Beajamin'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To je seveda nerodno. Čemu je torej tako? Čemu ne moremo spreminjati\n",
    "nizov tako, kot sezname? (In čemu sploh ta trapasta terka?) Videli bomo,\n",
    "da nam pride včasih zelo zelo prav, da so nekateri objekti\n",
    "nespremenljivi. (Nekateri - pogosto tudi jaz - pravijo celo, da jeziki\n",
    "sploh ne bi smeli dopuščati spreminjanja spremenljivk.) Nize pa si v\n",
    "resnici redko želimo spreminjati - da, pogosto jih bomo sestavljali ali\n",
    "obtesovali, zelo redko pa si želimo spreminjati posamezne črke. Zato nas\n",
    "to, da so konstantni, ne bo preveč motilo, velikokrat pa nam bo\n",
    "koristilo.\n",
    "\n",
    "\n",
    "## Računske operacije na seznamih (in drugod)\n",
    "\n",
    "V svojem prvem soočenju s programiranjem smo spoznali aritmetične\n",
    "izraze: seštevali in množili smo števila, jih kvadrirali in računali\n",
    "sinuse. Zadnjič smo naleteli na logične izraze, kjer smo računali z\n",
    "logičnimi vrednostmi, `True` in `False`. Danes je čas, da se nehamo\n",
    "čuditi ob vsakem izrazu posebej in jim dajati pridevke \"aritmetični\"\n",
    "\"logični\" in tako naprej. Računati se da pač z različnimi rečmi in ena\n",
    "od teh reči so tudi seznami.\n",
    "\n",
    "Lahko sezname seštevamo? Kaj dobimo, če seštejemo `[2, 5, -1]` in\n",
    "`[3, 7, 4]`? Dobimo `[5, 12, 3]` ali `[2, 5, -1, 3, 7, 4]`? Oboje bi\n",
    "bilo smiselno, odgovor pa je takšen: če so se seznami doslej vedli tako\n",
    "podobno nizom, naj se še glede seštevanja.Ker je `'abc' + 'def'` enako\n",
    "`'abcdef'`, naj bo tudi `[2, 5, -1] + [3, 7, 4]` enako\n",
    "`[2, 5, -1, 3, 7, 4]`.\n",
    "\n",
    "Podobno je z množenjem. `[2, 5, -1] * 2` bi moralo biti po vsej logiki\n",
    "enako `[2, 5, -1] + [2, 5, -1]`, se pravi `[2, 5, -1, 2, 5, -1]`. In\n",
    "tudi je.\n",
    "\n",
    "K seznamu lahko prištejemo le seznam, k nizu niz, k terki terko. Vse tri\n",
    "pa lahko pomnožimo s celim številom - in z ničemer drugim.\n",
    "\n",
    "Poleg `+` in `*` pa poznajo vsi trije še dva operatorja, `in` in\n",
    "`not in`. S prvim vprašamo, ali seznam oz. terka vsebujeta določen\n",
    "element in ali niz vsebuje določen podniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 1 in [1, 2, 3]\n",
    "True\n",
    ">>> 4 in [1, 2, 3]\n",
    "False\n",
    ">>> 'in' in 'Benjamin'\n",
    "True\n",
    ">>> 'an' in 'Benjamin'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drugi je seveda ravno nasproten, z njim se vprašamo ali seznam (niz) *ne\n",
    "vsebuje* elementa (podniza)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> 1 not in [1, 2, 3]\n",
    "False\n",
    ">>> 4 not in [1, 2, 3]\n",
    "True\n",
    ">>> 'in' not in 'Benjamin'\n",
    "False\n",
    ">>> 'an' not in 'Benjamin'\n",
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V resnici `not in` ni prav potreben, saj je `x not in l` isto kot\n",
    "`not x in l`."
   ]
  }
 ],
 "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": 4
}