pn/predavanja/07 Oblikovanje nizov.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a530cd73",
   "metadata": {},
   "source": [
    "# Oblikovanje nizov\n",
    "\n",
    "Pri izpisovanju smo bili doslej omejeni na dokaj zoprni `print`. Za začetek nam je zadoščal, kmalu pa postane neroden, saj nekaterih stvari z njim preprosto ni mogoče (preprosto) narediti. Za začetek se je potrebno z njim pogajati, da ne gre po vsakem izpisu v novo vrsto in da ne dodaja presledkov med reči, ki jih izpisujemo.\n",
    "\n",
    "Če smo imeli slovar, v katerem je pisalo, koliko kilometrov je nekdo prevozil s katerim izmed svojih koles,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "70d585c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "razdalje = {'Canyon': 2932, 'Cube': 2939,\n",
    "            'Nakamura': 488, 'Stevens': 0}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e6107e2",
   "metadata": {},
   "source": [
    "in hoteli to izpisati, nam je `print` dodajal presledke pred dvopičja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "baff5447",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon : 2932\n",
      "Cube : 2939\n",
      "Nakamura : 488\n",
      "Stevens : 0\n"
     ]
    }
   ],
   "source": [
    "for kolo, razdalja in razdalje.items():\n",
    "    print(kolo, \":\", razdalja)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a4fe2aa",
   "metadata": {},
   "source": [
    "Če bi želeli poleg tega v oklepjih izpisati, kakšen delež je prevozil s katerim kolesom, bi dobili kole neprebavljivost:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "62d313b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon : 2932 ( 46.10787859726372 %)\n",
      "Cube : 2939 ( 46.217958798553234 %)\n",
      "Nakamura : 488 ( 7.6741626041830475 %)\n",
      "Stevens : 0 ( 0.0 %)\n"
     ]
    }
   ],
   "source": [
    "skupna = sum(razdalje.values())\n",
    "\n",
    "for kolo, razdalja in razdalje.items():\n",
    "    print(kolo, \":\", razdalja, \"(\",\n",
    "          razdalja / skupna * 100, \"%)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cac45ed",
   "metadata": {},
   "source": [
    "Preveč decimalk, tile grozni presledki ... morda pa bi se prileglo tudi kaj poravnavanja, ne? \n",
    "\n",
    "Slaba novica: `print`-u sicer lahko rečemo, naj ne piše odvečnih presledkov, s poravnavanjem in decimalkami pa se mu res ne da ukvarjati."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af922aba",
   "metadata": {},
   "source": [
    "Večina besedil, ki jih izpišejo ali kako drugače pokažejo programi, vsebuje fiksno besedilo, v katerega so vstavljeni kaki nizi ali številke. Če računalnik izpiše \"Datoteke kraljice.py ni mogoče najti\", je vstavljeno besedilo \"kraljice.py\", ki je najbrž vsakič drugačno, odvisno pač od tega, katero datoteko (neuspešno) iščemo. V \"Danes je 60 Fahrenheitov, to je, 16 Celzijevih stopinj\" sta vstavljeni števili 60 in 16, ki sta odvisni od tega, v katerem letnem času poženemo program (in koliko smo že uspeli pogreti planet), ostalo besedilo pa je vedno enako.\n",
    "\n",
    "Večina programskih jezikov - ali pa pripadajočih knjižnic - ima kak mehanizem, s katerim lahko sestavimo nize tako, da napišemo \"konstantni\" niz, označimo mesta, na katera je potrebno nekaj vstaviti. Potem pa na nek način povemo, kaj naj vstavi. Popularni prevajani jeziki so večinoma povzeli način, ki so si ga izmislili v jeziku C in je malo bolj zoprn, novejši jeziki, predvsem skriptni, ki so bližje spletu, pa navadno omogočajo preprostejše in zmogljivejše načine sestavljanja nizov iz vzorcev.\n",
    "\n",
    "Eno od načel Pythona je, da se da vsako stvar narediti na en in samo en očiten način. To je dobro zato, ker, posledično, vsi programerji pišemo podobne programe in zato lažje sodelujemo. Prav pri oblikovanju nizov pa se je to sfižilo: nize lahko oblikujemo na tri različne načine. Do tega je prišlo, ker so določene ideje (ne le v Pythonu) zorele z leti, vendar (za)star(el)ih načinov ne moreš kar tako ukiniti, saj starejši programi potem ne bi več delali v novejših različicah jezika. Zaresen programer v Pythonu mora poznati vse tri načine, nam bo zadoščal zadnji, najmodernejši. V resnici tudi jaz, zaresen programer, uporabljam le še tega.\n",
    "\n",
    "## f-nizi\n",
    "\n",
    "Recimo, da imamo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "57088bb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "fahr = 42\n",
    "celz = (fahr - 32) * 5 / 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5220bbc",
   "metadata": {},
   "source": [
    "Zdaj bi radi sestavili, v bistvu, takšen niz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b51162b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{fahr} Fahrenheitov je {celz} Celzijev'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{fahr} Fahrenheitov je {celz} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e39e1f1e",
   "metadata": {},
   "source": [
    "le da želimo, da Python na mesti, ki smo ju označili s `{fahr}` in `{celz}`, vstavi vrednosti spremenljivk `fahr` in `celz`.\n",
    "\n",
    "To počnejo f-nizi. F-niz je kot običajen niz, le da mu pred prvi narekovaj dodamo črko f (kot *format*). V takšnih nizih imajo zaviti oklepaji poseben pomen: kar je v njih, se (izračuna in) vstavi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2c131f91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42 Fahrenheitov je 5.555555555555555 Celzijev'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"{fahr} Fahrenheitov je {celz} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea49353",
   "metadata": {},
   "source": [
    "V neki stari domači nalogi smo - oh, kako je bilo to nerodno! - pisali\n",
    "\n",
    "```python\n",
    "from random import randint\n",
    "\n",
    "a = randint(2, 10)\n",
    "b = randint(2, 10)\n",
    "print(a, \"krat\", b)\n",
    "c = input(\"Odgovor? \")\n",
    "```\n",
    "\n",
    "S tem, da najprej izpišemo in potem zahtevmo odgovor, smo se izognili temu, da bi morali mukoma sestavljali niz ob klicu funkcije `input`:\n",
    "\n",
    "```python\n",
    "a = randint(2, 10)\n",
    "b = randint(2, 10)\n",
    "c = input(\"Koliko je \" + str(a) + \"x\" + str(b) + \"?\")\n",
    "```\n",
    "\n",
    "Zdaj, ko poznamo metodo f-nize, poznamo preprostejši način:\n",
    "\n",
    "```python\n",
    "a = randint(2, 10)\n",
    "b = randint(2, 10)\n",
    "c = input(f\"Koliko je {a}x{b}? \")\n",
    "```\n",
    "\n",
    "(Tule je priložnost, da mimogrede pokažemo starejša načina oblikovanja nizov, ki smo ju omenjali na začetku: v C-jevskem slogu bi pisali `c = input(\"Koliko je %sx%s? \" % (a, b))`, v onem, malo novejšem pa `c = input(\"Koliko je {}x{}? \".format(a, b))`. Obema je skupno to, da so v nizu le označena mesta, kamor je potrebno vstavljati, potem pa moramo na nekem drugem mestu, po koncu niza, našteti stvari, ki jih vstavljamo. Z novejšim slogom lahko z nekimi čudnimi triki v zavite oklepaje dodajamo tudi imena spremenljivk, vendar niti približno tako udobno kot po novem. Vsak od starih načinov ima tudi kakšno lastnost, zaradi katere ga moramo včasih uporabiti tudi v novih programih v Pythonu. Vendar se to zgodi zelo redko in v zelo posebnih primerih.)\n",
    "\n",
    "Na ta način ne vstavljamo le števil, temveč karkoli, kar se da izpisati."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9a6d236a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Datoteke kraljice.py ne najdem'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datoteka = \"kraljice.py\"\n",
    "f\"Datoteke {datoteka} ne najdem\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73a2a27b",
   "metadata": {},
   "source": [
    "## Izrazi v f-nizih\n",
    "\n",
    "V nize ne vstavljamo le vrednosti spremenljivk: v zavite oklepaje lahko pišemo kar cele izraze."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "947df855",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42 Fahrenheitov je 5.555555555555555 Celzijev'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fahr = 42\n",
    "\n",
    "f\"{fahr} Fahrenheitov je {(fahr - 32) * 5 / 9} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30b28d16",
   "metadata": {},
   "source": [
    "Zdaj pa spet na kolesa!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "12fcd828",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon: 2932 (46.10787859726372 %)\n",
      "Cube: 2939 (46.217958798553234 %)\n",
      "Nakamura: 488 (7.6741626041830475 %)\n",
      "Stevens: 0 (0.0 %)\n"
     ]
    }
   ],
   "source": [
    "skupna = sum(razdalje.values())\n",
    "\n",
    "for kolo, razdalja in razdalje.items():\n",
    "    print(f\"{kolo}: {razdalja} ({razdalja / skupna * 100} %)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b980950b",
   "metadata": {},
   "source": [
    "Delen uspeh. Znebili smo se presledkov pred dvopiči, predvsem pa je postalo samo izpisovanje preglednejše. Kar primerjajmo:\n",
    "\n",
    "```\n",
    "prej: print(kolo, \":\", razdalja, \"(\", razdalja / skupna * 100, \"%)\")\n",
    "zdaj: print(f\"{kolo}: {razdalja} ({razdalja / skupna * 100} %)\")\n",
    "```\n",
    "\n",
    "Če hočemo še pregledneje, pa lahko napišemo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ae91e925",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon: 2932 (46.10787859726372 %)\n",
      "Cube: 2939 (46.217958798553234 %)\n",
      "Nakamura: 488 (7.6741626041830475 %)\n",
      "Stevens: 0 (0.0 %)\n"
     ]
    }
   ],
   "source": [
    "skupna = sum(razdalje.values())\n",
    "\n",
    "for kolo, razdalja in razdalje.items():\n",
    "    delez = razdalja / skupna * 100\n",
    "    print(f\"{kolo}: {razdalja} ({delez} %)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4d16e45",
   "metadata": {},
   "source": [
    "Zdaj je f-niz očitno vzorec, v katerega vstavljamo vrednosti.\n",
    "\n",
    "Ostane nam še boj z decimalkami."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd870f99",
   "metadata": {},
   "source": [
    "## Kako oblikujemo reči\n",
    "\n",
    "Če bi radi povedali, kako naj se izpiše neko število (ali niz ali karkoli že), dodamo izrazu dvopičje in za njim opis formata.\n",
    "\n",
    "To bomo najpogosteje potrebovali za oblikovanje necelih števil. To gre tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5bbb2572",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42.0 Fahrenheitov je  5.6 Celzijev'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"{fahr:4.1f} Fahrenheitov je {celz:4.1f} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8adeae0c",
   "metadata": {},
   "source": [
    "Opis formata je tule `4.1f`. Pri tem `4.1` pomeni, da bi radi izpis na štiri mesta, pri čemer naj bo eno rezervirano za decimalko. Za črko `f` si predstavljajte, da pomeni `float`.\n",
    "\n",
    "Če pustimo za število premalo prostora, ga bo izpis pač zasedel več."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "472c4f1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Primer predolgega števila: 1234.6'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1234.5678\n",
    "f\"Primer predolgega števila: {x:3.1f}\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16ad60a3",
   "metadata": {},
   "source": [
    "Zahtevali smo eno decimalko in to smo tudi dobili, vse skupaj pa je širše kot\n",
    "štiri mesta, saj je število pač predolgo.\n",
    "\n",
    "Določanje števila decimalk je smiselno le pri necelih številih. Če\n",
    "vstavljamo nize ali cela števila, lahko določamo le širino:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1298602a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anze          74\n",
      "Benjamin      82\n",
      "Cilka         48\n",
      "Dani          66\n",
      "Eva           61\n",
      "Franc        101\n"
     ]
    }
   ],
   "source": [
    "podatki = [\n",
    "    (74, \"Anze\", False),\n",
    "    (82, \"Benjamin\", False),\n",
    "    (48, \"Cilka\", True),\n",
    "    (66, \"Dani\", False),\n",
    "    (61, \"Eva\", True),\n",
    "    (101, \"Franc\", False),\n",
    "    ]\n",
    "\n",
    "for teza, ime, spol in podatki:\n",
    "    print(f\"{ime:10}{teza:6}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decc6dba",
   "metadata": {},
   "source": [
    "Tu za številom mest nismo dodajali črke `f`, saj ne gre za (necela) števila. Za nizi pa sploh ne. (Obstajajo sicer druge črke, ki bi jih lahko dodali, da Python povemo, za kaj gre, vendar jih smemo tule brez škode pozabiti.)\n",
    "\n",
    "Vsa imena so izpisana z desetimi znaki; manjkajoči prostor je zapolnjen s presledki. Številke so izpisane s šestimi mesti, manjkajoči prostor spet zapolnjujejo presledki.\n",
    "\n",
    "Nizi so poravnani na levo - presledki so dodani za njimi. Večina reči, ki jih izpisujemo (nizi in števila namreč niso edino, kar se da izpisati), so poravnani tako. Številke pa so poravnane desno. To lahko spremenimo, če za dvopičje dodamo `<`, `>` ali `^`, s katerimi naročimo, naj bo reč poravnana levo, desno ali na sredino. Ravno obratni izpis kot zgoraj bi dosegli z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "47db6e55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Anze74    \n",
      "  Benjamin82    \n",
      "     Cilka48    \n",
      "      Dani66    \n",
      "       Eva61    \n",
      "     Franc101   \n"
     ]
    }
   ],
   "source": [
    "for teza, ime, spol in podatki:\n",
    "    print(f\"{ime:>10}{teza:<6}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2a65378",
   "metadata": {},
   "source": [
    "To ni ravno posrečeno. Dodajmo še presledek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c70d8175",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Anze 74    \n",
      "  Benjamin 82    \n",
      "     Cilka 48    \n",
      "      Dani 66    \n",
      "       Eva 61    \n",
      "     Franc 101   \n"
     ]
    }
   ],
   "source": [
    "for teza, ime, spol in podatki:\n",
    "    print(f\"{ime:>10} {teza:<6}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d53fb0b",
   "metadata": {},
   "source": [
    "To je lažje berljivo, še vedno pa je seveda najlepši prvi izpis.\n",
    "\n",
    "Pred znak, ki določa poravnavo, lahko dodamo simbol, ki naj se uporabi za zapolnjevanje - če seveda nismo zadovoljni s presledkom. Poravnajmo imena levo, števile desno, namesto presledkov pa zapolnimo prazen prostor s pikami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c0e584f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anze..........74\n",
      "Benjamin......82\n",
      "Cilka.........48\n",
      "Dani..........66\n",
      "Eva...........61\n",
      "Franc........101\n"
     ]
    }
   ],
   "source": [
    "for teza, ime, spol in podatki:\n",
    "    print(f\"{ime:.<10}{teza:.>6}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f389d7",
   "metadata": {},
   "source": [
    "Namesto pik lahko uporabimo poljuben drug znak. Kadar takole zapolnjujemo prostor s čimerkoli drugim kot s presledki, moramo dodati znake za poravnavanje (`<`, `>` ali `^`), tudi kadar z njimi izberemo takšno poravnavanje, kot bi bilo tudi privzeto (desno za števila, levo za vse drugo) všeč.\n",
    "\n",
    "V vse detajle ne bomo šli. Določiti je mogoče še veliko reči. Pri številih lahko zahtevamo, naj se vedno izpiše predznak, torej +, kadar je število pozitivno. Za števila lahko določimo, naj se izpišejo dvojiško ali šestnajstiško... Kdor potrebuje več kot to, naj Googla.\n",
    "\n",
    "### Oblikovanje koles\n",
    "\n",
    "Nazaj h kolesom. Večina izpisa je v redu, le deleže bi radi izpisali z manj decimalkami - recimo z eno samo. Dovolj je dodati `:.1f`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7f1dc97a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon: 2932 (46.1 %)\n",
      "Cube: 2939 (46.2 %)\n",
      "Nakamura: 488 (7.7 %)\n",
      "Stevens: 0 (0.0 %)\n"
     ]
    }
   ],
   "source": [
    "skupna = sum(razdalje.values())\n",
    "\n",
    "for kolo, razdalja in razdalje.items():\n",
    "    print(f\"{kolo}: {razdalja} ({razdalja / skupna * 100:.1f} %)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17a77de0",
   "metadata": {},
   "source": [
    "Celotna zgodba s kolesi je sicer nekoliko daljša. Podatke smo prebrali iz datoteke."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b64066ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "voznje = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "razdalje = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "visine = {\"Canyon\": 0, \"Cube\": 0, \"Nakamura\": 0, \"Stevens\": 0}\n",
    "\n",
    "for vrstica in open(\"kolesa.txt\"):\n",
    "    kolo, razdalja, visina = vrstica.split(\",\")\n",
    "    voznje[kolo] += 1\n",
    "    razdalje[kolo] += int(razdalja)\n",
    "    visine[kolo] += int(visina)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "430712f9",
   "metadata": {},
   "source": [
    "V slovarjih `voznje`, `razdalje` in `visine` imamo število voženj ter skupno razdaljo in višino, prevoženo s posameznim kolesom. Kaj, ko bi to izpisali v obliki tabelice?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3acd525a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Canyon         26 (26.0%)       2766 (39.6%)      26392 (27.0%) \n",
      "Cube           43 (43.0%)       3174 (45.4%)      66705 (68.3%) \n",
      "Nakamura       22 (22.0%)        439 ( 6.3%)       1119 ( 1.1%) \n",
      "Stevens         9 ( 9.0%)        607 ( 8.7%)       3395 ( 3.5%) \n"
     ]
    }
   ],
   "source": [
    "sk_voz = sum(voznje.values())\n",
    "sk_raz = sum(razdalje.values())\n",
    "sk_vis = sum(visine.values())\n",
    "\n",
    "for kolo in voznje:\n",
    "    voz, raz, vis = voznje[kolo], razdalje[kolo], visine[kolo]\n",
    "    print(f\"{kolo:12}{voz:5} ({voz / sk_voz:>5.1%}) {raz:10} \"\n",
    "          f\"({raz / sk_raz:>5.1%}) {vis:10} ({vis / sk_vis:>5.1%}) \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fce9a87",
   "metadata": {},
   "source": [
    "Novo je oblikovanje odstotkov: ne množimo s 100 in ne uporabimo `f` (recimo, zgoraj. `.1f`) temveč `%`. Konkretno, napisali smo `{voz / sk_voz:>5.1%}`. Količnik `voz / sk_voz` smo poravnali desno, izpisali na pet mest z eno decimalko in sicer kot odstotek. Ta pomeni, da bo Python reč kar sam pomnožil s `100` in še znak `%` bo dodal.\n",
    "\n",
    "Mimogrede opazíte še, da smo spremenljivkam `voz`, `raz` in `vis` dali kratka imena, skupnemu številu voženj, dolžini in razdalji pa podobna, prav tako kratka imena. Že s tako kratkimi je vrstica kar dolga.\n",
    "\n",
    "Izpis je videti že kar imenitno; še bolj imeniten bo, če mu dodamo imena stolpcev."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a09eab1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Kolo       Število voženj           Razdalja             Višina\n",
      "---------------------------------------------------------------\n",
      "Canyon         26 (26.0%)       2766 (39.6%)      26392 (27.0%)\n",
      "Cube           43 (43.0%)       3174 (45.4%)      66705 (68.3%)\n",
      "Nakamura       22 (22.0%)        439 ( 6.3%)       1119 ( 1.1%)\n",
      "Stevens         9 ( 9.0%)        607 ( 8.7%)       3395 ( 3.5%)\n",
      "---------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "sk_voz = sum(voznje.values())\n",
    "sk_raz = sum(razdalje.values())\n",
    "sk_vis = sum(visine.values())\n",
    "\n",
    "print()\n",
    "print(f\"{'Kolo':6}{'Število voženj':>19}{'Razdalja':>19}{'Višina':>19}\")\n",
    "print(\"-\" * (6 + 3 * 19))\n",
    "for kolo in voznje:\n",
    "    voz, raz, vis = voznje[kolo], razdalje[kolo], visine[kolo]\n",
    "    print(f\"{kolo:12}{voz:5} ({voz / sk_voz:>5.1%}) {raz:10} \"\n",
    "          f\"({raz / sk_raz:>5.1%}) {vis:10} ({vis / sk_vis:>5.1%})\")\n",
    "print(\"-\" * (6 + 3 * 19))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "586e7211",
   "metadata": {},
   "source": [
    "Tako lepo, da je že kar malo kičasto."
   ]
  }
 ],
 "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
}