07 Seznami.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seznami\n",
    "\n",
    "Lotimo se nečesa podjetnejšega: radi bi izpisali ime Qwertyjevega gena, ki vsebuje največ A-jev.\n",
    "\n",
    "No, za začetek pohlevnejši cilj: koliko A-jev ima gen, ki ima največ A-jev? (Če je vprašanje bolj zapleteno, to ne pomeni nujno, da je nanj težje odgovoriti. V tem primeru že ni tako.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "najvec = 0\n",
    "\n",
    "for vrstica in open(\"datoteke/qwerty-dna.txt\"):\n",
    "    ime, zaporedje = vrstica.split()\n",
    "    if zaporedje.count(\"a\") > najvec:\n",
    "        najvec = zaporedje.count(\"a\")\n",
    "        \n",
    "print(najvec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ideja programa je takšna: v spremenljivko `najvec` bomo shranili največje število a-jev, kar smo jih kdaj videli. V začetku je to `0`. Nato za vsako vrstico pogledamo, ali je število a-jev, ki jih vsebuje, večje od največjega doslej; če je, je največje pač to.\n",
    "\n",
    "Ker ni lepo, da računalnik silimo delati več, kot je treba (sploh, kadar to delo ne bo tako hitro in preprosto, kot je štetje a-jev v besedilu), popravimo program tako, da bo štel le enkrat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n"
     ]
    }
   ],
   "source": [
    "najvec = 0\n",
    "\n",
    "for vrstica in open(\"datoteke/qwerty-dna.txt\"):\n",
    "    ime, zaporedje = vrstica.split()\n",
    "    ajev = zaporedje.count(\"a\")\n",
    "    if ajev > najvec:\n",
    "        najvec = ajev\n",
    "        \n",
    "print(najvec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj pa k prvotni nalogi: izpisali bi radi ime gena, ne števila a-jev. Za to si bo potrebno poleg največjega števila genov (ki ga potrebujemo zato, da jih lahko primerjamo) pač zapomniti še ime gena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GHJK17\n"
     ]
    }
   ],
   "source": [
    "najvec = 0\n",
    "\n",
    "for vrstica in open(\"datoteke/qwerty-dna.txt\"):\n",
    "    ime, zaporedje = vrstica.split()\n",
    "    ajev = zaporedje.count(\"a\")\n",
    "    if ajev > najvec:\n",
    "        najvec = ajev\n",
    "        naj_gen = ime\n",
    "        \n",
    "print(naj_gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No, saj ni bilo tako težko.\n",
    "\n",
    "Zdaj pa si zapletimo življenje. Radi bi izpisali imena vseh genov, urejena po abecedi.\n",
    "\n",
    "Z datotekami bo to težko. Datoteke so okorne. Za urejanje potrebujemo nekaj fleksibilnejšega: sezname.\n",
    "\n",
    "Seznam je ... pač seznam. Seznam nekih stvari. Opišemo ga tako, da med oglatimi oklepaji naštejemo njegove elemente, ločene z vejicami, na primer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "imena = [\"Ana\", \"Berta\", \"Cilka\", \"Dani\"]\n",
    "teze = [72, 85, 70, 82]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prek seznamov lahko gremo kar z zanko `for`, čisto tako kot prek datoteke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ana\n",
      "Berta\n",
      "Cilka\n",
      "Dani\n"
     ]
    }
   ],
   "source": [
    "for ime in imena:\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seznam lahko izpišemo tudi s `print`: izpiše se z oglatimi oklepaji in vejicami. Ni estetsko, dela pa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ana', 'Berta', 'Cilka', 'Dani']\n",
      "[72, 85, 70, 82]\n"
     ]
    }
   ],
   "source": [
    "print(imena)\n",
    "print(teze)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če hočemo seznam vseh genov, bomo sestavili prazen seznam, šli s `for` prek datoteke in zlagali vsa imena v seznam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ASDF13', 'SDFG14', 'DFGH15', 'FGHJ16', 'GHJK17', 'HJKL18', 'ZXCV19', 'XCVB20', 'CVBN21', 'VBNM22']\n"
     ]
    }
   ],
   "source": [
    "geni = []\n",
    "for vrstica in open(\"datoteke/qwerty-dna.txt\"):\n",
    "    ime, zaporedje = vrstica.split()\n",
    "    geni.append(ime)\n",
    "print(geni)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj je `append`, najbrž lahko uganemo: metoda seznamov, ki na konec seznam dopiše nov element.\n",
    "\n",
    "Zaželeli smo si izpisati vse gene, urejene po abecedi, ne? Ni problema: seznam ima metodo `sort`, ki uredi njegove elemente. Primerja jih tako, kot je za tip elementa smiselno - številke po velikosti, nize po abecedi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ASDF13', 'CVBN21', 'DFGH15', 'FGHJ16', 'GHJK17', 'HJKL18', 'SDFG14', 'VBNM22', 'XCVB20', 'ZXCV19']\n"
     ]
    }
   ],
   "source": [
    "geni.sort()\n",
    "print(geni)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seznami imajo v resnici še goro metod. Kot smo zamolčali metode nizov, bomo tudi metode seznamov. Vsak pa naj preleti seznam, da bo vedel, kaj obstaja. Uradni seznam je v [Pythonovi dokumentaciji](https://docs.python.org/3/tutorial/datastructures.html), gostobesednejši opis pa je v [zapiskih predmeta Programiranje 1](https://ucilnica.fri.uni-lj.si/mod/page/view.php?id=7693)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indeksiranje\n",
    "\n",
    "Seznami so prikladnejši od datotek (tudi) zato, ker so shranjeni v pomnilniku in jih, za razliko od datotek (ki se vedejo, kot da bi bile shranjene na magnetnih trakovih, ki jih lahko vidimo na filmih iz šestdesetih), ne beremo le po vrsti po vrsticah, temveč lahko dostopamo do poljubnega elementa. Zaporedno številko elementa, ki nas zanima, zapišemo med oglate oklepaje. Tako, recimo `geni[2]` pomeni drugi element seznama `geni`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'DFGH15'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drugi? I, pač. Računalnikarji štejejo od 0, ne od 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ASDF13'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'CVBN21'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poleg tega znajo računalnikarji šteti tudi nazaj. Element -1 (zakaj ne -0? no, no, razmisli!) je zadnji element, -2 je predzadnji..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ZXCV19'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'XCVB20'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in tako nazaj."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zahtevamo lahko tudi \"rezino\", na primer vse elemente od drugega do petega: zapišemo oba indeksa, vmes pa damo dvopičje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DFGH15', 'FGHJ16', 'GHJK17']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kot je pričakovati, so geni od drugega do petega trije. Torej drugi, tretji in četrti. Ja, spodnja meja je vključena, gornja ne. Ker je tako praktično.\n",
    "\n",
    "Če hočemo vse elemente do petega ali od drugega, preprosto izpustimo spodnjo oziroma zgornjo mejo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ASDF13', 'CVBN21', 'DFGH15', 'FGHJ16', 'GHJK17']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['DFGH15',\n",
       " 'FGHJ16',\n",
       " 'GHJK17',\n",
       " 'HJKL18',\n",
       " 'SDFG14',\n",
       " 'VBNM22',\n",
       " 'XCVB20',\n",
       " 'ZXCV19']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Genov do petega je pet, torej je `[:5]` isto, kot če bi rekli \"prvih pet\". Če hočemo vse gene od drugega naprej, pa je isto, kot če bi rekli \"brez prvih dveh\". (To seveda deluje predvsem in samo zato, ker štejemo od 0!)\n",
    "\n",
    "Ker znamo šteti tudi od zadaj, znamo zahtevati vse gene razen zadnjih štirih (torej vse do minus četrtega; to deluje, ker gornja meja intervala ni vključena), ali pa prav zadnje štiri (torej od minus četrtega naprej; to deluje, ker ima zadnji indeks -1 in ne -0, kar bi bilo tako ali tako nemogoče, saj je -0 isto kot 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ASDF13', 'CVBN21', 'DFGH15', 'FGHJ16', 'GHJK17', 'HJKL18']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[:-4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['SDFG14', 'VBNM22', 'XCVB20', 'ZXCV19']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geni[-4:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Z indeksiranjem lahko sezname tudi spreminjamo. Če bi bila Ana raje Ančka, lahko seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', 'Berta', 'Cilka', 'Dani']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "spremenimo z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "imena[0] = \"Ančka\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pa imamo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ančka', 'Berta', 'Cilka', 'Dani']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kaj v resnici vrača split?\n",
    "\n",
    "Metoda `split` v resnici vrne seznam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ana', '72', '1.70']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vrstica = \"Ana 72 1.70\"\n",
    "vrstica.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seznam pa lahko priredimo bodisi eni spremenljivki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "podatki = [\"Ana\", \"72\", \"1.70\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in v tem primeru se bo spremenljivka `podatki` nanašala na ta seznam, bodisi trem,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "ime, teza, visina = [\"Ana\", \"72\", \"1.70\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pa bomo dobili tri spremenljivke.\n",
    "\n",
    "Če ne vemo, koliko jih bo, lahko preverimo dolžino seznama. Dobimo jo s funkcijo (ne metodo!) `len`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(podatki)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če imamo, recimo, seznam, ki se vedno začne z imenom in težo, naprej pa ne vemo, kaj bi utegnilo slediti, lahko napišemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "ime = podatki[0]\n",
    "teza = podatki[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Primer: geni z največ a-ji\n",
    "\n",
    "Izpisati želimo tri gene, katerih sekvence vsebuejo z največ a-jev.\n",
    "\n",
    "Očitno bi lahko razširili program, ki išče gen z največ a-ji - vendar bi bilo kar zoprno. Druga pot je, da sestavimo, hm, seznam števil a-jev."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[29, 31, 32]\n"
     ]
    }
   ],
   "source": [
    "ajev = []\n",
    "for vrstica in open(\"datoteke/qwerty-dna.txt\"):\n",
    "    ime, zaporedje = vrstica.split()\n",
    "    ajev.append(zaporedje.count(\"a\"))\n",
    "ajev.sort()\n",
    "print(ajev[-3:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Metoda `sort` uredi po velikosti, mi pa hočemo največje tri in ti so na koncu, torej bomo vzeli zadnje tri, `[-3:]`, se pravi, vse od minus tretjega do konca.\n",
    "\n",
    "Eh, no, ker velikokrat želimo urejati v rikverc, ima `sort` še argument, ki ga moramo (za razliko od tega, kar smo počeli doslej), podati z imenom, takole."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[32, 31, 29]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ajev.sort(reverse=True)\n",
    "ajev[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vse lepo in prav, ampak nas ne zanimajo števila a-jev, temveč za katere tri gene gre. Zoprna reč. Urejati moramo po številu a-jev, obenem pa ne izgubiti imen.\n",
    "\n",
    "Pa naredimo nekaj hecnega: namesto seznama števil a-jev, sestavimo seznam, ki bo vseboval sezname-pare, s številom a-jev in imenom gena."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[26, 'ASDF13'],\n",
       " [31, 'SDFG14'],\n",
       " [26, 'DFGH15'],\n",
       " [19, 'FGHJ16'],\n",
       " [32, 'GHJK17'],\n",
       " [29, 'HJKL18'],\n",
       " [24, 'ZXCV19'],\n",
       " [21, 'XCVB20'],\n",
       " [24, 'CVBN21'],\n",
       " [27, 'VBNM22']]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ajev = []\n",
    "for vrstica in open(\"datoteke/qwerty-dna.txt\"):\n",
    "    ime, zaporedje = vrstica.split()\n",
    "    ajev.append([zaporedje.count(\"a\"), ime])\n",
    "ajev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pozorno poglejte, kaj smo dali kot argument `append`-u: podali smo mu seznam, `[zaporedje.count(\"a\"), ime]`.\n",
    "\n",
    "Zdaj to uredimo s `sort`, tako kot prej. Kako pa `sort` primerja par seznamov? Najprej pogleda prva elementa. Če sta različna, je \"manjši\" tisti seznam, ki ima \"manjši\" prvi element. Če sta enaka, pogleda drugi element. In tako naprej."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[32, 'GHJK17'],\n",
       " [31, 'SDFG14'],\n",
       " [29, 'HJKL18'],\n",
       " [27, 'VBNM22'],\n",
       " [26, 'DFGH15'],\n",
       " [26, 'ASDF13'],\n",
       " [24, 'ZXCV19'],\n",
       " [24, 'CVBN21'],\n",
       " [21, 'XCVB20'],\n",
       " [19, 'FGHJ16']]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ajev.sort(reverse=True)\n",
    "ajev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj vzamemo prve tri elemente. Prehodimo jih z zanko `for` in izpišemo njihova imena.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GHJK17\n",
      "SDFG14\n",
      "HJKL18\n"
     ]
    }
   ],
   "source": [
    "naj_tri = ajev[:3]\n",
    "for par in naj_tri:\n",
    "    a, ime = par\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gre tudi hitreje. Najprej: seznama `naj_tri` niti ne potrebujemo. Prvi tri elemente lahko pograbimo kar mimogrede."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GHJK17\n",
      "SDFG14\n",
      "HJKL18\n"
     ]
    }
   ],
   "source": [
    "for par in ajev[:3]:\n",
    "    a, ime = par\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pa tudi spremenljivke `par` ne potrebujemo: v `a` in `ime` jo lahko razbijemo kar v vrstici s `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GHJK17\n",
      "SDFG14\n",
      "HJKL18\n"
     ]
    }
   ],
   "source": [
    "for a, ime in ajev[:3]:\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Da bo pregledneje, zberimo vse skupaj."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GHJK17\n",
      "SDFG14\n",
      "HJKL18\n"
     ]
    }
   ],
   "source": [
    "ajev = []\n",
    "for vrstica in open(\"datoteke/qwerty-dna.txt\"):\n",
    "    ime, zaporedje = vrstica.split()\n",
    "    ajev.append([zaporedje.count(\"a\"), ime])\n",
    "\n",
    "ajev.sort(reverse=True)\n",
    "for a, ime in ajev[:3]:\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Terke\n",
    "\n",
    "Za konec omenimo še žlahtnika seznamov, terko (angl. *tuple*). Terke se od seznamov razlikujejo po tem, da jih ne pišemo z oglatimi oklepaji temveč z okroglimi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "podatki = (\"Ana\", 72, 1.70)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seznami običajno vsebujejo same enake stvari - imeli smo seznam imen, seznam tež, seznam genov. Terke bodo navadno vsebovale različne stvari, kot recimo gornja, ki ima ime (niz) ter težo in višino (števili).\n",
    "\n",
    "Ta razlika je bolj kozmetična in ne bi bila vredna svojega podatkovnega tipa. Pomembnejša lastnost terk je, da jih ne moremo spreminjati. Terke imajo vse metode seznamov, ki ničesar ne spremenijo; manjka jim, recimo `append`. Poleg tega terke ne moremo spreminjati z indeksiranjem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-47-421cb9f87815>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpodatki\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Ančka\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "podatki[0] = \"Ančka\""
   ]
  }
 ],
 "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
}