p1/predavanja/09a oblikovanje nizov.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "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. Mu je mogoče reči, naj pri izpisu števil ne izpiše vseh šestnajst ali kolikor že decimalk? Tudi ne. `print` se s takimi rečmi ne ukvarja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8571428571428571\n"
     ]
    }
   ],
   "source": [
    "print(6 / 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj pa, če bi želeli število izpisati na samo dve decimalki? Res, nerodno.\n",
    "\n",
    "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 \"60 Fahrenheitov je 16 Celzijevih stopinj\" sta vstavljeni števili 60 in 16, ki sta odvisni od tega, v katerem semestru poženemo program, ostalo besedilo pa je vedno enako.\n",
    "\n",
    "Večina računalniških jezikov omogoča, da 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; prepoznali ga boste po `%i` `%5.3f` in podobnih rečeh. 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, ko je Python z leti postajal pametnejši. V začetku je uporabljal [nekoliko izboljšano različico C-jevskega oblikovanja](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting), saj druge praktično ni bilo. Kasneje so dodali [veliko preprostejši način oblikovanja nizov](https://docs.python.org/3.6/library/string.html#format-string-syntax), C-jevskega pa obdržali zato, da so stari programi še vedno delovali. Leta so tekla in programski jeziki napredovali. V modo je prišel drugačen še veliko prikladnejši način in Python je bil s svojima, precej nerodnejšima, videti prav štorast. Zato lahko od različice 3.6 naprej tudi v Pythonu oblikujemo nize na enak način kot v drugih modernih jezikih.\n",
    "\n",
    "Pri tem predmetu se bomo naučili le tretji načinu. Prva dva je potrebno poznati, če boste resno programirali v Pythonu in boste morali brati tudi tuje programe. Sami pa ju boste rekdo uporabili.\n",
    "\n",
    "## f-nizi\n",
    "\n",
    "Recimo, da imamo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "fahr = 42\n",
    "celz = (fahr - 32) * 5 / 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zdaj bi radi sestavili, v bistvu, takšen niz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{fahr} Fahrenheitov je {celz} Celzijev'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{fahr} Fahrenheitov je {celz} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "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": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42 Fahrenheitov je 5.555555555555555 Celzijev'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"{fahr} Fahrenheitov je {celz} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V neki 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",
    "(Mimogrede omenimo 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.)\n",
    "\n",
    "Na ta način ne vstavljamo le števil, temveč karkoli, kar se da izpisati."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Datoteke kraljice.py ne najdem'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datoteka = \"kraljice.py\"\n",
    "f\"Datoteke {datoteka} ne najdem\""
   ]
  },
  {
   "cell_type": "markdown",
   "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": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42 Fahrenheitov je 5.555555555555555 Celzijev'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fahr = 42\n",
    "\n",
    "f\"{fahr} Fahrenheitov je {(fahr - 32) * 5 / 9} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kako oblikujemo reči\n",
    "\n",
    "Nize zdaj znamo zlagati, tistega, kar nas je najbolj motilo, pa se sploh še nismo lotili: 60.0 Fahrenheitov je 15.555555555555555 Celzijev? Za moje potrebe bi popolnoma zadostovalo 15.5 in tudi pri 15 me ne bi nič bolj zeblo.\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": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42.0 Fahrenheitov je  5.6 Celzijev'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"{fahr:4.1f} Fahrenheitov je {celz:4.1f} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Primer predolgega števila: 1234.6'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1234.5678\n",
    "f\"Primer predolgega števila: {x:3.1f}\""
   ]
  },
  {
   "cell_type": "markdown",
   "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": 9,
   "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",
   "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": 10,
   "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",
   "metadata": {},
   "source": [
    "To ni ravno posrečeno. Dodajmo še presledek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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",
   "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": 12,
   "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",
   "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",
    "\n",
    "## Kontrolni znaki v nizih\n",
    "\n",
    "Niz se lahko razprostira prek več vrstic, če ga zapremo v trojne narekovaje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Niz, ki je\n",
      "dolg vec vrstic.\n",
      "Konkretno, tri!\n"
     ]
    }
   ],
   "source": [
    "s = \"\"\"Niz, ki je\n",
    "dolg vec vrstic.\n",
    "Konkretno, tri!\"\"\"\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V nizu so očitno shranjena mesta, ko mora pri izpisu iti v novo vrstico. Kako?\n",
    "\n",
    "Poleg \"običajnih\" znakov, ki jih je mogoče izpisati, vsebuje niz tudi kontrolne znake. Če jih želimo \"videti\", to lahko storimo tako, da niz izpišemo v ukazni vrstici, vendar brez `print`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Niz, ki je\\ndolg vec vrstic.\\nKonkretno, tri!'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Znak `\\n` ni pravi znak (in, predvsem, nista dva znaka, temveč en sam) in pomeni prehod v novo vrstico. Napišemo ga lahko tudi sami."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Tole gre pa\\nv dve vrstici\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pravi, vedno, ko v niz napišemo `\\n`, Python tega ne bo\n",
    "razumel kot vzvratno poševnico (*backslash*), temveč kot znak za\n",
    "prehod v novo vrsto (*new line*). Podobnih znakov je še več, vendar\n",
    "navadno uporabljamo le še enega, namreč `\\t`, ki pomeni\n",
    "tabulator. Pa ga preskusimo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\t25\n",
      "6\t36\n",
      "7\t49\n",
      "8\t64\n",
      "9\t81\n",
      "10\t100\n",
      "11\t121\n",
      "12\t144\n",
      "13\t169\n",
      "14\t196\n"
     ]
    }
   ],
   "source": [
    "for i in range(5, 15):\n",
    "    print(f\"{i}\\t{i**2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zaporedjem, ko sta `\\n` in `\\t` pravimo ubežna zaporedja (*escape sequence*).\n",
    "\n",
    "V računalnikovem pomnilniku so znaki shranjeni kot številke: vsakemu znaku ustreza določena številka. V kodiranju ASCII, ki ga običajno uporabljamo, je, npr. koda znaka A 65, koda B je 66, koda C je 67 in tako naprej. Kode  a, b in c so 97, 98 in 99... Koda presledka je 32. Vsi kontrolni znaki imajo kode manjše od 32. Tako je koda znaka `\\n` 10 in koda tabulatorja, `\\t` je 9. Več o ASCII si lahko preberete [tule](http://en.wikipedia.org/wiki/Ascii). Na tej strani se nahaja tudi [seznam kod ASCII](http://en.wikipedia.org/wiki/Ascii#ASCII_printable_characters).\n",
    "\n",
    "Da gre pri `\\n` za en znak in ne za dva, se lahko hitro prepričamo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n"
     ]
    }
   ],
   "source": [
    "s = \"a\\nb\"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(len(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Znake lahko opisujemo tudi z njihovimi kodami. To storimo z ubežnim zaporedjem `\\x`, ki ji sledi koda znaka, zapisana v šestnajstiškem številskem sistemu. Tako, je, npr. koda črke a 97, to je 61 po šestnajstiško, koda z pa 122 oz. 7a po šestnajstiško. Zato lahko niz \"Janez\" napišemo tudi takole."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Janez'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"J\\x61ne\\x7a\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tega seveda ne počnemo, ker nima smisla. Pač pa nam ubežno zaporedje pride prav, kadar želimo zapisovati kake nenavadne kontrolne znake. Včasih bomo naleteli, na primer, na znak s kodo 0. Tega zapišemo kot `\\x00` (pazite, napisati je potrebno dve ničli!).\n",
    "\n",
    "Vzvratna poševnica (*backslash*) ima torej v nizih posebno vlogo: uporablja se za ubežno zaporedje. Kaj pa, kadar želimo, da bi bila vzvratna poševnica samo vzvratna poševnica? V tem primeru naredimo dve. Torej: `\\\\` je ubežno zaporedje, ki predstavlja vzvratno poševnico (eno samo!). Kupiš dva, dobiš enega. Na Windowsih bomo to reč najpogosteje srečali v imenih direktorijev."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\documents and settings\\nina\\telovadba\n"
     ]
    }
   ],
   "source": [
    "dir = \"c:\\\\documents and settings\\\\nina\\\\telovadba\"\n",
    "print(dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še enkrat, ker je pomembno: ko pišemo imena direktorijev, vedno pišemo dvojne vzvratne poševnice, da bomo dobili enojne. Ali pa, še boljše: pišimo kar običajne poševnice, enojne. Tako napisani programi bodo delovali tudi na Linuxu in Macu.\n",
    "\n",
    "Če pozabimo pisati dvojne poševnice, dobimo, kar si zaslužimo, kar ni nujno tisto, kar bi radi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\documents and settings\n",
      "ina\telovadba\n"
     ]
    }
   ],
   "source": [
    "dir = \"c:\\documents and settings\\nina\\telovadba\"\n",
    "print(dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`\\n` in `\\t` sta znaka za novo vrstico in za tabulator.\n",
    "\n",
    "Pisanju dvojnih poševnic se lahko izognemo z r-nizi (*r* kor *raw*). Ti so podobni f-nizom, le da pred narekovaj damo črko `r` in vzvratna poševnica bo samo vzvratna poševnica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\documents and settings\\nina\\telovadba\n"
     ]
    }
   ],
   "source": [
    "dir = r\"c:\\documents and settings\\nina\\telovadba\"\n",
    "print(dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V tem primeru v niz ne moremo dati ubežnega zaporedja `\\n`, saj bosta `\\` in `n` v tem primeru res pomenila samo `\\` in `n`.\n",
    "\n",
    "Med vsemi drugimi ubežnimi zaporedji omenimo le še dve: `\\'` in `\\\"` predstavljata enojni in dvojni narekovaj.\n",
    "\n",
    "Mimogrede, če vam bo kdaj prišlo prav: kodo znaka dobimo s funkcijo `ord`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"A\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V drugo smer vodi funkcija `chr`, ki ji povemo kodo znaka in vrne niz, ki vsebuje znak s to kodo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(65)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'B'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(66)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(10)"
   ]
  }
 ],
 "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": 4
}