02 Izrazi in spremenljivke.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter je kalkulator\n",
    "\n",
    "Jupyter (oziroma Python) je, za začetek ... kalkulator.\n",
    "\n",
    "V celico s programsko kodo vpišemo račun in ko jo izvedemo, izvemo rezultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2 * 3+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ker smo v Jupytru odprli beležnico vrste \"Python 3\", v celice s programsko kodo vpisujemo programe v Pythonu (različica 3). Spletni strežnik v ozadju v resnici požene Python in mu vsakič, ko pritisnemo Shift-Enter, da vsebino celice v izračun.\n",
    "\n",
    "Temu, kar smo vpisovali zgoraj, pravimo *izraz*. Tu se ne bomo ukvarjali s pravorečjem in točnimi definicijami: izraz bo za nas pač *nekaj, kar se da izračunati*.\n",
    "\n",
    "V izrazih lahko uporabljamo presledke in to moramo - kot tudi sicer - početi po občutku. V zadnjem izrazu tega nismo počeli, zato je zapis zavajajoč. Python je dovolj pameten, da ve, da ima *operator* (še ena beseda, ki si jo zapomnimo!) množenja prednost pred operatorjem seštevanja. Kar smo napisali, se računa enako, kot če bi rekli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2*3+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2*3 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2 * 3 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nekoč se bomo dogovorili za zadnje, dotlej pa jih pišite, kakor hočete, le na začetku ne sme biti presledkov (razen takrat, ko bodo morali biti - kar bomo srečali v naslednji uri).\n",
    "\n",
    "Kakšni operatorji še obstajajo? Očitna sta še `/` za deljenje in `-` za odštevanje. Dvojna zvezdica, `**`, pomeni potenciranje (mednju ne smemo napisati presledka, `**` je kot, recimo, ena *beseda*). Operator `%` izračuna ostanek po deljenju."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13 % 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Potenciranje ima prednost pred vsem, kar poznamo doslej. Kadar je treba, pa lahko uporabimo oklepaje."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(4 + 5) * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če ostane kak oklepaj odprt, Python dovoli, da nadaljujemo izraz v naslednji vrsti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(4 + 2 * (3\n",
    "+ 8)-\n",
    "2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tule ni lepo, a kdaj drugič nam bo prišlo še zelo prav, boste videli.\n",
    "\n",
    "Pri množenju je nujno uporabiti zvezdico. Se pravi, pisati moramo `7 * (2 + 3)` in ne `7(2 + 3)`.\n",
    "\n",
    "Za deljenje imamo poleg operatorja `/` tudi `//`, ki deli celoštevilsko."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4.5 // 1.2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 // 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.2 gre v 4.5 trikrat ... in še malo ostane. A celoštevilskega deljenja ostanek ne zanima.\n",
    "\n",
    "Pozornejšemu je padlo v oči še nekaj zanimivega: če delimo 4.5 z 1.2, dobimo 3.0, če delimo 7 z 2, pa 3. Python loči med celimi in necelimi števili. Rezultat deljenja necelih števil je necelo število; slučajno je ravno okroglo (3), vendar Python še vedno ve, da gre za število, ki bi lahko bilo necelo (čeprav slučajno ni). Rezultat celoštevilskega deljenja celih števil pa je celo število, zato ga Python tudi izpiše brez decimalk. Podobno je s seštevanjem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.3 + 1.7 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Če seštejemo realni števili 2.3 in 1.7 dobimo realno število 4.0. Če seštejemo celi števili 2 in 2, dobimo celo število 4.\n",
    "\n",
    "To, kar smo pravkar spoznali, so \"podatkovni tipi\". Točneje, spoznali smo dva podatkovna tipa *cela števila* in *števila s plavajočo vejico*. V angleščini se jima reče *integer* in *floating point number* v Pythonu pa `int` in `float`. V izvor teh čudnih imen se ne bomo poglabljali; s tem naj se ukvarjajo računalnikarji.\n",
    "\n",
    "Vsaka reč v Pythonu je reč nekega tipa, in če je ta reč število, je bodisi tipa `int` bodisi `float`. (So števila lahko še kakega drugega tipa? Lahko, nekateri jeziki imajo celo kupe številskih tipov. Vendar nas za zdaj ne brigajo.)\n",
    "\n",
    "Neučakanega študenta morda pograbila radovednost. Kateri podatkovni tipi pa še obstajajo - razen številskih? Le malo naj počaka, kmalu bodo na vrsti.\n",
    "\n",
    "Preden gremo naprej, samo opozorimo, da v večini drugih programskih jezikih deljenje celih števil vrača celo število, tako da je 7 / 2 enako 3 in ne 3.5. A pisci Pythona so se zato odločili, naj bo deljenje vedno \"pravilno\", kadar hočemo celoštevilsko, pa moramo to posebej povedati tako, da namesto `/` uporabimo `//`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Moj računalnik je lahko tudi kalkulator - s spominom\n",
    "\n",
    "Izračunali bomo, koliko je 2 + 3 in rekli računalniku, naj si to zapomni."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Temu, kar smo napisali tu, pravimo *prireditveni stavek*, saj smo z njim `x`-u priredili vrednost izraza 2+3.\n",
    "\n",
    "Da hočemo nekaj prirejati povemo z enačajem (očitno). Na njegovi desni je nek izraz - torej nekaj, kar se da izračunati. Včasih bo to `2 + 3`, včasih bo kaj veliko bolj zapletenega, včasih bo na desni strani samo številka, kot, recimo, v prirejanju `x = 42`. Python bo, tako kot v našem dosedanjem igranju z njim, izračunal tisto na desni in dobil `5` ali `42` ali karkoli že.\n",
    "\n",
    "Na levi strani enačaja je neko ime. Python bo temu imenu (recimo `x`) priredil tisto, kar je izračunal.\n",
    "\n",
    "OK? Prireditveni stavek priredi imenu na levi strani enačaja rezultat izraza na desni.\n",
    "\n",
    "Levo in desno od enačaja praviloma pišemo presledke, zaradi preglednosti.\n",
    "\n",
    "Python tokrat ni izpisal ničesar v odgovor. Rezultat si je le zapomnil, shranil ga je pod imenom `x`. Kaj lahko počnemo s tem `x`? Lahko ga uporabljamo v drugih izrazih."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "13 % x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kadar rečem `x`, Python poišče, tisto, kar je priredil `x`-u. Če smo `x`-u priredili 5 in rečemo `x + 7`, je to isto, kot če bi rekli `5 + 7`.\n",
    "\n",
    "Spremenljivko lahko seveda uporabljamo tudi za računanje novih spremenljivk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = x + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spremenljivka pri programiranju (v večini jezikov) ne pomeni istega kot v matematiki. Spremenljivke v matematiki se, roko na srce, pravzaprav ne spreminjajo. V matematiki *x* ne more biti v eni vrstici 5, v naslednji pa 8. Pri programiranju pa so spremenljivke v resnici spremenljive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še huje. Če matematiki ne bi znali programirati (pa navadno znajo in to dobro), bi jih utegnilo pretresti tole:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = x + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kako je *x* lahko enak *x+2*? Saj ni. Ta enačaj ne predstavlja enakosti, kot v matematiki, temveč prirejanje. V drugi vrstici Python izračuna vrednost izraza x + 2, to je, 7, in to priredi imenu, spremenljivki `x`. Izraz `x = x + 2` torej pomeni, preprosto, povečaj x za 2.\n",
    "\n",
    "Kakšna so lahko imena spremenljivk? Vedno le ena črka? Angleške abecede?\n",
    "\n",
    "Takole: imena so lahko poljubno dolga. Sestavljena so lahko iz črk angleške abecede, številk in podčrtaja, `_`, vendar se morajo začeti s črko ali podčrtajem, s številko pa ne. Python, kot skoraj vsi drugi jeziki, razlikuje med malimi in velikimi črkami: x in isto kot X. (V resnici smemo uporabljati tudi šumnike in kitajske pismenke, vendar se tega ne navadite, ker je nezaželeno in ker tega ne boste mogli početi v skoraj nobenem drugem jeziku kot v Pythonu, zato naj vam ne pride v kri.)\n",
    "\n",
    "Poleg tega pa obstaja še par dogovorov.\n",
    "\n",
    "- Podčrtaja praviloma ne dajemo na začetek; to storimo, kadar hočemo povedati nekaj posebnega. Kaj, bomo izvedeli veliko kasneje.\n",
    "- Prav tako ima nek poseben pomen, če začnemo spremenljivko z veliko črko.\n",
    "- Ime spremenljivke naj pove, kaj spremenljivka vsebuje, npr. `pospesek = 9.8`. Spremenljivke ne poimenujte `stevilka`, ceprav morda res vsebuje številko. Ko bomo začeli uporabljati sezname, vas bo veliko uporabljalo ime `seznam`, in če bodo v programu trije seznami, jih obste poimenovali `seznam1`, `seznam2`, `seznam3`. Da, to vam bo zelo pomagalo razumeti, kaj ste shranili kam. To je približno tako, kot če bi na knjigah pisalo \"Knjiga\" namesto, kaj je v njej. (Ni pa zelo drugače od steklenic v Mercatorju, na katerih preprosto piše \"Vino\".)\n",
    "- Včasih bo ime spremenljivke dolgo več besed. Ločimo jih s podčrtaji, na primer `visina_triglava = 2864`. Včasih boste videli tudi `visinaTriglava = 2864`. V Pythonu to ni zaželeno. `VisinaTriglava = 2864` pa sploh ne.\n",
    "- Po drugi strani bodo nepomembne spremenljivke, ki jih bomo potrebovali le v majhnem delčku programa, pogosto dolge en sam znak. S tem ni nič narobe. Pač pa se bomo v tem primeru izogiabli malemu l-ju, ki ga v nekaterih pisavah ne moremo ločiti od velikega i-ja in v drugih od enice.\n",
    "\n",
    "Vsi našteti dogovori (in še veliko podobnih bomo spoznali sproti) so samo dogovori. Če se jih ne držimo, bodo programi še vedno delovali. Pythonu je vseeno. Ni pa vseeno nam: če se držimo takšnih dogovorov, bodo naši programi preglednejši tako za nas, kot za druge, ki upoštevajo enaka pravila pisanja in bodo morali brati naše programe za nami."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Več vrstic v celici\n",
    "\n",
    "V celico s programsko kodo lahko napišemo tudi več vrstic. Jupyter bo kot rezultat izračuna izpisal rezultat zadnje vrstice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "y = x + 2\n",
    "y ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Poglavje polno napak\n",
    "\n",
    "\"Vsak, kdor dela, dela tudi napake,\" se je jež poklapano opravičil krtači. Čeprav nobenega omemba vrednega kosa programa, daljšega od, recimo, 20 vrstic, ne napišemo brez vsaj ene resne napake. Pravzaprav tudi jaz, ki sem kar usposobljen programer, večine časa ne preživim ob programiranju temveč ob iskanju napak v tem, kar sem pravkar sprogramiral. Začetni tečaji programiranja pa navadno ne posvečajo napakam nobene resne pozornosti. Tu te napake ne bomo ponovili, zato kar takoj naredimo nekaj napak.\n",
    "\n",
    "Postavimo, najprej, `a` na `7` in izračunajmo `a + b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'b' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-34-3ef3835d0b71>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'b' is not defined"
     ]
    }
   ],
   "source": [
    "a = 7\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kadar Python česa ne more storiti, izpiše sporočilo o napaki. Ko bomo programirali zares, bomo videli tudi daljša, ki jih bomo težje razumeli, tole pa je preprosto: `name 'b' is not defined`. Pozabili smo *definirati* `b`, pozabili smo mu dati vrednost.\n",
    "\n",
    "Kaj pa tole?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "can't assign to literal (<ipython-input-35-409be5c547e9>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-35-409be5c547e9>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    7 = a\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to literal\n"
     ]
    }
   ],
   "source": [
    "7 = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Človek, vajen matematike, bi si mislil, da je `a = 7` in `7 = a` eno in isto. V matematiki da, pri programiranju (v normalnih jezikih) pa ne, saj enačaj pomeni prirejanje; v prvem primeru priredimo `a`-ju 7, v drugem primeru pa hočemo sedmici prirediti `a`, kar seveda ne gre. To ima natanko toliko smisla, kot če bi napisali `1 = 2`. (Še več, Python nas bo po prstih celo, če bomo napisali `1 = 1`. Ena je ena, to bo ostala in se ne bo spremenila, niti v ena ne.) Sporočila o napaki tokrat ne razumemo povsem, saj ne vemo, kaj je \"literal\", osnovno sporočilo, \"can't assign\", pa je jasno.\n",
    "\n",
    "Pridelajmo še eno napako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "can't assign to keyword (<ipython-input-36-abb8adb6eb95>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-36-abb8adb6eb95>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    True = 12\u001b[0m\n\u001b[0m             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to keyword\n"
     ]
    }
   ],
   "source": [
    "True = 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beseda `True` ima poseben pomen in je ni mogoče uporabljati kot spremenljivko. Takšnim besedam pravimo ključne besede, ali, kot bi jim rekel John Kennedy, če bi bil še živ, *keywords*. Tokrat je bil Python še prijazen, pri večini drugih ključnih besed pa ne bo povedal kaj dosti več kot \"nekaj je narobe\". Poskusimo z dvema, `if` in `in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-37-9b6cbf7468bb>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-37-9b6cbf7468bb>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    if = 7\u001b[0m\n\u001b[0m       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "if = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-38-b1a7fdba72f5>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-38-b1a7fdba72f5>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    in = 7\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "in = 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sporočilo \"invalid syntax\" pomeni, da smo napisali nekaj tako čudnega, da Python ne more uganiti, kaj smo mislili in nam lahko le pokaže tisto mesto, na katerem je dokončno obupal nad nami.\n",
    "\n",
    "Morda je koga zaskrbelo, da nam bodo takšne, rezervirane besede v stalno napoto. Bi se dalo videti spisek? Ne bo hudega. Le dobrih 30 jih je in kmalu bomo poznali skoraj vse. Že od naslednje ure naprej vam ne bo prišlo na misel, da bi uporabili `if` kot ime spremenljivke in stavek `if = 1` vam bo videti grotesken."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Moj kalkulator ima tudi funkcije\n",
    "\n",
    "Tako kot spremenljivke, ki v programiranju ne pomenijo čisto istega kot v matematiki in v programiranju ne pomenijo čisto istega, tudi beseda *funkcija* ne pomeni povsem istega. Videti pa je zelo podobno. Imamo, recimo, funkcijo `abs`, ki izračuna absolutno vrednost števila."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.8"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-2.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ali pa `pow`, ki naredi isto kot operator `**`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za razliko od matematikov, ki na funkcijo gledajo kot da *ima določeno vrednost pri določenih parametrih*, računalnik *izračuna vrednost funkcije*, za kar moramo *poklicati funkcijo*. Se pravi, v zadnji vrstici smo *poklicali* funkcijo `pow` in ji *podali* dva *argumenta*, 2 in 3. Funkcija je izračunala vrednost in jo *vrnila*.\n",
    "\n",
    "Tudi klic funkcije, `pow(2, 3)`, je izraz. Kot katerikoli drugi izraz lahko tudi `pow` in `abs` nastopata kot del izraza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pow(2, 3) + 2) / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(2, 3) + abs(-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In argumenti funkcij so lahko prav tako izrazi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2\n",
    "yy = pow(abs(-2), x * 3)\n",
    "yy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funkcije so v resnici zelo pomembna reč. Python ima milijone in milijone funkcij (ne pretiravam, samo en detajl sem zamolčal). Za vsako reč, ki si jo zamislite, obstaja funkcija. Obstaja funkcija, ki bo, če jo pokličete, poslala mail osebi, katere naslov podate kot argument in z vsebino, ki jo podate kot argument. Obstaja funkcija, ki izriše ali pokaže sliko. Funkcija, ki odpre Excel in funkcija, ki piše po njem. S Pythonom lahko naredimo karkoli, le ime funkcije moramo poznati. (Kot rečeno, izpuščam detajle.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nizi\n",
    "\n",
    "Nas še vedno muči radovednost o tem, kakšne podatkovne tipe, poleg številskih, še imamo? Ker radovednost ni lepa čednost, jo bomo najlažje odpravili tako, da jo potešimo. Vsaj malo. (\"Skušnjavo najlažje premagaš tako, da ji podležeš,\" je modroval Oscar Wilde.) Spoznajmo vsaj še en bolj zapleten podatkovni tip: niz.\n",
    "\n",
    "Niz ali, po kot mu pravijo Avstralci, *string* (oprostite mi boste morali, da bom pogosto uporabljal angleške izraze; pa mi pokažite, lepo prosim, zidarja, ki ne uporablja vaservage in plajbe temveč vodno tehtnico in svinčnico, pa se bom tudi jaz popravil), je zaporedje znakov. Aha, kaj pa je to znak? Znaki so črke, številke, ločila in take stvari. Nize moramo vedno zapreti v narekovaje, bodisi enojne (') bodisi dvojne (\"). Uporabiti smemo take, ki so bolj praktični in tudi Python bo izpisoval tako, kot se mu bo zdelo bolj praktično."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tole je primer niza.'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Tole je primer niza.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tole je pa še en primer niza.'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Tole je pa še en primer niza.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No, vidite, tudi ko smo niz zaprli v dvojne narekovaje, je Python izpisal enojne. V resnici mu je vseeno.\n",
    "\n",
    "Tudi nize lahko priredimo spremenljivkam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jutri bo oblačno in dež'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "napoved = \"Jutri bo oblačno z dežjem\"\n",
    "napoved"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Celo seštevamo jih lahko."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jutri bo oblačno z dežjem'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Jutri bo \" + \"oblačno\" + \" z \" + \"dežjem\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ali pa oboje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Jutri bo oblačno z dežjem'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "napoved_zac = \"Jutri bo \"\n",
    "oblaki = \"oblačno\"\n",
    "padavine = \"dežjem\"\n",
    "napoved_zac + oblaki + \" z \" + padavine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kako zapleten račun! Predvsem ne spreglejte, da smo dali besedo \"z\" pod narekovaje, saj so `napoved_zac`, `oblaki` in `padavine` spremenljivke (vrste nizi), `\" z \"` pa je niz kar tako. To je nekako tako, kot če bi, ko smo se igrali s številkami, pisali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "y = 3\n",
    "x + 2 + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V zadnji vrstici sta `x` in `y` sta spremenljivki (vrste `int`), `2` pa je številka kar tako.\n",
    "\n",
    "Kaj pa, če bi slučajno pozabili narekovaje?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'z' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-53-57b8a595088d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnapoved_zac\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0moblaki\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mz\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mpadavine\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'z' is not defined"
     ]
    }
   ],
   "source": [
    "napoved_zac + oblaki + z + padavine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jasno? Brez narekovajev je `z` ime spremenljivke - in to takšne, ki še ni definirana. To je tako, kot če bi namesto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "ime = \"Benjamin\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "rekli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Benjamin' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-55-149e124aca6f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mime\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBenjamin\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'Benjamin' is not defined"
     ]
    }
   ],
   "source": [
    "ime = Benjamin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seveda pa lahko (z malim prekrškom enega pravila - katerega že?):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'otrok solza'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Benjamin = \"otrok solza\"\n",
    "ime = Benjamin\n",
    "ime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jasno? Prvič imamo spremenljivko `Benjamin`, drugič pa niz, v katerem je besedilo Benjamin. Ko ni narekovajev, imamo spremenljivko, ko so, pa niz.\n",
    "\n",
    "Zakaj pa smo prejle rekli, da uporabimo tiste narekovaje, ki so bolj *praktični*? Čemu bi bili kakšni narekovaji bolj praktični od drugih?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-57-e7b97c04099d>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-57-e7b97c04099d>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    \"Cesar vpraša nekoliko nevoljen: \"Kaj neki?\"\"\u001b[0m\n\u001b[0m                                        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "\"Cesar vpraša nekoliko nevoljen: \"Kaj neki?\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ni potrebno biti posebno pameten, da vidimo, kaj ga je (namreč Pythona, ne cesarja) onesrečilo tokrat. Ko vidi prvi narekovaj, ve, da gre za niz. Ko pride do naslednjega narekovaja, se niz, tako méni, niz konča. In potem se seveda zmede, ker nizu sledi nekaj, kar ni podobno ničemur. Zdaj pa poskusimo z enojnimi narekovaji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cesar vpraša nekoliko nevoljen: \"Kaj neki?\"'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Cesar vpraša nekoliko nevoljen: \"Kaj neki?\"'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ker se niz začne z enojnim narekovajem, se bo s takim tudi končal in vsi dvojni narekovaji znotraj niza so samo znaki kot katerikoli drugi - tako kot recimo dvopičje in vprašaj. O tej temi bi lahko napisali še marsikaj, vendar se za zdaj ustavimo.\n",
    "\n",
    "\n",
    "## Iz nizov v števila\n",
    "\n",
    "Da se reč usede, meditirajmo ob naslednjih vrsticah:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1 + 1\n",
    "b = \"1 + 1\"\n",
    "c = \"1\" + \"1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kakšne so po tem vrednosti spremenljivk `a`, `b` in `c`? Sploh pa, je vse troje legalno ali pa bo Python spet kaj stokal?\n",
    "\n",
    "V prvo nimamo dvomov, vrednost `a` mora biti enaka 2 (in tudi je). Drugo? `\"1 + 1\"` je niz; spremenljivki `b` smo priredili niz `\"1 + 1\"`, torej vsebuje ta niz. In ne niza 2? Ne, nihče mu ni naročil, naj poskuša izračunati, koliko je 1 + 1, tako kot pravzprav tudi v `ime = \"Benjamin\"` ne poskuša izračunati, \"koliko\" je Benjamin. `\"1 + 1\"` je niz, kot vsak drugi, čeprav je slučajno podoben računu.\n",
    "\n",
    "Najbolj zanimivo je tretje. Preden razrešimo vprašanje, se vprašajmo nekaj drugega. Recimo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "ana = \"Ana\"\n",
    "benjamin = \"Benjamin\"\n",
    "r = ana + benjamin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaj dobimo, če seštejemo Ano in Benjamina. (Tončka? Brez duhovičenja, to so resne reči.) Spremenljivka `r` bo imela vrednost `\"AnaBenjamin\"`. (Ako kdo misli, da bomo dobili `\"Benjamin Ana\"`, saj smo tudi poprej imeli presledke ob oni študijsko-vremenski napovedi, naj pozorno pregleda, kaj smo pisali ondi: vse presledke smo napisali sami.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AnaBenjamin'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No, potem pa vemo: ko seštejemo *niza* `\"1\"` in `\"1\"` dobimo niz `\"11\"`.\n",
    "\n",
    "Nikar ne zamudimo priložnosti za še eno napako!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-63-b780703cc5f9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"1\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "1 + \"1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seštevanje je operacija, zato tistemu, kar je levo in desno od `+` pravimo operanda. Sporočilo pravi, da operator `+` ne podpira operandov tipov `int` in `str` (`str` je\n",
    "podatkovni tip, ki predstavlja nize). Dve števili ali dva niza bi znal sešteti, te kombinacije pa ne. Mimogrede, obratni vrstni red da nekoliko drugačno sporočilo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-64-ec358fc6499a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"1\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "\"1\" + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na to napako boste pogosto naleteli, tako da bodite pripravljeni.\n",
    "\n",
    "Ker nam bo prišlo vsak čas prav, povejmo, kako iz niza dobimo število. Recimo, torej, da imamo `a = \"1\"` in `b = \"2\"`. Radi bi ju sešteli - vendar zares, tako da bomo dobili 3, ne \"12\". Za to ju moramo najprej (ali pa sproti) spremeniti v števili. Iz niza dobimo število tako, da pokličemo \"funkcijo\" `int` ali `float`; obe funkciji pričakujeta kot argument niz, ki vsebuje neko število in kot rezultat vrneta celo (`int`) ali realno (`float`)\n",
    "število. (Tole bi se spodobilo in bilo pravično povedati: `int` in `float` v resnici nista funkciji, temveč nekaj drugega, a za potrebe teh predavanj, se bomo držali Pythonovega načela \"Če hodi kot raca in gaga kot raca, potem je raca\", ki bo postalo pomembno proti koncu semestra; če se obnašata kot funkciji, ju bomo brez slabe vesti oklicali za funkciji.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"42\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(\"42\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kar želimo, storimo na tri načine, vsak bo poučen po svoje. Prvi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"1\"\n",
    "b = \"2\"\n",
    "\n",
    "aa = int(a)\n",
    "bb = int(b)\n",
    "aa + bb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naredili smo dve novi spremenljivki, `aa` in `bb`, ki vsebujeta vrednosti `a` in `b`, pretvorjeni v števila. Nato ju seštejemo.\n",
    "\n",
    "Drugi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"1\"\n",
    "b = \"2\"\n",
    "\n",
    "a = int(a)\n",
    "b = int(b)\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tole je podobno kot prej, le da smo povozili stare vrednosti `a` in `b` z novimi, številskimi, namesto da bi števila zapisovali v druge spremenljivke.\n",
    "\n",
    "Tretji:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"1\"\n",
    "b = \"2\"\n",
    "\n",
    "int(a) + int(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vpis in izpis\n",
    "\n",
    "Doslej smo rezultate izračunov dobili tako, da smo v zadnji vrstici celice zapisali izraz ali ime spremenljivke, katere vrednost nas je zanimala. Pogosto pa bomo želeli kaj izpisati med računanjem, ali pa bomo hoteli, da celica izpiše več stvari. Nekoč bomo morda pisali tudi \"prave\" programe, ki jih ne bomo izvajali v Jupytru.\n",
    "\n",
    "Če hočemo, da računalnik kaj izpiše, mu moramo to posebej reči: namesto, da napišemo le `1 + 1` (v zadnji vrstici celice), bomo rekli \"izpiši, koliko je 1 + 1\".\n",
    "\n",
    "Povedali smo, da funkcije pri programiranju niso nekaj takšnega kot funkcije v matematiki: funkcije v matematiki imajo določeno vrednost pri določenih argumentih (še huje, matematiki pravijo, da so funkcije pravilo, ki vsakemu elementu kodomene funkcije določi ... uh, pustimo). \"Naše\" funkcije pa nekaj delajo in včasih vrnejo kakšen rezultat, recimo številko ali niz ali kaj tretjega. Ena od teh funkcij je namenjena izpisovanju: če jo pokličemo, izpiše tisto, kar smo ji dali kot argument. Imenuje se `print`. Za razliko od, recimo, `abs`, ki zahteva en argument, namreč poljubno število, in vrne njegovo absolutno vrednost, ali `pow`, ki hoče natanko dva argumenta, lahko damo `print`u poljubno število argumentov - številke, nize ali še kaj tretjega -, pa jih bo lepo izpisala."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 27 benjamin\n"
     ]
    }
   ],
   "source": [
    "print(1 + 1, 27, \"benjamin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jutri bo  oblačno z dežjem\n"
     ]
    }
   ],
   "source": [
    "print(napoved_zac, oblaki, \"z\", padavine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Med reči, ki jih izpiše, bo `print`, če ne zahtevamo drugače, postavil presledke.\n",
    "\n",
    "Druga funkcija, ki nam bo prišla prav, prosi uporabnika, da vpiše kako reč. Kot argument pričakuje niz, vprašanje, ki ga želimo zastaviti uporabniku. Kot rezultat \"izračuna\" vrne niz, ki ga je vpisal uporabnik."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Geslo? blabla\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'blabla'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "geslo = input(\"Geslo? \")\n",
    "geslo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(V drugi vrstici se geslo, `FR1.ru135`, ne izpiše, temveč ga tipka uporabnik.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Primer: pretvarjanje temperatur\n",
    "\n",
    "Sestavimo tole: računalnik naj uporabnika prosi za temperaturo v Celzijevih\n",
    "stopinjah in računalnik mu bo izpisal, koliko je to v Kelvinih in koliko v\n",
    "Fahrenheitih. Iz Celzijev dobimo Kelvine tako, da jim prištejemo 273.15,\n",
    "Fahrenheite pa tako, da jih pomnožimo z 9/5 in prištejemo 32 (kogar zanima\n",
    "še kaj, naj pogleda na [Wikipedijo](http://en.wikipedia.org/wiki/Conversion_of_units_of_temperature)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperatura [C]? 35\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "must be str, not float",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-78-1f38fa372baf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtemp_C\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Temperatura [C]? \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mtemp_K\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtemp_C\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m273.15\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not float"
     ]
    }
   ],
   "source": [
    "temp_C = input(\"Temperatura [C]? \")\n",
    "temp_K = temp_C + 273.15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Eh.* Funkcija `input` vrne *niz*, ki ga je vpisal uporabnik. Četudi utegne ta izgledati kot številka, je še vedno niz in k nizom ni mogoče prištevati števil. Kot smo videli, lahko storimo troje: naredimo novo spremenljivko, na primer, `temp_Cf = float(temp_C)`, povozimo staro s `temp_Cf = float(temp_C)` ali pa pretvorbo opravimo kar sproti, tako da računamo `temp_K = float(temp_C) + 273.15`. Izmed naštetih možnosti se odločimo za četrto in niz pretvorimo, čim ga uporabnik vpiše. Ponovimo torej vso vajo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperatura [C]? 35\n",
      "35.0 C je enako 308.15 ali 51.44444444444444\n"
     ]
    }
   ],
   "source": [
    "temp_C = float(input(\"Temperatura [C]? \"))\n",
    "temp_K = temp_C + 273.15\n",
    "temp_F = temp_C * 5/9 + 32\n",
    "print(temp_C, \"C je enako\", temp_K, \"K ali\", temp_F, \"F\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Izpis v zadnji vrstici lahko poenostavimo. Če pred narekovaj niza dodamo črko `f`, lahko znotraj niza v zavite oklepaje vstavimo imena spremenljivk ali kar cele izraze. Python jih bo izračunal in rezultat vstavil na ustrezno mesto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.0 C je enako 308.15 ali 51.44444444444444\n"
     ]
    }
   ],
   "source": [
    "print(f\"{temp_C} C je enako {temp_K} ali {temp_F}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pravi program\n",
    "\n",
    "Vse, kar smo počeli doslej, vključno s tem zgoraj, je kramljanje z računalnikom, To ni pravi program. \"Pravi program\" je nekaj, kar poženeš in te vpraša, kar te ima vprašati ter izpiše, kar ima izpisati.\n",
    "\n",
    "Odprimo Notepad ali Sublime ali Visual Studio Code ali emacs ali vi ... približno katerikoli urejevalnik besedil, razen Worda. Še preprosteje: vrnimo se na stran v Jupytru, ki kaže direktorij, in naredimo novo datoteko, ki ne bo vrste Python 3 temveč Text File. Poimenujmo ga temperature.py. Vanj skopiramo gornje štiri vrstice in ga shranimo s File / Save.\n",
    "\n",
    "Zdaj v ukazni vrstici vpišemo `python temperature.py` (oziroma `python3 temperature.py`, če se na računalniku, s katerim delamo, `python` nanaša na različico 2 in ne 3). Python bo izvedel program v datoteki temperature.py, vrstico za vrstico, kot da bi izvajal celico."
   ]
  }
 ],
 "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
}