p1/kratki zapiski/03 seznami, terke, for.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seznami\n",
    "\n",
    "Python ima podatkovni tip `list`. Jaz to prevedem v *seznam*, eni imajo\n",
    "raje *tabela*, ker se vede malo podobno kot *array* v kakšnem drugem\n",
    "jeziku.\n",
    "\n",
    "-   Zapremo ga v oglate oklepaje. Vsebuje lahko elemente poljubnih\n",
    "    tipov, lahko tudi mešanico tipov, npr. `[\"Ana\", 74, True]`. Ampak\n",
    "    tega ponavadi ne počnemo. Za različne tipe ponavadi uporabljamo\n",
    "    terke (glej spodaj).\n",
    "\n",
    "-   Gre lahko čez več vrstic, če pustimo odprt oklepaj. Zamik v drugi in\n",
    "    nadaljnjih vrsticah je načelno poljuben, vendar se splača lepo\n",
    "    poravnavati."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "teze = [74, 82, 58,\n",
    "        66, 61, 84]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-   Za zadnjim elementom lahko naredimo vejico. To je praktično\n",
    "    predvsem, če bomo, recimo, spreminjali vrstni red."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "imena = [\n",
    "    \"Ana\",\n",
    "    \"Berta\",\n",
    "    \"Cilka\",\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-   `prazen` je zelo slabo ime za seznam. Če kdo napiše `prazen = []`,\n",
    "    grem stavit, da ta seznam ne bo *vedno* prazen. Tudi `seznam` je\n",
    "    slabo ime za seznam.\n",
    "\n",
    "## Terke\n",
    "\n",
    "Terka (`tuple`) je podobna seznamu, samo da jo zapremo v navadne\n",
    "oklepaje, `t = (1, 2, 3).`\n",
    "\n",
    "-   Oklepaje lahko tudi izpustimo: `t = 1, 2, 3`. Tega ponavadi ne\n",
    "    počnemo.\n",
    "-   Če terka vsebuje samo en element, to ni `(42)` temveč `(42, )`. Če\n",
    "    napišemo samo `(42)`, je to samo 42 v oklepaju.\n",
    "-   Pač pa je `()` čisto lepa prazna terka.\n",
    "-   V terko pogosto dajemo stvari različnih tipov.\n",
    "-   Bistvena in skoraj edina razlika med terkami in seznami je, da terk\n",
    "    ne moremo spreminjati. Terke so za razliko od seznamov *immutable*.\n",
    "-   Python interno pogosto uporablja terke. Ko, recimo, pokličemo\n",
    "    funkcijo, Python spakira vse argumente v terko in funkcija v resnici\n",
    "    dobi terko. Samo da programer tega niti ne opazi, to je Pythonova\n",
    "    privatna fora.\n",
    "\n",
    "\n",
    "### Dolžina seznama, terke, niza\n",
    "\n",
    "Funkcija `len(s)` vrne dolžino `s`. `s` je lahko karkoli, kar ima\n",
    "dolžino, npr. niz, seznam, terka, množica, slovar.\n",
    "\n",
    "## Razpakiranje v elemente\n",
    "\n",
    "\n",
    "To je ena najboljših stvari v Pythonu (Kotlin jo delno imitira,\n",
    "JavaScript pa je tu še ful bolj kul).\n",
    "\n",
    "Levo od enačaja je lahko več spremenljivk, če je desno od njega kaj, kar\n",
    "ima natančno toliko elementov. Če bi imeli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "student = (\"Ana\", 65, \"Ž\")\n",
    "prastevila = [2, 3, 5]\n",
    "crke = \"abcdef\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lahko pišemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ime, teza, spol = student\n",
    "prvo, drugo, tretje = prastevila\n",
    "a, b, c, d, e, f = crke"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seveda lahko tudi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ime, teza, spol = (\"Ana\", 65, \"Ž\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "vendar je to čudno, in celo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "ime, teza, spol = \"Ana\", 65, \"Ž\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "saj terk ni potrebno zapirati v oklepaje, vendar je to nečitljivo.\n",
    "\n",
    "Pač pa je zanimivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "x, y = y, x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prirejanje `x, y = y, x` je v bistvu isto kot `x, y = (y, x)`, vendar to vedno pišemo brez oklepajev, ker je vsakemu jasno, da s tem\n",
    "menjamo vrednosti dveh spremenljivk. (Torej: sintakse `x, y = y, x` si\n",
    "niso izmislili za zamenjavo vrednosti spremenljivk, temveč je to\n",
    "slučajni stranski učinek tega, da terk ni potrebno zapirati v oklepaje\n",
    "in da lahko terke razpakiramo.)\n",
    "\n",
    "Število imen levo od enačaja mora biti enako številu elementov stvari na\n",
    "desni. Lahko pa dodamo še spremenljivko, v katero gre višek. Označimo jo\n",
    "z zvezdico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "prvo, drugo, *ostala = [2, 3, 5, 7, 11, 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prvo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "drugo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 11, 13]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ostala"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lahko celo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "prvo, drugo, *ostala, zadnje = [2, 3, 5, 7, 11, 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 11]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ostala"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zvezdica nima zveze s kazalci, temveč prihaja iz drugega vica. To vlogo\n",
    "je prvič dobila ob klicih funkcij, ampak to bomo videli drugič.\n",
    "\n",
    "Razpakiranje v elemente uporabljamo tudi zato, da navidez dosežemo, da\n",
    "lahko funkcija vrača več stvari. Funkcija `splitext(fname)`, ki prejme\n",
    "ime datoteke ter vrne osnovni del in končnico, bi lahko bila definirana\n",
    "tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitext(fname):\n",
    "    dot_idx = fname.rfind(\".\")\n",
    "    base = fname[:dot_idx]\n",
    "    ext = fname[dot_idx:]\n",
    "    return base, ext"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in bi jo klicali z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "osnova, koncnica = splitext(\"en_film.avi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V resnici `return` vrača `return (base, ext)`, samo da tu ne pišemo\n",
    "oklepajev, ob klicu pa to razpakiramo nazaj. Tako sploh ni videti, da\n",
    "delamo s terkami, ampak je videti, kot da vračamo in dobimo dve stvari.\n",
    "Se pravi, v počasnem posnetku se zgodi to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitext(fname):\n",
    "    dot_idx = fname.rfind(\".\")\n",
    "    base = fname[:dot_idx]\n",
    "    ext = fname[dot_idx:]\n",
    "    t = (base, ext)\n",
    "    return t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "ime_konc = splitext(\"en_film.avi\")\n",
    "osnova = ime_konc[0]\n",
    "koncnica = ime_konc[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zanka for\n",
    "\n",
    "C-jevska zanka `for` je samo bolj kompaktno zapisan `while`. Zanka\n",
    "`for(zacetek; pogoj; korak) { nekaj }` je isto kot\n",
    "`zacetek; while (pogoj) { nekaj; korak }`. C ima torej dvakrat isto\n",
    "zanko.\n",
    "\n",
    "Pythonova zanka `for` pa je drugačna od `while`. Je taka kot zanke, ki\n",
    "se ponekod `for each` ali kaj podobnega. Zanka `for` gre vedno čez neko\n",
    "zbirko stvari, recimo čez seznam, terko, niz, množico, slovar, vrstice\n",
    "datoteke, generator..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana\n",
      "Berta\n",
      "Cilka\n",
      "Dani\n",
      "Ema\n"
     ]
    }
   ],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\"]\n",
    "for ime in imena:\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prosim, ne pišite\n",
    "\n",
    "```python\n",
    "for i in range(len(imena)):\n",
    "    ime = imena[i]\n",
    "    print(ime)\n",
    "```\n",
    "\n",
    "### Razpakiranje v zanki `for`\n",
    "\n",
    "Navadite se tako:\n",
    "\n",
    "```python\n",
    "studenti = [(\"Ana\", 65), (\"Berta\", 80), (\"Cilka\", 78)]\n",
    "for ime, teza in studenti:\n",
    "    ...\n",
    "```\n",
    "\n",
    "in celo\n",
    "\n",
    "``` python\n",
    "studenti = [(\"Ana\", (65, 175)), (\"Berta\", (80, 180)), (\"Cilka\", (78, 160))]\n",
    "for ime, (teza, visina) in studenti:\n",
    "    ...\n",
    "```\n",
    "\n",
    "ne pa\n",
    "\n",
    "``` python\n",
    "for i in range(len(studenti)):\n",
    "    ime = studenti[i][0]\n",
    "    teza = studenti[i][1][0]\n",
    "    visina = studenti[i][1][1]\n",
    "```\n",
    "\n",
    "Ker očitno.\n",
    "\n",
    "V obeh zankah, `for` in `while` lahko uporabljamo `break` in `continue`.\n",
    "\n",
    "### Else po zanki\n",
    "\n",
    "Zanki v Pythonu lahko sledi `else`. Kar zapišemo vanj, se izvede, če\n",
    "zanka ni bila prekinjena z `break`.\n",
    "\n",
    "``` python\n",
    "for x in stevila:\n",
    "    if x % 2 == 1:\n",
    "        print(\"Prvo liho število v seznamu je\", x)\n",
    "        break\n",
    "else:\n",
    "    print(\"Seznam ne vsebuje nobenega lihega števila\")\n",
    "```\n",
    "\n",
    "Pozor: `else` je poravnan s `for`, ker se nanaša na zanko, in ne z `if`,\n",
    "kar bi bilo očitno narobe.\n",
    "\n",
    "\n",
    "### Zanka po dveh seznamih\n",
    "\n",
    "Če imamo\n",
    "\n",
    "``` python\n",
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\"]\n",
    "teze = [72, 80, 68, 72, 67]\n",
    "```\n",
    "\n",
    "**ne pišemo**\n",
    "\n",
    "``` python\n",
    "for i in range(len(imena)):\n",
    "    print(imena[i], teze[i])\n",
    "```\n",
    "\n",
    "temveč"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana 74\n",
      "Berta 82\n",
      "Cilka 58\n",
      "Dani 66\n",
      "Ema 61\n"
     ]
    }
   ],
   "source": [
    "for ime, teza in zip(imena, teze):\n",
    "    print(ime, teza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`zip` vrne približno tole:\n",
    "\n",
    "```\n",
    ">>> zip(imena, teze)\n",
    "[('Ana', 72), ('Berta', 80), ('Cilka', 68), ('Dani', 72), ('Ema', 67)]\n",
    "```\n",
    "\n",
    "Tako je bilo pred različico 3. V različici 3 vrne nekaj malo drugačnega,\n",
    "vendar se vede (skoraj) enako.\n",
    "\n",
    "Funkciji `zip` lahko damo poljubno število seznamov in drugih stvari.\n",
    "\n",
    "``` python\n",
    "for ime, teza, crka, stevilka in zip(imena, teze, \"abcdef\", (1, 2, 3, 4, 5)):\n",
    "    ...\n",
    "```\n",
    "\n",
    "Če argumenti nimajo enakega števila elementov, se `zip` ustavi, ko je\n",
    "konec najkrajšega.\n",
    "\n",
    "\n",
    "### Zanka prek številskega intervala\n",
    "\n",
    "Pogosta rabe zanke `for` v C-ish jezikih je `for(i = 0; i < 10; i++)`. V Pythonu je to `for i in range(10)`. Lahko si predstavljamo, da `range` vrne seznam števil. V Pythonu 2.7 bi to bilo tako\n",
    "\n",
    "```python\n",
    ">>> range(5)\n",
    "[0, 1, 2, 3, 4]\n",
    ">>> range(7, 12)\n",
    "[7, 8, 9, 10, 11]\n",
    ">>> range(10, 25, 4)\n",
    "[10, 14, 18, 22]\n",
    ">>> range(20, 10, -2)\n",
    "[20, 18, 16, 14, 12]\n",
    "```\n",
    "\n",
    "Spodnja meja je vključena, zgornja ni, zato da `range(a, b)` vrne `b - a` elementov in zato da\n",
    "\n",
    "```python\n",
    ">>> range(5, 8) + range(8, 10)\n",
    "[5, 6, 7, 8, 9]\n",
    "```\n",
    "\n",
    "Od Pythona 3 naprej, `range` ne vrača seznamov, vendar vse deluje zelo podobno, kot da bi jih. Kaj vrača, izvemo čez par tednov.\n",
    "\n",
    "\n",
    "### Indeksiranje\n",
    "\n",
    "Tole je namerno proti koncu, zato da se čimbolj navadite uporabljati `for` tako, kot je v Pythonu in podobnih jezikih treba.\n",
    "\n",
    "#### \"Običajni\" indeksi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani', 'Ema']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Berta'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indeksi s konca\n",
    "\n",
    "Pogosto potrebujemo zadnji element. Ali predzadnjega. Ne pišemo `imena[len(imena) - 1]` ali `imena[len(imena) - 2]` temveč:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ema'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dani'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rezine\n",
    "\n",
    "S `s[i:j]` dobimo elemente seznama `s` od `i`-tega do `j`-tega. Z `i`-tim, a brez `j`-tega. Torej `j - i` elementov. Enako deluje tudi s terkami in nizi (Python nima nobenih `substr` in podobnih funkcij)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Benjamin\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nja'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če izpustimo spodnjo mejo, gre od začetka, tako da lahko `s[:i]` preberemo kar \"*prvih i elementov*\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ben'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če izpustimo zgornjo mejo, gre do konca. V bistvu `s[i:]` pomeni \"*brez prvih i*\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jamin'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj pa še negativni indeksi: `s[:-i]` pomeni vse do i-tega z desne, se pravi \"*brez zadnjih i*\".  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benja'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In `s[-i:]` je potem \"*zadnjih i elementov*\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'min'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jasno delajo tudi kombinacije."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'enjami'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In še korak."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ejmn'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:10:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In celo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nimajneB'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`s[:]` vrne vse elemente od prvega do zadnjega, torej kopijo. To je uporabno predvsem za sezname. Terke in nizi so nespremenljivi, torej jih nima smisla kopirati."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trik: zaporedni elementi\n",
    "\n",
    "Če je `s` nek seznam, bomo z `zip(s, s[1:])` dobili pare zaporednih\n",
    "elementov. Recimo, da nas zanima, ali števila v nekem seznamu naraščajo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = [2, 5, 8, 6, 10, 11, 15]\n",
    "\n",
    "narascajo = True\n",
    "for prej, potem in zip(s, s[1:]):\n",
    "    if potem <= prej:\n",
    "        narascajo = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še bolj pa mi je pravzaprav všeč"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "for prej, potem in zip(s, s[1:]):\n",
    "    if potem <= prej:\n",
    "        narascajo = False\n",
    "        break\n",
    "else:\n",
    "    narascajo = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Spreminjanje seznamov z indeksiranjem in rezanjem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani', 'Ema']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cecilija', 'Dani', 'Emilija']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[2] = \"Cecilija\"\n",
    "imena[-1] = \"Emilija\"\n",
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana',\n",
       " 'Benjamin',\n",
       " 'Boštjan',\n",
       " 'Brane',\n",
       " 'Cene',\n",
       " 'Brane',\n",
       " 'Cene',\n",
       " 'Dani',\n",
       " 'Emilija']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[1:3] = [\"Benjamin\", \"Boštjan\", \"Brane\", \"Cene\"]\n",
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Benjamin', 'Cene', 'Brane', 'Cene']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena[5:] = []\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vse to je možno početi le s seznami, ne pa tudi z nizi in terkami, saj so nespremenljivi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Računske operacije na seznamih, nizih in terkah\n",
    "\n",
    "Glede seštevanja se seznami in terke vedejo enako kot nizi: operator `+` stakne dva seznama oz. terki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Anamarija'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ana\" + \"marija\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 2, 1, 8, 3]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[5, 7, 2] + [1, 8, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S seštevanjem si pomagamo tudi, če želimo spremeniti element terke ali niza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benjamin'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Be_jamin\"\n",
    "s = s[:2] + \"n\" + s[3:]\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tudi množenje seznamov se vede enako kot množenje nizov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AnaAnaAna'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ana\" * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7, 2, 5, 7, 2, 5, 7, 2]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[5, 7, 2] * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z operatorjem `in` (in `not in`) preverimo, ali seznam vsebuje (in ne vsebuje) določenega elementa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 in [5, 7, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 not in [5, 7, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za nize operator `in` preverja, ali vsebujejo podniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"min\" in \"Benjamin\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"min\" not in \"Benjamin\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dodajanje elementov v seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Benjamin', 'Cene', 'Brane', 'Cene']"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Benjamin', 'Cene', 'Brane', 'Cene', 'Franz']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena.append(\"Franz\")\n",
    "imena"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}