p1/kratki zapiski/09 oblikovanje nizov, datoteke.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Oblikovanje nizov\n",
    "\n",
    "Kot vsak normalen jezik ima tudi Python nek način oblikovanja nizov. Iz zgodovinskih razlogov pravzaprav tri.\n",
    "\n",
    "### Operator `%`\n",
    "\n",
    "V C-ju in jezikih, ki se zgledujejo po njem, imamo vzorce oblike `\"Danes sem videl %i primerkov %s.\"`. To je tudi najstarejša oblika oblikovanja nizov v Pythonu, le da Python nima funkcij, kot je C-jev `printf`, temveč ima niz operator `%` (ja, recikliran operator za ostanek po deljenju), ki mu sledi terka z vrednostmi, ki jih je potrebno vstaviti. Če vstavljamo le eno vrednost, je ni potrebno dajati v terko."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes sem videl 7 primerkov medvedov.'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Danes sem videl %i primerkov %s.\" % (7, \"medvedov\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes sem videl medveda.'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Danes sem videl %s.\" % \"medveda\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seveda lahko vključimo tudi vse ostale C-jevske trike - število mest, decimalk, predznak..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'π je približno 3.14.'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"π je približno %4.2f.\" % 3.14159265"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To starodavno obliko boste v novejši kodi videvali le še v povezavi z modulom [`logging`](https://docs.python.org/3/library/logging.html), zato v zvezi z njo ne bomo našteli vsega, kar se da (še) početi z njo in tega (še) ne poznati iz drugih jezikov, kjer ste morda srečali nize v tej obliki. Kdor hoče vedeti, bo pogledal [dokumentacijo](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting). Tu pokažimo le še tole: namesto terke lahko podamo slovar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes sem videl 7 primerkov medvedov.'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Danes sem videl %(n)i primerkov %(zival)s.\" % {\"n\": 7, \"zival\": \"medvedov\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To je očitno še posebej uporabno predvsem\n",
    "- če je niz zapleten in se ne bi radi izgubljali v vrstnem redu,\n",
    "- ali če imamo tak slovar že ravno pri roki.\n",
    "\n",
    "Slovar lahko vsebuje tudi odvečne elemente; Python jih bo pač ignoriral.\n",
    "\n",
    "### Metoda `format`\n",
    "\n",
    "Nizi imajo metodo `format`. Ta znotraj niza poišče vse pare zavitih oklepajev in jih zamenja z istoležnimi argumenti, ki jih podamo ob klicu `format`. Bolj očitno bo iz primera."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes sem videl 7 primerkov medvedov.'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vzorec = \"Danes sem videl {} primerkov {}.\"\n",
    "\n",
    "vzorec.format(7, \"medvedov\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dele lahko, tako kot prej, tudi poimenujemo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes sem videl 7 primerkov medvedov.'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Danes sem videl {n} primerkov {zival}.\".format(n=7, zival=\"medvedov\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če želimo dodati oblikovanje, dodamo `:` in za njim obliko v običajni obliki."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.14 odstotkov medvedov še ne spi.'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{n:.2f} odstotkov medvedov še ne spi.\".format(n=3.14159265)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če hočemo brez imena, pač naredimo brez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.14 odstotkov medvedov še ne spi.'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{:.2f} odstotkov medvedov še ne spi.\".format(3.14159265)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta način je praktičen zato, ker je vzorec shranjen v obliki niza. Kaj s tem mislim, bomo videli, ko izvemo za trenutno aktualen način oblikovanja, kjer ni tako. V praksi pa tudi tega način ne uporabljamo več pogosto, zato bodi tudi o njem dovolj. Berite [dokumentacijo](https://docs.python.org/3/library/string.html#format-string-syntax).\n",
    "\n",
    "## Interpolacija\n",
    "\n",
    "Danes je v vseh sodobnih jezikih v modi veliko prikladnejši način oblikovanja nizov. Tipično ga najdemo pod imenom [string interpolation](https://en.wikipedia.org/wiki/String_interpolation). Python ga ima od različice 3.6.\n",
    "\n",
    "Ko pišemo niz, pred narekovaj (enojni ali dvojni ali trojni) damo znak `f` in Python bo vse, kar je znotraj zavitih oklepajev izračunal in vstavil v niz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Danes sem srečal 7 primerkov medvedov.'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 7\n",
    "zival = \"medvedov\"\n",
    "\n",
    "f\"Danes sem srečal {n} primerkov {zival}.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Znotraj oklepajev so lahko celi izrazi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42 Fahrenheitov je 5.555555555555555 Celzijev'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fahr = 42\n",
    "\n",
    "f\"{fahr} Fahrenheitov je {(fahr - 32) * 5 / 9} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tako kot pri `format`, lahko izrazu sledi dvopičje in nato format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'42.0 Fahrenheitov je 5.6 Celzijev'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"{fahr:3.1f} Fahrenheitov je {(fahr - 32) * 5 / 9:3.1f} Celzijev\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vse je enako kot v C-ju: v formatu `4.1f` številke, `4.1`, pomenijo, da bi radi izpis na štiri mesta, pri čemer naj bo eno rezervirano za decimalko. Za črko `f` si predstavljajmo, da pomeni `float`. Če pustimo za število premalo prostora, ga bo izpis pač zasedel več."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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",
   "metadata": {},
   "source": [
    "Še nekaj oblikovanja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": [
    "Znak, ki pove, za kaj gre (število, niz...) lahko tudi izpustimo in Python bo naredil, kot bo prav.\n",
    "\n",
    "Opazimo, da so nizi privzeto poravnani na levo, številka na desno. To lahko spremenimo, če za dvopičje dodamo \"puščico\" `<`, `>` ali `^` (centriranje)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": [
    "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": 15,
   "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",
    "Tega je seveda še ogromno. Določimo lahko, naj se vedno izpiše predznak, torej +, kadar je število pozitivno, zahtevamo izpis v dvojiškem ali šestnajstiškem sistemu.... Za števila lahko določimo, naj se izpišejo dvojiško ali šestnajstiško... Kdor potrebuje več kot to: [dokumentacija](https://docs.python.org/3/library/string.html#formatspec).\n",
    "\n",
    "## Kdaj uporabiti kaj?\n",
    "\n",
    "Vsaka oblika ima še vedno svoje prednosti.\n",
    "\n",
    "- V starejših oblikah (`%` in `format`) lahko shranimo vzorec v niz, npr. `vzorec = \"Danes je %(vreme)s.\"` oz. `vzorec = \"Danes je {vreme}.\"`. V novi tega ne moremo storiti, ker se niz `f\"Danes je {vreme}\"` izračuna (interpolira) takoj, na mesto. To je uporabno predvsem, kadar bi radi vzorec podali neki funkciji, ki bo vanj potem vstavila podatke in vse skupaj izpisala. Ni, da bi to počeli pogosto, lahko pa se zgodi. Včasih je tudi praktično shraniti vzorec v datoteko, ki jo v programu preberemo in vstavimo podatke. Z novo obliko to ne gre.\n",
    "\n",
    "- V prvi in zadnji obliki (`%` in interpolacija) Python ne kliče funkcije, pri drugi, `format`, pa kličemo metodo. Nekoč sem naletel na situacijo - ki pa se je za noben denar ne morem spomniti (sploh mi ga pa niti nihče ne ponuja) - ko mi Python ni pustil uporabiti `format`, ker bi to zahtevalo klic, v onem kontekstu pa klic ni bil dovoljen. Mislim, da je bilo povezano z logiranjem oz. z napakami in Python tam ni hotel spreminjati sklada. Po spominu.\n",
    "\n",
    "V praksi: predlagam, naj vsa nova koda uporablja interpolacijo. Navadite se jih tudi zato, ker boste tudi v drugih sodobnih jezikih uporabljali interpolacijo, le sintaksa bo v vsakem jeziku malo drugačna.\n",
    "\n",
    "# Kontrolni znaki v nizih\n",
    "\n",
    "Kontrolne znake zapisujemo tako, kot ste vajeni od drugod:\n",
    "\n",
    "- `\\n`: nova vrstica,\n",
    "- `\\t`: tabulator,\n",
    "- `\\x41`: znaki, podani z ASCII kodo v šestnajstiškem zapisu (tole je veliki A),\n",
    "- `\\u0041`: znaki, podani z Unicode v šestnajstiškem zapisu (tudi tole je veliki A),\n",
    "- `\\N{GREEK SMALL LETTER PI}`: ime znaka v Unicode (tole očitno ni veliki A),\n",
    "- še vse živo drugo,\n",
    "- `\\\\`: backslash, AKA vzvratna poševnica.\n",
    "\n",
    "Če imamo v nizu veliko vzvratnih poševnic in se nam jih ne podvaja, uporabimo r-nize (`r` kot *raw*). Pred narekovaj damo znak `r` in vzvratna poševnica bo le še vzvratna poševnica. Kot naj bi (čeprav najbrž ni) rekel Freud: *cigara je včasih vseeno samo cigara*.\n",
    "\n",
    "Vzvratno poševnico često pišemo v imenih direktorijev. Pišite navadno; tudi Windowsi jo že dolgo razumejo. Pač pa se boste z njimi pretepali v regularnih izrazih. Da, tam pa potrebujemo r-nize.\n",
    "\n",
    "Komentar si zaslužijo še kode za Unicode: tudi teh ne potrebujemo pogosto. Programi v Pythonu so navadno shranjeni kot Unicode, praviloma UTF-8, in lahko brez težav vsebujejo znak π, kot smo prepričljivo videli tudi v enem gornjih nizov. Zato jih bomo z `\\N{GREEK SMALL LETTER PI}` najbrž opisali približno tolikokrat, kot bomo veliki A opisali z `\\x41`.\n",
    "\n",
    "\n",
    "# Delo z datotekami\n",
    "\n",
    "Datoteke odpremo s funkcijo `open(ime_datoteke)`. Če ne podamo drugih argumentov, jo bo Python odprl kot besedilno datoteko, za branje in s kodiranjem, ki je privzeto za sistem in je v spodobnih sistemih UTF-8, na Windowsih pa bogvekaj, recimo cp1250. `open(ime_datoteke)` je torej v normalnih razmerah isto kot `open(ime_datoteke, \"rt\", encoding=\"utf-8\")`. Argument `encoding` podamo poimensko, ker je vmes še en nezanimiv argument in ker je poimensko podajanje (vsaj tu) tako ali tako lepše.\n",
    "\n",
    "## Branje besedilnih datotek\n",
    "\n",
    "Datoteka, ki jo odpremo za branje, se vede kot generator, ki vrača vrstice. Običajno bomo datoteko torej brali z\n",
    "\n",
    "```python\n",
    "for vrstica in open(ime):\n",
    "```\n",
    "\n",
    "Druge metode, ki vas lahko zanimajo, so:\n",
    "\n",
    "- `read()` prebere celotno datoteko v niz. Temu naj ne sledi `split(\"\\n\")`, ker je nesmiselno in vas poleg tega utegne zafrkniti, ker se bo zadnja vrstica tipično končala z `\\n`, zato bo `split` na konec dodal še en prazen niz. Če že, naj temu sledi `splitlines()`, vendar tudi to ni smiselno - zaradi naslednje metode.\n",
    "- `readlines()` prebere vse vrstice datoteke (oz. vse preostale vrtice, če nismo na začetku datoteke) v seznam nizov. Nizi vsebujejo tudi znak za novo vrstico, `\\n`. \n",
    "- `readline()` prebere eno (=naslednjo) vrstico datoteke.\n",
    "\n",
    "## Pisanje besedilnih datotek\n",
    "\n",
    "Če želimo pisati v besedilno datoteko, jo odpremo z `open(ime_datoteke, \"w\")`, ki pobriše morebitno obstoječo datoteko s tem imenom, ali `open(ime_datoteke, \"a\")` (`a` kot *append*), ki dodaja na konec obstoječe datoteke. Namesto `w` in `a` lahko pišemo tudi `wt` ali `at`, vendar ni potrebno, ker je `t` (besedilna datoteka) tako ali tako privzeti način.\n",
    "\n",
    "Edina res uporabna metoda za pisanje v datoteke je\n",
    "\n",
    "- `write(s)`\n",
    "\n",
    "Obstaja tudi \n",
    "\n",
    "- `writelines(s)`, ki v datoteko zapiše seznam vrstic `s`. Ker `writelines` ne dodaja znakov `\\n` (tako kot jih `readlines` ni brisal), jih moramo dodati sami. Potemtakem pa je hitreje preprosto napisati `write(\"\\n\".join(s))`.\n",
    "\n",
    "## Zapiranje datotek\n",
    "\n",
    "Datoteke imajo metodo `close`. V praksi jo redko kličemo,\n",
    "\n",
    "- ker se datoteka zapre sama, takrat ko *garbage collection* pospravi ime, ki se nanaša nanjo, torej tipično na koncu funkcije ali programa\n",
    "- ker takrat, ko hočemo to izvesti po vseh pravilih, datoteko odpremo z `with`, ki pa sam skrbi za zapiranje. Več o tem pa v ločenem predavanju o *context managerjih*.\n",
    "\n",
    "\n",
    "## Binarne datoteke\n",
    "\n",
    "Binarne datoteke odpremo tako, da v niz, s katerim podamo način odpiranja, dodamo `b`. Torej `open(ime, \"rb\")` oziroma `open(ime, \"wb\")`. Ko beremo binarno datoteko - kar očitno počnemo z `read` in ne `readline` ali `readlines`, saj binarne datoteke nimajo vrstic - ne dobimo niza (`str`) temveč bajte (`bytes`). Torej čisto drug podatkovni tip. Prav tako z `write` v binarne datoteke zapisujemo bajte, ne nizov.\n",
    "\n",
    "To pa je tema za [ločeno poglavje](http://localhost:8888/notebooks/p1/dodatna%20predavanja/09%20binarne%20datoteke%3B%20nizi%20in%20bajti.ipynb), saj podatkovni tip `bytes` ni povezan le z datotekami."
   ]
  }
 ],
 "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
}