p1/predavanja/05 metode nizov in seznamov.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kako kličemo metode\n",
    "\n",
    "Funkcijam, ki smo jih srečevali doslej, smo, da so kaj naredile, morali dati podatke, na katerih so delale. Funkcija `len` kot argument zahteva seznam ali niz, katerega dolžino bi radi izvedeli. Funkcija `input` kot\n",
    "argument želi niz z vprašanjem, ki bi ga radi zastavili uporabniku. Razen argumentov, ki jih podamo, te funkcije nimajo drugih podatkov (vsaj ne, da bi mi vedeli zanje).\n",
    "\n",
    "Ko smo se učili o seznamih, pa smo mimogrede naleteli na neko nenavadnost: za dodajanje novega elementa v seznam nismo poklicali funkcije, ki bi ji podali seznam in element (na primer `append(imena, \"Ana\")`), temveč smo morali napisati ime seznama, ki mu je sledila pika in `append`, kot argument pa smo navedli le element, ki smo ga želeli dodati, torej `imena.append(\"Ana\")`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena = []\n",
    "imena.append(\"Ana\")\n",
    "imena.append(\"Berta\")\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`append` je očitno nenavaden, ne kličemo ga tako kot druge funkcije.\n",
    "Funkcija `append` \"pripada\" seznamu; zato mu pravimo `imena.append`.\n",
    "Naredimo še en seznam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "teze = []\n",
    "teze.append(55)\n",
    "imena.append(\"Cilka\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[55]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "teze"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vsak seznam ima svoj `append`: `imena` imajo `imena.append` in `teze` imajo `teze.append`.\n",
    "\n",
    "Takšnim funkcijam pravimo *metode*. Klic `imena.append` si predstavljamo, kot da *seznamu `imena` rečemo \"dodaj si element\" `\"Cene\"`* in klic `teze.append(55)` pomeni, da *seznamu `teze` rečemo \"dodaj si element\" `55`*.\n",
    "\n",
    "Pika, `.` izraža nekakšno pripadnost, vsebovanost. Ko smo spoznali module, smo videli, da z `math.sqrt` pridemo do `math`-ove funkcije z imenom `sqrt`. Z `imena.append` zahtevamo \"imenovo\" metodo `append`. In s `teze.append` \"tezovo\" metodo `append`.\n",
    "\n",
    "Takšnih metod je še veliko: takole prosimo niz `ime`, naj nam pove, koliko črk \"n\" vsebuje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ime = \"Benjamin\"\n",
    "ime.count(\"n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Takole pa niz `fname` vprašamo, ali se konča s \"torrent\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fname = \"en film.torrent\"\n",
    "fname.endswith(\".torrent\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kako bi Benjamina spremenili v Benjamaxa? Težko: kot vemo, so nizi nespremenljivi (tako kot terke; od vsega, o čemer smo govorili prejšnji teden, lahko spreminjamo samo sezname). Pač pa lahko vprašamo niz, kako bi bil videti, če \"min\" zamenjano z \"max\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benjamax'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ime.replace(\"min\", \"max\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metode niso povezane s tem, ali je niz shranjen v spremenljivki ali ne. Metodo moremo poklicati tudi na nizu \"kar tako\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'maja'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Maja\".lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Skoraj vsaka reč v Pythonu ima metode (ali vsaj nekaj podobnega). Celo običajna števila imajo metode, čeprav zgolj tehnično in z zelo čudnimi imeni, kot lahko vedoželjen študent hitro preveri."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3.14\n",
    "x.is_integer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Med tipi, ki smo jih spoznali doslej, pa imajo uporabe vredne metode nizi in seznami. V okviru predavanj ne bomo podrobneje spoznavali vse mogočih podatkovnih tipov. Temeljiteje pa bomo pogledali metode nizov, seznamov in podobnih reči, ki jih pri programiranju v Pythonu vsakodnevno uporabljamo. Obenem bomo tako dobili vtis, kako te reči\n",
    "izgledajo.\n",
    "\n",
    "**Namen tega predavanja ni, da si zapomnite vse te metode in jih znate na pamet za izpit. :)** Namen je le, da dobite predstavo, kako to deluje in kakšne vse stvari obstajajo. Za konkretna imena pa vam bo vedno na voljo dokumentacija.\n",
    "\n",
    "### Metode nizov\n",
    "\n",
    "Nekaj smo jih že spoznali: `count`, `replace` in `lower`. Zadnja ima sestro, `upper`, ki vrne niz, pri katerem so vse črke pretvorjene v velike črke. Podobna sta še `capitalize` in `title`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'maja'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Maja\".lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MAJA'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Maja\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Maja'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"maja\".capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Stavek, Ki Ga Bomo Povelikočrkovali Po Angleško'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"stavek, KI GA bomo povelikočrkovali po anGLEško\".title()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da ne bi kdo pozabil, za vsak slučaj še enkrat spomnimo: te metode ne spreminjajo niza, temveč vračajo nove nize. Nizi ostanejo takšni, kot so bili. Po tem primeru bi moralo biti jasno, kaj ne deluje in kako je potrebno pisati, da bo delovalo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BENJAMIN'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Benjamin\"\n",
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benjamin'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BENJAMIN'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = s.upper()\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metodo `count` smo že spoznali. Povejmo le še, da lahko išče tudi daljše "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Maja\".count(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Maja\".count(\"aj\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poleg `count` imamo tudi nekaj funkcij, ki povedo, kje v nizu se nahaja določen podniz. Prvi sta `find` in `index`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Benjamin\".find(\"jam\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Benjamin\".index(\"jam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Edina razlika med njima je v tem, kaj storita, če iskanega niza ni. `find` vrne -1, `index` pa javi napako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Benjamin\".find(\"max\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-c435d9d16506>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"Benjamin\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"max\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "\"Benjamin\".index(\"max\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če se dani podniz pojavi večkrat, bosta funkciji vrnili indeks prve pojavitve - razen, če jima z dodatnimi argumenti povemo, od kod naprej naj iščeta. Poleg `find` in `index` obstajata še funkciji `rfind` in `rindex`, ki iščeta s konca in tako vrneta zadnjo pojavitev podniza v nizu.\n",
    "\n",
    "Mimogrede smo že omenili tudi preprosto, a zelo uporabno funkcijo `endswith`, ki pove, ali se niz konča s podanim podnizom. Poleg njega obstaja še `startswith`, ki pove ali se niz *začne* z danim podnizom. \n",
    "\n",
    "Metode `ljust`, `rjust` in `center` dopolnijo niz s presledki z leve, z desne ali z obeh strani, tako da je dolg toliko, kot želimo. Takole napihnemo Benjamina na 15 znakov:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benjamin       '"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Benjamin\".ljust(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'       Benjamin'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Benjamin\".rjust(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'    Benjamin   '"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Benjamin\".center(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še enkrat: te metode ne spreminjajo niza, temveč vrnejo nov niz! Nobena metoda ne more spremeniti niza.\n",
    "\n",
    "Metoda `strip` naredi ravno nasprotno: odbije presledke (in tabulatorje in znake za prehod v novo vrstico) na levi in desni strani niza. `lstrip` in `rstrip` pospravita samo levo in samo desno stran."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benjamin'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"     Benjamin    \".strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benjamin    '"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"     Benjamin    \".lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'     Benjamin'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"     Benjamin    \".rstrip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če se zdi ta metoda komu neuporabna, se moti. Zelo. Svojo zmoto bo spoznal, ko pridemo do branja datotek.\n",
    "\n",
    "Nizi imajo še veliko metod. Pogledali bomo le še dve najzanimivejši.\n",
    "\n",
    "Metoda `split` razbije niz na seznam podnizov, kakor jih ločujejo presledki, tabulatorji in znaki za nove vrstice. (V prvem približku: razbije jih na besede.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Metoda',\n",
       " 'split',\n",
       " 'razbije',\n",
       " 'niz',\n",
       " 'na',\n",
       " 'seznam',\n",
       " 'podnizov,',\n",
       " 'kakor',\n",
       " 'jih',\n",
       " 'ločujejo',\n",
       " 'presledki.']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Metoda split razbije niz na seznam podnizov, kakor jih ločujejo presledki.\"\n",
    "s.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Presledkom, tabulatorjem in znakom za novo vrstico rečemo tudi *beli prostor* (*white space*). Namesto glede na beli prostor lahko `split` razbije niz tudi glede na kak drug znak, ki ga moramo v tem primeru podati kot argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['123', '4123', '21']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"123-4123-21\".split(\"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['', '23-4', '23-2', '']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"123-4123-21\".split(\"1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zadnja metoda, `join`, dela ravno obratno kot `split`: združuje nize. Način, na katerega je obrnjena, je nenavaden, a če malo razmislimo, vidimo, da drugače ne bi moglo biti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AnaBertaCilkaDaniEma'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\"]\n",
    "\"\".join(imena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Praznemu nizu, `\"\"`, smo \"naročili\", naj združi nize iz podanega seznama. To sicer ni videti preveč lepo, lepše bo, če jih združimo s kakim ločilom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana - Berta - Cilka - Dani - Ema'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" - \".join(imena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana, Berta, Cilka, Dani, Ema'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\", \".join(imena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana in Berta in Cilka in Dani in Ema'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" in \".join(imena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Najlepše pa bo, če vsa imena do zadnjega združimo z vejicami, nato pa z \"in\" pripnemo še zadnje ime. Ker ravno poznamo rezine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana, Berta, Cilka, Dani in Ema'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\", \".join(imena[:-1]) + \" in \" + imena[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To, mimogrede, deluje celo z dvema imenoma - prvo bo pač pustil pri miru, saj v seznamu, kot je `[\"Ana\"]` ni česa združevati:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ana in Benjamin'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena = [\"Ana\", \"Benjamin\"]\n",
    "\", \".join(imena[:-1]) + \" in \" + imena[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pri enem samem pa malo zataji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' in Ana'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena = [\"Ana\"]\n",
    "\", \".join(imena[:-1]) + \" in \" + imena[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Metode seznamov\n",
    "\n",
    "Tako kot nizi imajo tudi seznami metodi `count` in `index`, o katerih ne bomo izgubljali besed.\n",
    "\n",
    "Medtem ko vam pri nizih metoda `index` ne bo prišla velikokrat na misel, jo boste, sodeč po izkušnjah iz preteklih generacij, pridno zlorabljali na seznamih. Že kaka dva, tri tedne pred temi predavanji jo nekateri študenti odkrijejo in si z njeno pomočjo otežijo reševanje domačih nalog.\n",
    "\n",
    "**Metoda `index` je v resnici uporab(lje)na zelo redko.** Metode `index` prav gotovo ne gre uporabljati znotraj zanke `for`, ki gre prek seznama in ob tem poskuša dobiti indeks trenutnega elementa.\n",
    "\n",
    "Ena tipičnih zlorab je ta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana tehta 72 kilogramov.\n",
      "Berta tehta 78 kilogramov.\n",
      "Cilka tehta 70 kilogramov.\n",
      "Dani tehta 65 kilogramov.\n",
      "Ema tehta 68 kilogramov.\n"
     ]
    }
   ],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\"]\n",
    "teze = [72, 78, 70, 65, 68]\n",
    "for ime in imena:\n",
    "    i = imena.index(ime)\n",
    "    print(ime, \"tehta\", teze[i], \"kilogramov.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tole tule slučajno deluje. Neha pa delovati takoj, ko imamo v seznamu dve enaki imeni: `index` bo vrnil prvo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana tehta 72 kilogramov.\n",
      "Ana tehta 72 kilogramov.\n",
      "Ana tehta 72 kilogramov.\n"
     ]
    }
   ],
   "source": [
    "imena = [\"Ana\", \"Ana\", \"Ana\"]\n",
    "teze = [72, 78, 70]\n",
    "for ime in imena:\n",
    "    i = imena.index(ime)\n",
    "    print(ime, \"tehta\", teze[i], \"kilogramov.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tu se študenti tipično pritožijo: ko se `ime` nanaša na drugo Ano v seznamu, bi morala metoda `index` po njihovem vrniti indeks drugega elementa, `1` in ne `0`.\n",
    "\n",
    "Če bi `index` res delal tako: kaj bi dobili, če bi poklicali `imena.index(\"Ana\")`? V tem primeru se niz `\"Ana\"` ne nanaša na nek specifičen element v seznamu.\n",
    "\n",
    "V resnici je `ime` v gornjem primeru vedno samo `\"Ana\"`. Ne neka konkretna Ana s tega seznama. Samo Ana. In `index` vrne prvo Ano.\n",
    "\n",
    "Vem, vem, zakaj študenti pišejo programe, kot je gornji. Zaradi moje reklame proti `range(len(...))`. Radi bi napisali tole, a si ne upajo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana tehta 72 kilogramov.\n",
      "Berta tehta 78 kilogramov.\n",
      "Cilka tehta 70 kilogramov.\n",
      "Dani tehta 65 kilogramov.\n",
      "Ema tehta 68 kilogramov.\n"
     ]
    }
   ],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\", \"Ema\"]\n",
    "teze = [72, 78, 70, 65, 68]\n",
    "\n",
    "for i in range(len(imena)):\n",
    "    print(imena[i], \"tehta\", teze[i], \"kilogramov.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In prav je, da si ne upajo. To se naredi tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana tehta 72 kilogramov.\n",
      "Berta tehta 78 kilogramov.\n",
      "Cilka tehta 70 kilogramov.\n",
      "Dani tehta 65 kilogramov.\n",
      "Ema tehta 68 kilogramov.\n"
     ]
    }
   ],
   "source": [
    "for ime, teza in zip(imena, teze):\n",
    "    print(ime, \"tehta\", teza, \"kilogramov.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kadar potrebujemo element in indeks, pa uporabimo `enumerate`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 : Ana\n",
      "1 : Berta\n",
      "2 : Cilka\n",
      "3 : Dani\n",
      "4 : Ema\n"
     ]
    }
   ],
   "source": [
    "for i, ime in enumerate(imena):\n",
    "    print(i, \":\", ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Malo smo skrenili s poti, ampak je pomembno. Zato bom povedal še enkrat **preden uporabite `index`, razmislite, ali ga res potrebujete**. Metoda `index` je\n",
    "\n",
    "- nevarna, ker vedno vrne prvi element s podano vrednostjo, in tega morda ne pričakujemo,\n",
    "- počasna, ker mora Python dejansko pregledati seznam do iskanega elementa,\n",
    "- navadno nepotrebna, ker lahko pridemo do indeksa po preprostejši poti,\n",
    "- poleg tega pa navadno brez potrebe zapleta program.\n",
    "\n",
    "Če je tako slab, zakaj obstaja? Ker ga včasih čisto legalno potrebujemo. Zakaj pa o njem govorim programerjem - začetnikom? Zato, ker ga sicer odkrijejo sami. `index` je ena od stvari, za katere je boljše, da otroci o njih slišijo od staršev, ne vrstnikov.\n",
    "\n",
    "Zdaj pa nazaj k metodam.\n",
    "\n",
    "Že nekaj časa vemo za `append`, ki v seznam doda nov element. Pazite, tole je zelo drugače kot pri nizih! Metoda `append` ne vrača novega seznama, temveč v resnici spreminja seznam.\n",
    "\n",
    "Kako pa bi k nizu pripeli seznam? Tule nam `append` ne bo pomagal: kar naredi, je povsem narobe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani', 'Ema']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "imena.append([\"Fanči\", \"Ema\", \"Greta\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj smo pa pričakovali? Metoda `append` prejme en argument. In to kar prejme, doda k seznamu. Torej: kar\n",
    "ji podamo kot argument, bo zadnji element seznama. Če torej `append`-u podamo seznam, bo seznam zadnji element seznama.\n",
    "\n",
    "Metoda, ki bo naredila, kar hočemo, je `extend`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanči', 'Greta']"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena = ['Ana', 'Berta', 'Cilka', 'Dani', 'Ema']\n",
    "imena.extend([\"Fanči\", \"Greta\"])\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V resnici `extend`-a praktično ne potrebujemo. Ker je sezname možno seštevati, raje uporabimo kar `+=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanči', 'Greta', 'Helga', 'Iva']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena += [\"Helga\", \"Iva\"]\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metodi `insert` podamo dva argumenta, indeks in element, pa bo vstavila element *pred* element s podanim indeksom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Fanči', 'Greta']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena = ['Ana', 'Berta', 'Dani', 'Ema', 'Greta']\n",
    "imena.insert(2, \"Cilka\")\n",
    "imena.insert(-1, \"Fanči\")\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Očitno deluje tudi indeksiranje s konca.\n",
    "\n",
    "Elemente seznama lahko odstranjujemo na tri načine.\n",
    "\n",
    "Prvi je `del`. `del` ni metoda in prihaja iz povsem drugega vica, a vseeno ga pač omenimo, ker se ravno učimo o spreminjanju seznamov. Uporabimo ga tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani', 'Ema', 'Greta']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del imena[-2]\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda `pop` vrne element s podanim indeksom in ga pobriše s seznama."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cilka'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena.pop(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Dani', 'Ema', 'Greta']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metodo `pop` redko uporabljamo za pobiranje elementov sredi seznamov. Navadno na ta način poberemo prvi ali zadnji element. Pravzaprav najpogosteje zadnjega, zato lahko `pop` pokličemo tudi brez argumentov, pa bomo dobili zadnji element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Greta'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Dani', 'Ema']"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če bi hoteli, recimo, prestaviti prvi element na konec, bi napisali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Berta', 'Dani', 'Ema', 'Ana']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena.append(imena.pop(0))\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V obeh primeri, pri `del` in `pop` smo morali podati indeks elementa, ki ga želimo odstarniti. Včasih nimamo indeksa, pač pa poznamo vrednost elementa, ki ga želimo odstraniti. V tem primeru uporabimo `remove`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Berta', 'Ema', 'Ana']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena.remove(\"Dani\")\n",
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pri tem ne odstrani vseh takšnih elementov, temveč le prvega, na katerega naleti, kakor lahko vidimo v spodnjem primeru."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 3, 4, 1, 1, 2]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = [7, 1, 2, 3, 4, 1, 1, 2]\n",
    "s.remove(1)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za metodo `remove` velja vse, kar smo napisali za `index`. V resnici za `remove` sicer obstaja več situacij, ko ga \"legalno uporabimo\", vseeno pa je nevaren, ker odstrani prvi takšen element; počasen, ker mora element najprej poiskati; pogosto nepotreben (ker lahko poznamo indeks). Poleg tega pa je še zelo nevaren: študenti ga radi uporabijo znotraj zanke, v kateri gredo čez prav ta isti seznam. Brisati elemente seznama, čez katerega greš ravnokar z zanko, je vedno zelo slaba ideja. Če uporabljaš `for` ali če nisi pošteno previden.\n",
    "\n",
    "Metoda `s.copy()` naredi kopijo seznama `s`, tako kot da bi napisali `s = s[:]`. Navadno uporabimo `s.copy()`, ker bolj eksplicitno pove, kaj počnemo.\n",
    "\n",
    "Metoda `s.clear()` ga izprazni, kar je isto kot `s[:] = []` ali `del s[:]` in *ni isto kot* `s = []`. Razlika je tako prefinjena, da bo vredna posebnega predavanja. Navadno uporabimo `s.clear()`.\n",
    "\n",
    "Le še dve metodi sta nam ostali. `reverse` obrne vrstni red elementov v seznamu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 5, 2, 7]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = [7, 2, 5, 1, 1]\n",
    "s.reverse()\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zadnja je `sort`, ki uredi elemente po vrsti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 5, 7]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.sort()\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda deluje nad vsakršnimi elementi, ki jih je mogoče primerjati - z njo lahko uredimo seznam števil, nizov... Podamo ji lahko tudi kup argumentov, ki pa jih v tem trenutku še nismo zmožni razumeti.\n",
    "\n",
    "Ne spreglejte razlike med metodami nizov in seznamov. Metode nizov vračajo nove nize; `s.replace(\"min\", \"max\")` ni spremenil niza `s`, temveč vrnil nov niz. Metode seznamov spreminjajo seznam; `s.insert(2, \"Ana\")` ne vrne novega seznama, temveč spremeni `s`. Enako velja za `sort` in `reverse`.\n",
    "\n",
    "Tule omenimo še dve Pythonovi funkciji, ki nista metodi, sta pa podobni gornjima in študente pogosto bega razlika."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "5\n",
      "2\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "s = [7, 2, 5, 1, 1]\n",
    "for e in reversed(s):\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 5, 1, 1]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 5, 7]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 5, 1, 1]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sort` in `reverse` sta metodi seznamov. Imeni sta v velelniku - uredi!, obrni! - torej uredita oz. obrneta seznam. Torej: spremenita ga.\n",
    "\n",
    "`sorted` in `reversed` sta funkciji. Imeni sta urejen in obrnjen, vrneta torej nov seznam (`reversed` v resnici ne vrača seznama, vrne pa nekaj, kar se vede malo podobno kot seznam). Seznam, ki ga podamo kot argument, ostane nespremenjen. Obe funkciji skoraj vedno uporabimo za zanko `for`.\n",
    "\n",
    "Eden od razlogov, zakaj `sorted` in `reversed` nista metodi, je tudi, da lahko na ta način sprejemata različne argumente. Zadovoljni sta tudi z nizom ali terko (in vsem drugim, čez kar je možno iti z zanko `for`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'e', 'r', 't']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(\"berta\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "t\n",
      "r\n",
      "e\n",
      "b\n"
     ]
    }
   ],
   "source": [
    "for e in reversed(\"berta\"):\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metode terk\n",
    "-----------\n",
    "\n",
    "Terke imajo enake metode kot seznami, manjkajo jim le metode, ki spreminjajo seznam.\n",
    "\n",
    "In, presenečenje: vse metode seznamov spreminjajo seznam. Terke imajo le metodi: `count` in `index`."
   ]
  }
 ],
 "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
}