pn/predavanja/03b Metode nizov.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bface6c6",
   "metadata": {},
   "source": [
    "## Težave z nizi\n",
    "\n",
    "Po tem, ko smo se poučili o tem, kako so shranjeni nizi in kaj vse se še vsebujejo poleg vidnih znakov, se vrnimo k vremenu v Radovljici, podatkom z dražbe in izboru koles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0b0d3ef9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "\n",
      "18\n",
      "\n",
      "15\n",
      "\n",
      "16\n",
      "\n",
      "18\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"temperature.txt\"):\n",
    "    print(vrstica)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de337a5",
   "metadata": {},
   "source": [
    "Vidimo prazne vrstice? Ki jih ne bi bilo, če bi izpisovali številke, ne nizov?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fcd8993d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "18\n",
      "15\n",
      "16\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"temperature.txt\"):\n",
    "    temp_c = int(vrstica)\n",
    "    print(temp_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b720c6cc",
   "metadata": {},
   "source": [
    "To se zgodi, ker vsaka vrstica, prebrana iz datoteke, vsebuje tudi znak za konec vrstice. Tako je, recimo, videti zadnja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c03df68b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'18\\n'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "059f0a69",
   "metadata": {},
   "source": [
    "To nas potem pesti pri nalogi z vaj, kjer je potrebno prešteti, kolikokrat se je nek lastnik štirih koles peljal s katerim izmed njih, recimo Cubom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6c0d7f60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube = 0\n",
    "for vrstica in open(\"../vaje/kolesa.txt\"):\n",
    "    if vrstica == \"Cube\":\n",
    "        cube += 1\n",
    "\n",
    "cube"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75fd0431",
   "metadata": {},
   "source": [
    "Že če pogledamo zadnjo vrstico, vidimo, da se je vozil tudi s Cubom, vendar ima vrstica na koncu, seveda, `\\n`, zato primerjava `vrstica == \"Cube\"` vrne `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4f007bbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cube\\n'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7b5cc917",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica == \"Cube\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d7c590d",
   "metadata": {},
   "source": [
    "Seveda lahko pišemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e248bee7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube = 0\n",
    "for vrstica in open(\"../vaje/kolesa.txt\"):\n",
    "    if vrstica == \"Cube\\n\":\n",
    "        cube += 1\n",
    "\n",
    "cube"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ce2f20",
   "metadata": {},
   "source": [
    "in dobimo pravi rezultat, vendar nam gre (no, vsaj meni) to na živce. Menda ne obstaja kak način, da se znebimo tega trapastega `\\n`?\n",
    "\n",
    "Še hujše: kaj, če je pri zapisovanju nekonsistenten in včasih piše \"Cube\", včasih \"cube\" in včasih \"CUBE\"? Obstaja kakšna oblika primerjanja, ki ignorira razliko med velikimi in malimi črkami?\n",
    "\n",
    "Aja, pa, zdi se mi, da še nisem omenil: njegova tipkovnica je nekaj pokvarjena in včasih dela dvojne n-je, tako da se v njegovi datoteki včasih pojavi tudi Stevenns, NNakamura in Cannyon (in Canyonn). Je mogoče na kak preprost način zamenjati vse dvojne n-je v nizu z enojnimi?\n",
    "\n",
    "Kam gremo? V funkcije za delo z nizi. Pravzaprav v nekaj splošnejšega.\n",
    "\n",
    "## Metode nizov\n",
    "\n",
    "Doslej smo spoznali le prgišče Pythonovih funkcij - le toliko, da smo se jih naučili klicati in da smo lahko kaj drobnega sprogramirali.\n",
    "- Vemo za `print` in `input`. Tidve sta splošno uporabni funkciji, predvsem prva. (Druga bo hitro potonila iz spomina, ker v resnici ni tako zelo uporabna.) Podobno `open`.\n",
    "- Vemo za nekaj funkcij za delo s števili, kot so `sqrt`, `sin` in `log`. Te so v resnici pospravljene v škatlici z imenom `math` in da smo jih lahko uporabili, smo jih morali pričarati s `from math import *`.\n",
    "- Vemo za `int` in `float`. To v resnici nista funkciji, temveč tipa. Vendar so vsi tipi v Pythonu tudi na nek način funkcije. Kakorkoli, `int` in `float` ste očitno zelo splošni zadevi.\n",
    "\n",
    "Python 3.12 ima v resnici samo [71 funkcij](https://docs.python.org/3/library/functions.html) (med katerimi je kakšnih 20 tipov). Še več, izmed teh 71 funkcij sem tako, na hitro, naštel 20 funkcij, ki jih dejansko kolikor toliko redno uporabljam. Ostale so bolj kot ne eksotika. Ostale, uporabne funkcije - in Python jih ima na tisoče - so pospravljene po škatlicah.\n",
    "\n",
    "Kakšnih škatlicah? Takole. Vzemimo nek niz, recimo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "891244db",
   "metadata": {},
   "outputs": [],
   "source": [
    "vrstica = \"NNakamura\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bedc16f",
   "metadata": {},
   "source": [
    "Tako kot številke smo tudi nize na tablo narisali kot škatlice, ki vsebujejo nek podatek. Poleg tega vsebujejo te škatlice tudi funkcije za delo s tem podatkom. Kot smo omenili v vaji \"Kolesa\" se lahko odvečnega `\\n` na koncu niza znebimo tako, da napišemo `vrstica = vrstica.strip()`. Ta `strip` je funkcija, ki se nahaja \"znotraj\" niza `vrstica`. In do tistega, kar je \"znotraj\", pridemo tako, da napišemo `vrstica`, nato piko (ki v vseh kontekstih v Pythonu - še nekaj jih bo - pomeni \"znotraj\") in potem ime tistega, kar je \"znotraj\", torej `strip`. Ker je to funkcija, jo pokličemo. In ker zanjo (zdajle) nimamo posebnih argumentov, pustimo oklepaja prazna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "98580c61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NNakamura\\n'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "51255fdf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NNakamura'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2673ad38",
   "metadata": {},
   "source": [
    "Takšnim funkcijam znotraj škatlic rečemo metode, po angleško *method*. (Ime je, priznajmo, malo čudno. Zgodovinsko. Vseeno boljše od tega, kako so jih klicali v začetku: sporočilo, *message*. V kontekstu takratnega razmišljanja, opisovanja tega, kar se dogaja ob klicanju metod, je bilo to ime smiselno, danes pa niti med programerji ni veliko takšnih, ki bi vedeli za ta izraz.)\n",
    "\n",
    "### `strip`\n",
    "\n",
    "`strip` je torej metoda nizov. Vsi nizi imajo `strip` (vsak svojega, drugega? kakor se vzame.) in njeno delo je, da vrne niz brez belega prostora na začetku in na koncu. Beli prostor so presledki, znak za novo vrstico in tabulatorji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f80e5489",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'niz s   preveč presledki. \\n  Res.'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"    niz s   preveč presledki. \\n  Res.   \\n\\n  \"\n",
    "\n",
    "s.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45193556",
   "metadata": {},
   "source": [
    "Vidimo: odstranil je vse presledke in nove vrstice na začetku in na koncu, tiste vmes pa je pustil pri miru.\n",
    "\n",
    "Obstajata različici `lstrip` in `rstrip`, ki odstranita le presledke na začetku in na koncu. Kateri je kateri, si boste že zapomnili, saj znate angleško.\n",
    "\n",
    "Metodi `strip` lahko podamo tudi argument, če želimo odstranjevati kaj drugega kot presledke. To bomo počeli redko, a vseeno pokažimo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "beb0afba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'čemu služijo te pike?!'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\".....čemu služijo te pike?!...\".strip(\".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83896e6e",
   "metadata": {},
   "source": [
    "Mimogrede smo videli, da lahko metode kličemo tudi na *literalih* za nize (\"dobesedno\" navedenem nizu) ne le na nizih, ki so že poimenovani, kot je bil gornji `s`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c802ff0c",
   "metadata": {},
   "source": [
    "Tako se bomo torej znebili `\\n` na koncu vrstice s kolesom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "62ad99b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NNakamura'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ee81b45",
   "metadata": {},
   "source": [
    "**Nobena metoda niza ne spreminja niza, temveč kvečjemu vrne nov niz.** Nizi so nespremenljivi. Niz, na katerega se nanaša `vrstica`, je še vedno tak, kot je bil."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "eefaa145",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NNakamura\\n'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30925488",
   "metadata": {},
   "source": [
    "Metoda `strip` je zgolj vrnila nov niz in če hočemo, da niz, na katerega se nanaša vrstica, ne bo več vseboval `\\n`, moramo imenu `vrstica` prirediti vrednost, ki jo vrne `vrstica.strip()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2c79aab1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NNakamura'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica = vrstica.strip()\n",
    "\n",
    "vrstica"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb6d4067",
   "metadata": {},
   "source": [
    "## Velike in male črke\n",
    "\n",
    "Naš naslednji kamen spotike je bilo primerjanje, pri katerem zanemarjamo razliko med malimi in velikimi črkami. Takšno torej, po katerem so nizi `\"canyon\"`, `\"Canyon\"` in `\"CANYON\"` enaki.\n",
    "\n",
    "Priznati moram, da funkcije, namenjene takšnemu primerjanju, nisem še nikoli uporabil, sem pa slutil, kje jo najti in jo tam ob zapisovanju teh zapiskov tudi hitro našel. Za tiste, ki bi jo utegnili potrebovati: imenuje se `locale.strcoll`. Kako, da tak postaran programer, kot sem jaz, ne ve zanjo? Preprosto: ta problem rešim po preprostejši bližnjici. `locale.strcoll` bi moral uporabiti le za urejanje nizov po abecedi, za ugotavljanje enakosti pa oba niza preprosto pretvorim v male (ali velike) črke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1cdcf8bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nnakamura'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8a2fdc9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'NNAKAMURA'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49b704c5",
   "metadata": {},
   "source": [
    "Ali celo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "457e3430",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Nnakamura'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a8c384c",
   "metadata": {},
   "source": [
    "Spet: nobena od teh funkcij ne spreminja niza, vse zgolj vrnejo nov niz. Če hočem, da bo vrstica vsebovala niz, zapisan s samimi malimi črkami, potrebujem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "0ace00fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "vrstica = vrstica.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0880be7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nnakamura'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dc46483",
   "metadata": {},
   "source": [
    "Zavoljo popolnosti povejmo še za eno metodo: `casefold`. Ta je podobna `lower`, vendar naredi še nekateri druge pretvorbe, recimo zamenja *ß* z *ss*, saj je \"Straße\" za tiste, ki znajo nemško, isto kot \"strasse\". Poleg tega, recimo, poskrbi, da so vsi šumniki zapisani na enak način (zapisati jih je mogoče z enim znakom ali kot kombinacijo c/s/z s strešico)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "e049ba7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'strasse'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Straße\".casefold()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa95442e",
   "metadata": {},
   "source": [
    "## Zamenjava podnizov"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "706f44c1",
   "metadata": {},
   "source": [
    "Tudi metoda `replace` ima nerodno ime, saj ne spreminja niza, temveč vrne niz, v katerem je nek znak ali podniz zamenjan z drugim."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "149e161d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nnekemure'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.replace(\"a\", \"e\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1b36bc09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nnakamjavra'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.replace(\"mu\", \"mjav\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ed33169a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nnakura'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.replace(\"am\", \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abd7f0dd",
   "metadata": {},
   "source": [
    "Kar potrebujemo mi, je zamenjava dveh nn-jev z enim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d8f3d96d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nakamura'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.replace(\"nn\", \"n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71640172",
   "metadata": {},
   "source": [
    "To dela tudi za Canyona:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e0ba7313",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'canyon'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"cannyon\".replace(\"nn\", \"n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7569f0e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'canyon'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"canyonn\".replace(\"nn\", \"n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "3cfafa98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'canyon'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"cannyonn\".replace(\"nn\", \"n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ab6c627",
   "metadata": {},
   "source": [
    "## Vse skupaj\n",
    "\n",
    "Ker vsaka od teh metod vrne nov niz, jih lahko \"verižimo\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "57da8957",
   "metadata": {},
   "outputs": [],
   "source": [
    "vrstica = \"NNakamura\\n\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "6511b5a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nakamura'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.strip().lower().replace(\"nn\", \"n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "257c48b9",
   "metadata": {},
   "source": [
    "In zdaj lahko končno preštejemo te bicikle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "7d83e97f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cube: 46\n",
      "Stevens: 1\n",
      "Nakamura: 23\n",
      "Canyon: 30\n"
     ]
    }
   ],
   "source": [
    "cube = stevens = nakamura = canyon = 0\n",
    "for vrstica in open(\"../vaje/kolesa.txt\"):\n",
    "    vrstica = vrstica.strip().lower().replace(\"nn\", \"n\")\n",
    "    if vrstica == \"cube\":\n",
    "        cube += 1\n",
    "    if vrstica == \"stevens\":\n",
    "        stevens += 1\n",
    "    if vrstica == \"nakamura\":\n",
    "        nakamura += 1\n",
    "    if vrstica == \"canyon\":\n",
    "        canyon += 1\n",
    "\n",
    "print(\"Cube:\", cube)\n",
    "print(\"Stevens:\", stevens)\n",
    "print(\"Nakamura:\", nakamura)\n",
    "print(\"Canyon:\", canyon)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d67db29",
   "metadata": {},
   "source": [
    "## Začetek in konec\n",
    "\n",
    "Nizi imajo še par ducatov metod, vendar večine bodisi še ne moremo razumeti, bodisi niso prav splošno uporabne. Tu bomo navrgli le še dve, potem pa posvetili daljši razdelek zvezdi današnjega predavanja, metodi `split`.\n",
    "\n",
    "Preprosti, a pogosto uporabni metodi sta `startswith` in `endswith`. Podamo jima niz in vrneta `True` ali `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "4ceeade8",
   "metadata": {},
   "outputs": [],
   "source": [
    "ime = \"Benjamin\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "bb432af0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ime.startswith(\"Ben\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "9986478d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ime.startswith(\"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "9ec141e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ime.startswith(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "778b43e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ime.startswith(\"tisto zgoraj je malo hecno\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "d1e91445",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ime.endswith(\"min\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "199d3d1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ime.endswith(\"max\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a4037c6",
   "metadata": {},
   "source": [
    "Obe metodi bomo - kot vse, ki vračajo `False` ali `True` - seveda najpogosteje uporabljali v pogojih v `if` (in `while`, ko ga bomo poznali)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f22b2e9b",
   "metadata": {},
   "source": [
    "# Razbijanje niza\n",
    "\n",
    "Hja. V resnici je v direktoriju *vaje* samo precej poenostavljena različica datoteke s kolesarsko statistiko. V resnici je videti tako:\n",
    "\n",
    "```\n",
    "Cube,51,1216\n",
    "Canyon,104,444\n",
    "Cube,74,1508\n",
    "Cube,79,936\n",
    "Nakamura,17,95\n",
    "(in tako naprej)\n",
    "```\n",
    "\n",
    "V vsaki vrstici so trije podatki, ločeni z vejicami: najprej ime kolesa, ki ga je imel neznani kolesar nek dan za izlet, nato prevožena razdalja in potem višinski metri. Kako prebrati to?\n",
    "\n",
    "Za začetek vzemimo le eno vrstico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "1bb4ff85",
   "metadata": {},
   "outputs": [],
   "source": [
    "vrstica = \"Cube,51,1216\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64846bc3",
   "metadata": {},
   "source": [
    "Doslej zamolčana metoda nizov je `split`. Ta razbije nize na več nizov; kot argument ji podamo ločilo - v našem primeru vejico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "d1408f0f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Cube', '51', '1216']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica.split(\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ccee402",
   "metadata": {},
   "source": [
    "Metoda je vrnila tri nize. Kaj pomenijo tisti oglati oklepaji, ni današnja tema. Motili nas ne bodo. Ker imamo tri nize, jih bomo priredili trem spremenljivkam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "16fc75b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "kolo, razdalja, visina = vrstica.split(\",\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b13b8b2",
   "metadata": {},
   "source": [
    "Razumemo? Desno od enačaja imamo tri stvari, torej levo od njega potrebujemo tri spremenljivke.\n",
    "\n",
    "Njihove vrednosti so, kot morajo biti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "3a40beda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cube'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kolo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "8cdde0ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'51'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "razdalja"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "716873f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1216'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "visina"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2072452c",
   "metadata": {},
   "source": [
    "Pa ugotovimo, kako daleč se je možakar peljal in kakšna je skupna višina njegovih izletov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "198a00ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Skupna razdalja: 6359\n",
      "Skupna višina: 98076\n"
     ]
    }
   ],
   "source": [
    "skupna_razdalja = 0\n",
    "skupna_visina = 0\n",
    "for vrstica in open(\"kolesa.txt\"):\n",
    "    kolo, razdalja, visina = vrstica.split(\",\")\n",
    "    skupna_razdalja += int(razdalja)\n",
    "    skupna_visina += int(visina)\n",
    "    \n",
    "print(\"Skupna razdalja:\", skupna_razdalja)\n",
    "print(\"Skupna višina:\", skupna_visina)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b96e2fb",
   "metadata": {},
   "source": [
    "Meni se zdi to kar imenitno. Kar zapletene datoteke znamo že brati."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e740b005",
   "metadata": {},
   "source": [
    "V zvezi s `split` je potrebno povedati še nekaj. Datoteke s podatki, ločene z vejicami, pogosto dobimo iz kakega Excela. Včasih pa so podatki ločeni s tabulatorji ali celo le s presledki - se pravi, belim prostorom. V tem primeru pokličemo `split` brez argumentov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "a4e098a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Cube', '45', '1024']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Cube 45 1024\".split()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d8cf286",
   "metadata": {},
   "source": [
    "To je podobno, vendar ne popolnoma isto, kot če kot argument podamo presledek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "5972efc6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Cube', '45', '1024']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Cube 45 1024\".split(\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d91da9f7",
   "metadata": {},
   "source": [
    "Razlika je v tem, kako `split` obravnava zaporedne presledke v nizu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "7b695bbf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Cube', '45', '1024']"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Cube   45     1024\".split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "8d1b4ec6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Cube', '', '', '45', '', '', '', '', '1024']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Cube   45     1024\".split(\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef0b8ead",
   "metadata": {},
   "source": [
    "V prvem primeru upošteva zaporedne presledke kot en sam presledek, v drugem primeru, ko smo podali argument, pa je pet zaporednih presledkov obravnaval kot pet ločil - med njimi pa so bili prazni nizi. Tega navadno nočemo. Kadar vas torej zasrbi, da bi poklicali `split(\" \")`, se obrzdajte in pokličite `split()`."
   ]
  }
 ],
 "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": 5
}