06 Metode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metode\n",
    "\n",
    "Najprej smo delali s številkami. Številke se preproste živali - lahko jih odštevaš, seštevaš, množiš in deliš, tu pa se približno konča. V Pythonu imamo, kot v večini jezikov, dve vrsti števil (če pozabimo na vse ostale, ki so malo bolj skrite ali malo manj uporab(lja)ne), namreč cela in necela števila. Nato smo spoznali nize, se pravi, zaporedja znakov. Ta so še bolj preprosta (kmalu bomo sicer videli, da videz vara), saj jih lahko samo seštevamo. Naslednji podatkovni tip, na katerega smo naleteli, so bile logične vrednosti, `True` in `False`. Teh ne moremo seštevati in množiti (res ne? ste prepričani? ste poskusili?), tipične operacije na njih so `and`, `or` in `not`.\n",
    "\n",
    "V zadnjem poglavju pa smo naleteli na čisto drugačen podatkovni tip: datoteka. Ta je nenavaden, ker ... pač ne zveni kot podatek. Ni številka ali kos besedila. Malo abstraktnejši je. (Takšnim rečem pravimo *objekti*. Ime ni preveč pomembno. In tudi številke so objekti. Le da me boste v zvezi z nekaterimi rečmi slišali uporabljati to ime, v zvezi s številkami pa ne.)\n",
    "\n",
    "Datotek ne moremo seštevati in množiti, ne moremo jih primerjati po velikosti, ne moremo jih izpisati (lahko pa preberemo in izpišemo njihovo vsebino, seveda). Splošne funkcije, ki smo jih videli doslej, recimo, `print`, `abs`, `pow`, `int` in `str`, zanje niso uporabne; nekatere med njimi (`abs`) sploh ne sprejmejo datoteke kot argument, druge pa ne vrnejo ničesar pametnega (`print` izpiše tisti `TextWrapper`...). Pač pa imajo datoteke svoje specifične funkcije. Videli smo tri: `write`, `read` in `close`. Imajo jih še precej. Ker pa so te funkcije specifične za datoteke (skoraj nobena druga reč v Pythonu nima funkcije `close`), ne plavajo kar tako na prostem, temveč so vezane na datoteko.\n",
    "\n",
    "Kako to izgleda sintaktično, smo videli. Namesto, da bi napisali `write(dat, \"Prva vrstica\\n\")`, smo pisali `dat.write(\"Prva vrstica\\n\").`. Funkcija `write` je \"znotraj\" datoteke, del definicije tega, kar zna datoteka. Zato pisanje s piko; pika bo tudi v drugih kontekstih v Python pomenila nekaj, kar je znotraj nečesa.\n",
    "\n",
    "Funkcija `write` torej ne obstaja, pač pa obstaja `dat.write` - funkcija `write`, ki je funkcija prav te specifične datoteke `dat`. Takšnim funkcijam navadno ne rečemo *funkcija* temveč *metoda*. To spet ni preveč pomembno (razlika je bolj zgodovinska, v modernih jezikih pa je praktično ni več) in je potrebno povedati le zato, ker boste to besedo pogosto slišali.\n",
    "\n",
    "Datoteke seveda niso edine reči, ki imajo metode. V resnici jih imajo celo števila, a tiste za nas niso posebej zanimive in uporabne. Pač pa so zanimive in uporabne metode, ki jih imajo nizi.\n",
    "\n",
    "Python v resnici nima veliko funkcij - golih funkcij, ki same plavajo naokrog. Vse, kar je uporabnega, se skriva v metodah. Z nizi, recimo, bomo morali početi marsikaj: včasih bomo želeli odkriti, na katerem mestu v nizu se pojavi določeno podzaporedje znakov (beseda, ali pa nek kodon, če vas zanimajo take reči). Ali pa bomo prešteli število pojavitev kodona. Razbili niz na seznam podnizov glede na določeno ločilo. Zamenjali del niza z drugim; morda vse pojavitve \"AGA\" z \"AGG\"... Za vse te reči obstajajo metode."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Primer: metoda `split()`\n",
    "\n",
    "Datoteka `osebe.txt` vsebuje tole:\n",
    "\n",
    "```\n",
    "Ana 72 1.70\n",
    "Berta 85 1.84\n",
    "Cilka 70 1.65\n",
    "Dani 82 1.80\n",
    "Eva 50 1.50\n",
    "Fanči 64 1.65\n",
    "```\n",
    "\n",
    "Izpisati želimo imena oseb in indekse njihovih telesnih tež.\n",
    "\n",
    "Za začetek se spomnimo le, kako lepo, po vrsticah prebrati datoteko."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana 72 1.70\n",
      "\n",
      "Berta 85 1.84\n",
      "\n",
      "Cilka 70 1.65\n",
      "\n",
      "Dani 82 1.80\n",
      "\n",
      "Eva 50 1.50\n",
      "\n",
      "Fanči 64 1.65\n"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"datoteke/osebe.txt\"):\n",
    "    print(vrstica)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zanka `for` bere datoteko, vrstico za vrstico, in vsebino vsake vrstice priredi spremenljivki `vrstica`. Kakšnega tipa je vrstica? Niz, seveda.\n",
    "\n",
    "V gornjem programu jo izpišemo. V resnici pa jo moramo razdeliti na tri reči, ime, težo in višino. To ne bo težko, saj imajo nizi metodo `split`. Uporabimo jo lahko takole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana\n",
      "Berta\n",
      "Cilka\n",
      "Dani\n",
      "Eva\n",
      "Fanči\n"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"datoteke/osebe.txt\"):\n",
    "    ime, teza, visina = vrstica.split()\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ker je vrstica sestavljena točno iz treh besed, bo `split` vrnila tri stvari, ki jih spravimo v tri spremenljivke. Če se število reči in spremenljivk ne ujema, Python javi napako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "not enough values to unpack (expected 4, got 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-09e0904b6635>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mvrstica\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"datoteke/osebe.txt\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mime\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mteza\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvisina\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnekaj_cesar_ni\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvrstica\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 4, got 3)"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"datoteke/osebe.txt\"):\n",
    "    ime, teza, visina, nekaj_cesar_ni = vrstica.split()\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj v resnici vrne `split` in kako ga uporabljati varneje, bomo še izvedeli (ali pa boste odkrili sami, če nam zmanjka časa :)).\n",
    "\n",
    "Spremenljivka `ime` je, očitno, niz. Kaj pa `teza` in `visina`? Tudi. Sicer so res videti kot številke - a Python ne ugiba. Če hočemo števila, moramo pretvarjati. Ročno. Pa dajmo: kar sproti, znotraj računanja `bmi`, bomo poklicali `int(teza)` in `float(visina)`. Teža naj bo celo število (lahko bi bila tudi necelo, saj je vseeno), višina pa bo necelo (to pa je pomembno - zakaj?)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana 24.913494809688583\n",
      "Berta 25.10633270321361\n",
      "Cilka 25.71166207529844\n",
      "Dani 25.30864197530864\n",
      "Eva 22.22222222222222\n",
      "Fanči 23.507805325987146\n"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"datoteke/osebe.txt\"):\n",
    "    ime, teza, visina = vrstica.split()\n",
    "    bmi = int(teza) / float(visina) ** 2\n",
    "    print(ime, bmi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tole je stranska tema, v katero se ne bomo spuščali: izpis je grd. Le na hitro nakažimo, kaj se da storiti. Najprej pred narekovaj, ki začenja niz, postavimo `f`, znotraj niza pa v zavitih oklepajih povemo, kaj naj se izpiše."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana: 24.913494809688583\n",
      "Berta: 25.10633270321361\n",
      "Cilka: 25.71166207529844\n",
      "Dani: 25.30864197530864\n",
      "Eva: 22.22222222222222\n",
      "Fanči: 23.507805325987146\n"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"datoteke/osebe.txt\"):\n",
    "    ime, teza, visina = vrstica.split()\n",
    "    bmi = int(teza) / float(visina) ** 2\n",
    "    print(f\"{ime}: {bmi}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nato poleg tega, kaj naj se izpiše, navedimo, *kako* naj se izpiše. `{ime}` spremenimo v `{ime:>15}`, kar pomeni, naj se `ime` izpiše na 15 znakov, poravnano na desno. `{bmi}` pa spremenimo v `{bmi:.3f}`, kar pomeni na tri decimalna mesta in kot običajno število (`f`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Ana: 24.913\n",
      "          Berta: 25.106\n",
      "          Cilka: 25.712\n",
      "           Dani: 25.309\n",
      "            Eva: 22.222\n",
      "          Fanči: 23.508\n"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"datoteke/osebe.txt\"):\n",
    "    ime, teza, visina = vrstica.split()\n",
    "    bmi = int(teza) / float(visina) ** 2\n",
    "    print(f\"{ime:>15}: {bmi:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ker je to, kot rečeno, tema, v katero se ne bomo spuščali, naj si ta, ki ga to zanima, sam prebere [dokumentacijo](https://docs.python.org/3/library/string.html#formatspec). Ta se žal nanaša na starejšo metodo `format` in ne na f-nize. A se boste že znašli - samo na `format` pozabite, in `f` dodajte, ostalo je isto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ob metodi `split` povejmo še, da ji lahko damo tudi argument: ločilo. V gornjem primeru bi imeli očitno probleme pri\n",
    "\n",
    "```\n",
    "Marija Terezija 90 1.70\n",
    "```\n",
    "\n",
    "saj bi `split` razbil vrstico na štiri besede, ker se je zdelo Marijini mami dobra fora, da je dala svoji hčeri dve imeni. Datoteko bi bilo zato varneje pisati tako, da bi bili podatki ločeni z vejico.\n",
    "\n",
    "```\n",
    "Ana, 72, 1.70\n",
    "Berta, 85, 1.84\n",
    "Cilka, 70, 1.65\n",
    "Marija Terezija, 90, 1.70\n",
    "```\n",
    "\n",
    "V tem primeru namesto `split()` pokličemo `split(\",\")`, pa loči po vejici namesto po presledkih.\n",
    "\n",
    "Datoteke so pogosto zapisane tako, da so stolpci ločeni s tabulatorjem (*tab-delimited*). V tem primeru pokličemo `split(\"\\t\")`. Posebni znak `\\t` je podoben posebnemu znaku `\\n` - tako kot `\\n` pomeni konec vrstice, `\\t` pomeni tabulator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Primer: Metoda count()\n",
    "\n",
    "Datoteka `qwerty-dna.txt` vsebuje sekvence desetih genov avstralskega Qwertyja. Vsaka vrstica se začne z imenom gena, sledi pa sto baznih parov. (Toliko so namreč dolgi njegovi geni. Čudna žival pač.)\n",
    "\n",
    "```\n",
    "ASDF13 gcaactgttggacggctacagtgacggttggtagaactgagtcggtttaaggactcacacatcgcgggtctgcaaagtgtaatctacaagggagcccgag\n",
    "SDFG14 cgaagggcaatcggaagttgaggttcgtcatattaagtttggggaacgccgacatctaaatcttttaggtgataaatgcctaaatcagattcaatgtatt\n",
    "DFGH15 cgacctcgtaaaatgacaaacactgtcgtggagcagtattcggtcatgccgcccgagccctaccaatcgagttcaactatcgctaactcgcgatgagcct\n",
    "FGHJ16 tcgcgggtagcccacagccgggcctgattacagaggggtgaattcgatgcttgatgcggattcctggtaagctccgccgtgcgaccgacaactctcgact\n",
    "GHJK17 tggtgatgtggtacatctttgaaaggctcaccgtgaacaaaagtgtattacaatcaacgagccccagggactgatccctcaacaagggcacccaagaagt\n",
    "HJKL18 tacagacactatcgctcccgtagctggaggatttcacatgatctaagcaaagccgtagtgggagttcctatggcaataagcgaccttctataaccgagag\n",
    "ZXCV19 tcatgcatgttaggttacatctaggctatgcctgtcccagtcagcaggtgggcctagattaagaaatgcccggttaggcaacacaacaccggtgtccttt\n",
    "XCVB20 cgctacgtatgtccctaatcaagggctcatggtgctagccagggtcggggctagtttttaaggtatttctgcccccaacaaggagccagataggcccctt\n",
    "CVBN21 acttggccactttactcctgcaatctttagtcctggggggagtttaaaatcattccagctgggatgggtctctatcctctccctgtaataacaacaaacg\n",
    "VBNM22 tggtctttaagattaactgctcattaggatctgtctccaaacactgttaccgccggcaatcacaggagaatcagtcacctaagttgcgtaggccatatcc\n",
    "```\n",
    "\n",
    "Izpisati želimo, koliko `a`-jev je v sekvenci vsakega gena.\n",
    "\n",
    "Pomagali si bomo z metodo `count`, ki ji kot argument podamo (pod)niz in vrne število ponovitev tega podniza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ASDF13 26\n",
      "SDFG14 31\n",
      "DFGH15 26\n",
      "FGHJ16 19\n",
      "GHJK17 32\n",
      "HJKL18 29\n",
      "ZXCV19 24\n",
      "XCVB20 21\n",
      "CVBN21 24\n",
      "VBNM22 27\n"
     ]
    }
   ],
   "source": [
    "for vrstica in open(\"datoteke/qwerty-dna.txt\"):\n",
    "    ime, zaporedje = vrstica.split()\n",
    "    print(ime, zaporedje.count(\"a\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To je to. :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nizi imajo še kup drugih metod. Ker seveda nimamo časa, da bi si jih ogledali vse po vrsti, lahko poškilite v [dokumentacijo](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str), ali pa v [zapiske predmeta Programiranje 1](https://ucilnica.fri.uni-lj.si/mod/page/view.php?id=7693)."
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}