Predavanje 01 - Uvod v Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "<font size=\"2\"> [github.com/jankoslavic/pypinm](http://github.com/jankoslavic/pypinm)</font>\n",
    "\n",
    "[Prof. dr. Janko Slavič](http://www.ladisk.si/~slavic)\n",
    "\n",
    "<center>\n",
    "<img width=300 src=\"./fig/ladisk.png\">\n",
    "<br>\n",
    "<font size=\"7\" color=\"f00e0e\" face=\"garamond\"><b>Uvod v Python</b></font>\n",
    "<img src=\"\">\n",
    "<font size=\"2\">September 2021</font>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "toc": "true"
   },
   "source": [
    "<h1>Kazalo<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Uvod\" data-toc-modified-id=\"Uvod-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Uvod</a></span><ul class=\"toc-item\"><li><span><a href=\"#Kaj-je-ekosistem-Pythona?\" data-toc-modified-id=\"Kaj-je-ekosistem-Pythona?-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Kaj je ekosistem Pythona?</a></span></li></ul></li><li><span><a href=\"#Kdo-se-uči-Python,-zakaj-ga-uporabljati?\" data-toc-modified-id=\"Kdo-se-uči-Python,-zakaj-ga-uporabljati?-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Kdo se uči Python, zakaj ga uporabljati?</a></span><ul class=\"toc-item\"><li><span><a href=\"#Uporaba-Pythona?\" data-toc-modified-id=\"Uporaba-Pythona?-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Uporaba Pythona?</a></span></li><li><span><a href=\"#Python-vs-Matlab\" data-toc-modified-id=\"Python-vs-Matlab-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Python vs Matlab</a></span></li></ul></li><li><span><a href=\"#Namestitev-Pythona\" data-toc-modified-id=\"Namestitev-Pythona-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Namestitev Pythona</a></span><ul class=\"toc-item\"><li><span><a href=\"#Uporaba-githuba-repozitorija-in-posodobitve\" data-toc-modified-id=\"Uporaba-githuba-repozitorija-in-posodobitve-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Uporaba githuba repozitorija in posodobitve</a></span></li><li><span><a href=\"#Visual-Studio-Code\" data-toc-modified-id=\"Visual-Studio-Code-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Visual Studio Code</a></span></li><li><span><a href=\"#Nameščanje-dodatkov-in-posodobitev\" data-toc-modified-id=\"Nameščanje-dodatkov-in-posodobitev-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Nameščanje dodatkov in posodobitev</a></span></li></ul></li><li><span><a href=\"#Jupyter-notebook-(Jupyter-lab)\" data-toc-modified-id=\"Jupyter-notebook-(Jupyter-lab)-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Jupyter notebook (Jupyter lab)</a></span><ul class=\"toc-item\"><li><span><a href=\"#Markdown\" data-toc-modified-id=\"Markdown-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Markdown</a></span></li></ul></li><li><span><a href=\"#Prvi-program-in-PEP\" data-toc-modified-id=\"Prvi-program-in-PEP-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Prvi program in PEP</a></span><ul class=\"toc-item\"><li><span><a href=\"#PEP---Python-Enhancements-Proposal\" data-toc-modified-id=\"PEP---Python-Enhancements-Proposal-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>PEP - Python Enhancements Proposal</a></span><ul class=\"toc-item\"><li><span><a href=\"#PEP8\" data-toc-modified-id=\"PEP8-5.1.1\"><span class=\"toc-item-num\">5.1.1&nbsp;&nbsp;</span>PEP8</a></span></li><li><span><a href=\"#PEP20\" data-toc-modified-id=\"PEP20-5.1.2\"><span class=\"toc-item-num\">5.1.2&nbsp;&nbsp;</span>PEP20</a></span></li></ul></li></ul></li><li><span><a href=\"#Osnove-Pythona\" data-toc-modified-id=\"Osnove-Pythona-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Osnove Pythona</a></span><ul class=\"toc-item\"><li><span><a href=\"#Osnovni-podatkovni-tipi-in-operatorji\" data-toc-modified-id=\"Osnovni-podatkovni-tipi-in-operatorji-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span>Osnovni podatkovni tipi in operatorji</a></span><ul class=\"toc-item\"><li><span><a href=\"#Dinamično-tipiziranje\" data-toc-modified-id=\"Dinamično-tipiziranje-6.1.1\"><span class=\"toc-item-num\">6.1.1&nbsp;&nbsp;</span>Dinamično tipiziranje</a></span></li><li><span><a href=\"#Logični-operatorji\" data-toc-modified-id=\"Logični-operatorji-6.1.2\"><span class=\"toc-item-num\">6.1.2&nbsp;&nbsp;</span>Logični operatorji</a></span></li><li><span><a href=\"#Primerjalni-operatorji\" data-toc-modified-id=\"Primerjalni-operatorji-6.1.3\"><span class=\"toc-item-num\">6.1.3&nbsp;&nbsp;</span>Primerjalni operatorji</a></span></li><li><span><a href=\"#Podatkovni-tipi-za-numerične-vrednosti\" data-toc-modified-id=\"Podatkovni-tipi-za-numerične-vrednosti-6.1.4\"><span class=\"toc-item-num\">6.1.4&nbsp;&nbsp;</span>Podatkovni tipi za numerične vrednosti</a></span></li><li><span><a href=\"#Operatorji-numeričnih-vrednosti\" data-toc-modified-id=\"Operatorji-numeričnih-vrednosti-6.1.5\"><span class=\"toc-item-num\">6.1.5&nbsp;&nbsp;</span>Operatorji numeričnih vrednosti</a></span></li><li><span><a href=\"#Operatorji-na-nivoju-bitov\" data-toc-modified-id=\"Operatorji-na-nivoju-bitov-6.1.6\"><span class=\"toc-item-num\">6.1.6&nbsp;&nbsp;</span>Operatorji na nivoju bitov</a></span></li></ul></li><li><span><a href=\"#Sestavljene-podatkovne-strukture\" data-toc-modified-id=\"Sestavljene-podatkovne-strukture-6.2\"><span class=\"toc-item-num\">6.2&nbsp;&nbsp;</span>Sestavljene podatkovne strukture</a></span><ul class=\"toc-item\"><li><span><a href=\"#Niz-(string)\" data-toc-modified-id=\"Niz-(string)-6.2.1\"><span class=\"toc-item-num\">6.2.1&nbsp;&nbsp;</span>Niz (string)</a></span></li><li><span><a href=\"#Terka-(tuple)\" data-toc-modified-id=\"Terka-(tuple)-6.2.2\"><span class=\"toc-item-num\">6.2.2&nbsp;&nbsp;</span>Terka (tuple)</a></span></li><li><span><a href=\"#Seznam-(list)\" data-toc-modified-id=\"Seznam-(list)-6.2.3\"><span class=\"toc-item-num\">6.2.3&nbsp;&nbsp;</span>Seznam (list)</a></span><ul class=\"toc-item\"><li><span><a href=\"#Izbrane-operacije-nad-seznami\" data-toc-modified-id=\"Izbrane-operacije-nad-seznami-6.2.3.1\"><span class=\"toc-item-num\">6.2.3.1&nbsp;&nbsp;</span>Izbrane operacije nad seznami</a></span></li><li><span><a href=\"#Zakaj-uporabiti-terko-in-ne-seznama?\" data-toc-modified-id=\"Zakaj-uporabiti-terko-in-ne-seznama?-6.2.3.2\"><span class=\"toc-item-num\">6.2.3.2&nbsp;&nbsp;</span>Zakaj uporabiti terko in ne seznama?</a></span></li></ul></li><li><span><a href=\"#Množice-(Sets)\" data-toc-modified-id=\"Množice-(Sets)-6.2.4\"><span class=\"toc-item-num\">6.2.4&nbsp;&nbsp;</span>Množice (Sets)</a></span></li><li><span><a href=\"#Slovar-(dictionary)\" data-toc-modified-id=\"Slovar-(dictionary)-6.2.5\"><span class=\"toc-item-num\">6.2.5&nbsp;&nbsp;</span>Slovar (dictionary)</a></span></li><li><span><a href=\"#Operacije-nad-sestavljenimi-podatkovnimi-strukturami\" data-toc-modified-id=\"Operacije-nad-sestavljenimi-podatkovnimi-strukturami-6.2.6\"><span class=\"toc-item-num\">6.2.6&nbsp;&nbsp;</span>Operacije nad sestavljenimi podatkovnimi strukturami</a></span></li><li><span><a href=\"#Štetje-in-rezanje-sestavljenih-podatkovnih-struktur\" data-toc-modified-id=\"Štetje-in-rezanje-sestavljenih-podatkovnih-struktur-6.2.7\"><span class=\"toc-item-num\">6.2.7&nbsp;&nbsp;</span>Štetje in rezanje sestavljenih podatkovnih struktur</a></span></li></ul></li><li><span><a href=\"#Kontrola-toka-programa\" data-toc-modified-id=\"Kontrola-toka-programa-6.3\"><span class=\"toc-item-num\">6.3&nbsp;&nbsp;</span>Kontrola toka programa</a></span><ul class=\"toc-item\"><li><span><a href=\"#Stavek-if\" data-toc-modified-id=\"Stavek-if-6.3.1\"><span class=\"toc-item-num\">6.3.1&nbsp;&nbsp;</span>Stavek <code>if</code></a></span></li><li><span><a href=\"#Izraz-if\" data-toc-modified-id=\"Izraz-if-6.3.2\"><span class=\"toc-item-num\">6.3.2&nbsp;&nbsp;</span>Izraz <code>if</code></a></span></li><li><span><a href=\"#Zanka-while\" data-toc-modified-id=\"Zanka-while-6.3.3\"><span class=\"toc-item-num\">6.3.3&nbsp;&nbsp;</span>Zanka <code>while</code></a></span></li><li><span><a href=\"#Zanka-for\" data-toc-modified-id=\"Zanka-for-6.3.4\"><span class=\"toc-item-num\">6.3.4&nbsp;&nbsp;</span>Zanka <code>for</code></a></span></li><li><span><a href=\"#Funkcija-zip\" data-toc-modified-id=\"Funkcija-zip-6.3.5\"><span class=\"toc-item-num\">6.3.5&nbsp;&nbsp;</span>Funkcija <code>zip</code></a></span></li><li><span><a href=\"#Funkcija-range\" data-toc-modified-id=\"Funkcija-range-6.3.6\"><span class=\"toc-item-num\">6.3.6&nbsp;&nbsp;</span>Funkcija <code>range</code></a></span></li><li><span><a href=\"#Funkcija-enumerate\" data-toc-modified-id=\"Funkcija-enumerate-6.3.7\"><span class=\"toc-item-num\">6.3.7&nbsp;&nbsp;</span>Funkcija <code>enumerate</code></a></span></li></ul></li></ul></li><li><span><a href=\"#Za-konec:-plonk-list-:)\" data-toc-modified-id=\"Za-konec:-plonk-list-:)-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Za konec: plonk list :)</a></span></li><li><span><a href=\"#Nekaj-vprašanj-za-razmislek!\" data-toc-modified-id=\"Nekaj-vprašanj-za-razmislek!-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Nekaj vprašanj za razmislek!</a></span><ul class=\"toc-item\"><li><span><a href=\"#Vključevanje-lokalnega-video-posnetka-s-transformacijami\" data-toc-modified-id=\"Vključevanje-lokalnega-video-posnetka-s-transformacijami-8.1\"><span class=\"toc-item-num\">8.1&nbsp;&nbsp;</span>Vključevanje lokalnega video posnetka s transformacijami</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Uvod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Kaj je ekosistem Pythona?\n",
    "\n",
    "Marsikaterega bralca beseda *ekosistem* zmoti/zmede. [Slovar slovenskega knjižnega jezika](http://www.fran.si/130/sskj-slovar-slovenskega-knjiznega-jezika/3539971/ekosistem?page=4&Query=sistem&All=sistem&FilteredDictionaryIds=130&View=1) danes pozna samo rabo v povezavi z ekologijo. V računalništvu pa se v zadnjih desetletjih beseda ekosistem uporablja tudi v kontekstu t. i. digitalnega ekosistema; v primeru Pythona to pomeni vso množico različih paketov (samo [pypi.org](https://pypi.org) trenutno hrani več kot 330 tisoč različnih paketov), ki temeljijo na programskem jeziku Python in so med seboj povezani."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Ekosistem Pythona je veliko več kot pa samo programski jezik Python!** Ta knjiga se v okviru prvih štirih predavanj osredotoča na tisti del tega ekosistema, ki je zanimiv in koristen predvsem za inženirske poklice. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python je **visokonivojski** programski jezik, z visokim nivojim abstrakcije. **Nizkonivojski** programski jeziki, v nasprotju, imajo nizek nivo abstrakcije (npr. strojna koda).\n",
    "\n",
    "Poglemo si izračun [Fibonaccijevega števila](http://sl.wikipedia.org/wiki/Fibonaccijevo_%C5%A1tevilo), ki sledi definiciji: \n",
    "$$F_1 = F_2 = 1\\qquad\\textrm{in}\\qquad F_n = F_{n-1} + F_{n-2}.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Izračun $F_n$ v [strojni kodi](http://en.wikipedia.org/wiki/Low-level_programming_language):\n",
    "<img width=400 src=\"./fig/strojna_koda.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "MASM koda\n",
    "<img width=400 src=\"./fig/mash_koda.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "C\n",
    "```c\n",
    "int Fibonacci(int n)\n",
    "{\n",
    "   if ( n == 0 )\n",
    "      return 0;\n",
    "   else if ( n == 1 )\n",
    "      return 1;\n",
    "   else\n",
    "      return ( Fibonacci(n-1) + Fibonacci(n-2) );\n",
    "} \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python\n",
    "```python\n",
    "def fib(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 10]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "števila = [1, 2, 3, 4, 5] # seznam števil\n",
    "[število*2 for število in števila if število>3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python omogoča visok nivo abstrakcije in zato abstraktno kodo. Sedaj si bomo pogledali primer kode Python:\n",
    "```python\n",
    "števila = [1, 2, 3, 4, 5] # seznam števil\n",
    "[število for število in števila if število%2]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Čeprav v tem trenutku še nimamo dovolj znanja, poskusimo razumeti/prebrati:\n",
    "\n",
    "1. prva vrstica definira seznam števil; vse kar sledi znaku # pa predstavlja komentar\n",
    "\n",
    "2. rezultat druge vrstice je seznam, kar definirata oglata oklepaja; znotraj oklepaja beremo:\n",
    "\n",
    "    * vrni `število` za vsako (**for**) `število` v (**in**) seznamu `števila`, če (**if**) je pri deljenju `število` z 2 ostanek 1. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Vidimo, da je nivo abstrakcije res visok, saj smo potrebovali veliko besed, da smo pojasnili vsebino!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Poglejmo rezultat:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "števila = [1, 2, 3, 4, 5] # seznam števil\n",
    "[število for število in števila if število%2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Kratek pregled začetkov nekaterih programskih jezikov:\n",
    "* 1957 Fortran, * 1970 Pascal, * 1972 C\n",
    "* 1980 C++, * 1984 Matlab, * 1986 Objective-C\n",
    "* **1991 Python**, * 1995 Java, * 1995 Delphi\n",
    "* 2009 Go, 2012 Julija"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Kdo se uči Python, zakaj ga uporabljati?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**ZDA** \n",
    "\n",
    "[Python je jezik, ki se ga najpogosteje učijo na najboljših Ameriških univerzah.](http://goo.gl/mJC1P8)\n",
    "<img width=400 src=\"./fig/Top39-700.4.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Na univerzi Berkeley v [začetku študijskega leta 2017/18](https://youtu.be/xuNj5paMuow?t=13m18s) (več kot 1200 študentov pri predmetu *Data science*, ki temelji na tehnologiji Jupyter notebook)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">First day of class in Foundations of <a href=\"https://twitter.com/hashtag/Datascience?src=hash\">#Datascience</a> for <a href=\"https://twitter.com/BerkeleyDataSci\">@BerkeleyDataSci</a> - all materials at <a href=\"https://t.co/yyoJbaKlnL\">https://t.co/yyoJbaKlnL</a> <a href=\"https://t.co/J6DLd0VQTl\">pic.twitter.com/J6DLd0VQTl</a></p>&mdash; Cathryn Carson (@CathrynCarson) <a href=\"https://twitter.com/CathrynCarson/status/900408152348270592\">August 23, 2017</a></blockquote>\n",
       "<script async src=\"//platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">First day of class in Foundations of <a href=\"https://twitter.com/hashtag/Datascience?src=hash\">#Datascience</a> for <a href=\"https://twitter.com/BerkeleyDataSci\">@BerkeleyDataSci</a> - all materials at <a href=\"https://t.co/yyoJbaKlnL\">https://t.co/yyoJbaKlnL</a> <a href=\"https://t.co/J6DLd0VQTl\">pic.twitter.com/J6DLd0VQTl</a></p>&mdash; Cathryn Carson (@CathrynCarson) <a href=\"https://twitter.com/CathrynCarson/status/900408152348270592\">August 23, 2017</a></blockquote>\n",
    "<script async src=\"//platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python v zadnjih 10 letih pospešeno pridobiva na popularnosti in je danes eden od najboljših ([IEEE Spectrum](https://spectrum.ieee.org/top-programming-languages/#toggle-gdpr).) in tudi najpopularnejših programskih jezikov ([Why is Python Growing so Quickly?](https://stackoverflow.blog/2017/09/14/python-growing-quickly/) in [Python's explosive growth](https://www.techrepublic.com/article/programming-languages-pythons-growth-is-absolutely-explosive-says-anaconda-ceo-and-not-slowing-down/))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Slovenija**\n",
    "\n",
    "* FRI: [Programiranje 1](https://ucilnica.fri.uni-lj.si/course/view.php?id=166)\n",
    "* FMF: Naloge na [www.projekt-tomo.si](https://www.projekt-tomo.si), poiščite: Prvi koraki v Python, Drugi koraki v Python, Python za začetnike\n",
    "\n",
    "**FS**\n",
    "\n",
    "* [Numerične metode](http://lab.fs.uni-lj.si/ladisk/?what=incfl&flnm=NM.php)\n",
    "* [Programiranje in numerične metode](http://lab.fs.uni-lj.si/ladisk/?what=incfl&flnm=PiNM.php)\n",
    "* [Poletna šola HPC](http://hpc.fs.uni-lj.si/python-intro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Uporaba Pythona?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nekatera mednarodna podjetja: *Nasa, Google, Cern*.\n",
    "\n",
    "Nekatera podjetja v Sloveniji: *Kolektor, Iskra Mehanizmi, Hidria, Mahle, Domel, ebm-papst Slovenia, Cimos, Eti.*\n",
    "\n",
    "Nekateri programi, ki imajo vgrajeno skriptno podporo za Python: *Abaqus, Ansys Workbench, MSC (Adams, SimXpert), ParaView, LMS Siemens, AVL.*\n",
    "\n",
    "Nekateri komercialni programi v Pythonu:  *BitTorrent, Dropbox.*\n",
    "\n",
    "Obširni seznam je [tukaj](http://en.wikipedia.org/wiki/List_of_Python_software)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python vs Matlab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ker ni bilo boljše možnosti, je bil v preteklosti na področju strojništva bolj popularen Matlab; Matlab je še vedno močno orodje, vendar je danes ekosistem Pythona za večino opravil  bistveno močnejše orodje. Na spletu boste našli ogromno primerjav, npr.: [Python vs Matlab](http://www.pyzo.org/python_vs_matlab.html).\n",
    "\n",
    "Kratka primerjave glede na [vir](http://www.southampton.ac.uk/~fangohr/training/python/pdfs/Python-for-Computational-Science-and-Engineering-slides.pdf):\n",
    "\n",
    "<img width=500 src=\"./fig/py_comparison.png\">\n",
    "\n",
    "Sintaksa je načeloma zelo podobna. Pomembna razlika je, da se indeksi pri **Matlabu** začnejo z 1, v **Pythonu** pa z 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Če ste mlajši od 25-30 let, preostanek te celice verjetno lahko preskočite.\n",
    "\n",
    "Če niste, ste se verjetno učili Matlab in se sprašujete zakaj je v vašem klubu čedalje manj članov. Verjetno je čas za prehod na Python; tukaj prispevek, ki vam lahko pomaga: [MATLAB vs Python: Why and How to Make the Switch](https://realpython.com/matlab-vs-python/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Namestitev Pythona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pojdite na [www.anaconda.com](https://www.anaconda.com/download/) ter namestite *Anaconda* distribucijo Pythona; *pazite, da izberete verzijo 3.8 ali novejšo* (64 bit). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pripravili smo [video navodila](https://www.youtube.com/watch?v=Cp-IuyN67rQ), ključni poudarki so:\n",
    "\n",
    "* namestitev distribucije Anaconda,\n",
    "* obkljujkajte, da bo Visual Studio Code (pojasnjen spodaj) naložen preko anaconde ([1m 48s](https://youtu.be/Cp-IuyN67rQ?t=1m48s)),\n",
    "* posodobite distribucije na zadnje verzije prek ukazne vrstice ([2m 28s](https://youtu.be/Cp-IuyN67rQ?t=2m28s)),\n",
    "* namestitev Git klienta (pojasnjen spodaj, [4m 30s](https://youtu.be/Cp-IuyN67rQ?t=4m30s)),\n",
    "* ureditev repozitorija v Visual Studio Code ([5m 50s](https://youtu.be/Cp-IuyN67rQ?t=5m50s))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Uporaba githuba repozitorija in posodobitve\n",
    "\n",
    "Ta knjiga se vedno dopolnjuje, zadnja verzija je dosegljiva na:\n",
    "\n",
    "* v izvorni obliki na naslovu [github.com/jankoslavic/pypinm](https://github.com/jankoslavic/pypinm/),\n",
    "* v spletni obliki na naslovu [jankoslavic.github.io/pypinm.io](https://jankoslavic.github.io/pypinm.io/).\n",
    "* v pdf obliki na naslovu [github.com/jankoslavic/pypinm](https://github.com/jankoslavic/pypinm/raw/master/pdf/Programiranje%20in%20numeri%C4%8Dne%20metode%20v%20ekosistemu%20Pythona%20-%20zadnja%20verzija.pdf)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Najbolje je za sinhronizacijo s spletnim repozitorijem uporabljati kakšnega od Git klientov. Git je sicer zelo močno orodje in skupini razvojnikov omogoča relativno enostavno delo na isti kodi in kontrolo nad različnimi verzijami datotek."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Visual Studio Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img width=500 src=\"./fig/vsc.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pri tem predmetu bomo v glavnem programirali v Jupyter Notebooku, kateri nam omogoča zelo učinkovito programiranje ob uporabi polno formatiranega besedila in interaktivnih prikazov. Kadar želimo programirati obsežnejše in bolj splošno uporabne pakete ter namenske programe, pa se ponavadi poslužimo posebnih razvojnih okolij (angl.  *integrated development environment* - IDE). Med bolj popularnimi sta [pyCharm](https://www.jetbrains.com/pycharm/download/) (glejte Community Edition) in [Visual Studio Code - VSC](https://code.visualstudio.com/). V zadnjem obdobju VSC, zaradi hitrosti, enostavnosti uporabe in razširljivosti, pridobiva na priljubljenosti in je že vključen v distribucijo Pythona Anaconda. Proti koncu tega predmeta se bomo vrnili k uporabi VSC, v tem trenutku navedimo zgolj povezavo do odličnega video posnetka na temo [produktivnosti z VSC](https://www.youtube.com/watch?v=6YLMWU-5H9o)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Nameščanje dodatkov in posodobitev\n",
    "\n",
    "Na [pypi.org](https://pypi.org) se nahaja veliko različnih paketov! Namestimo jih iz ukazne vrstice\\* (angl. *command prompt*) tako:\n",
    "\n",
    "* z ukazom **pip**,\n",
    "* bolj popularne pakete lahko namestim tudi z ukazom **conda**,\n",
    "\n",
    "\\* Ukazno vrstico prikličete v operacijskem sistemu Windows 10 tako, da kliknite `\"Start\"` in napišite `\"command prompt\"` ter pritisnete `\"enter\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Podrobnosti nameščanja dodatkov si bomo pogledali naslednjič. Da boste imeli zadnjo verzijo paketov, izvedite naslednje:\n",
    "\n",
    "1. Odprite ukazno vrstico in sprožite ukaz za posodobitev *Anaconde*:\n",
    "\n",
    "> conda update conda\n",
    "\n",
    "2. nato posodobite še vse nameščene pakete:\n",
    "\n",
    "> conda update --all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Jupyter notebook (Jupyter lab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Jupyter notebook](https://jupyter.org/) je  interaktivno okolje, ki deluje kot spletna aplikacija in se lahko uporablja z različnimi programskimi jeziki (npr. Python, Julia, R, C, Fortran ... iz prvih treh je nastalo tudi ime JuPyt[e]R). \n",
    "\n",
    "Jupyter notebook je najlažje preizkusiti tukaj: [try.jupyter.org](https://try.jupyter.org/) ali [colab.research.google.com](https://colab.research.google.com)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "*Jupyter notebook* zaženemo (v poljubni mapi) iz *ukazne vrstice* ali iz *Raziskovalca/Explorerja* z ukazom:\n",
    "``jupyter notebook``.\n",
    "<img width=500 src=\"./fig/jupyter_notebook.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Opombe: \n",
    "* s sprožitvijo ``jupyter lab`` pridemo do izboljšanega razvojnega okolja,\n",
    "* tukaj predpostavimo, da je pot do datoteke jupyter[.exe] dodana v spremenljivke okolja; distribucija *Anaconda* s privzetimi nastavitvami to uredi pravilno, sicer iščite pomoč na spletu, npr. [tukaj](https://www.google.si/search?q=add+program+to+path+windows+10),\n",
    "* če želite ukazno vrstico sprožiti v poljubni mapi, potem v *explorerju* pridržite ``shift`` in kliknite mapo z desnim gumbom; nato izberite *Odpri ukazno vrsticu tukaj / Open command window here*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Do Jupyter strežnika dostopamo prek spletnega brskalnika. Najprej se vam prikaže seznam map in datotek do katerih lahko dostopate v okviru mape, v kateri ste sprožili ukaz `jupyter notebook`. Nato poiščite v desnem kotu zgoraj ikono *new* in nato kliknite *Python 3*. S tem boste zagnali vaš prvi Jupyter notebook (v okviru jedra Python). Najdite ukazno vrstico in na desni strani kliknite na *Help* in nato *User interface tour*. Poglejte si še *Help/Keyboard shortcuts*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Jupyter notebook je sestavjen iz t. i. *celic* (angl. cell). \n",
    "\n",
    "Celica ima dve stanji:\n",
    "\n",
    "* **Ukazno stanje / Command mode**: v to stanje se vstopi s pritiskom [escape],\n",
    "* **Stanje za urejanje / Edit mode** v to stanje se vstopi s pritiskom [enter].\n",
    "\n",
    "V obeh primerih se celico izvrši s pritiskom [shift + enter]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Celice so lahko različnega tipa; tukaj bomo uporabljali dva tipa:\n",
    "\n",
    "* **Code**: v tem primeru celica vsebuje programsko kodo (bližnjica v ukaznem stanju je tipka [y]),\n",
    "* **Markdown**: v tem primeru celica vsebuje besedilo oblikovano po standardu *Markdown* (bližnjica v ukaznem stanju je tipka [m])."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Markdown\n",
    "\n",
    "Jupyter notebook omogoča zapis v načinu *markdown*, ki ga je v letih 2003-2004 predstavil [John Gruber](https://daringfireball.net/projects/markdown/). Namen markdowna je, da se pisec osredotoča na vsebino, pri tem pa za oblikovanje uporablja nekaj preprostih pravil. Pozneje se markdown lahko prevede v spletno obliko, v pdf (npr. prek LaTeX-a) itd. Bistvena pravila (vezana predvsem na uporabu na Githubu) so [podana tukaj](https://help.github.com/articles/basic-writing-and-formatting-syntax/); spodaj jih bomo na kratko ponovili."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Naslove definiramo z znakom #:\n",
    "\n",
    "* \\# pomeni naslov prve stopnje,\n",
    "* \\#\\# pomeni naslov druge stopnje itd*.\n",
    "\n",
    "\\* Če pogledate kodo opazite, da se znak \\ pojavi pred znakom \\# zato, da se *prikaže* sam znak \\# in ne uporabi njegovo funkcijo za naslov prve stopnje. Podobno je tudi pri drugih posebnih znakih.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Oblikovanje besedila definirajo posebni znaki; če želimo besedo (ali več besed) v *poševni* obliki, moramo tako besedilo vstaviti med dva znaka \\*: tekst v stanju za urejanje v obliki \\*primer\\* bi se prikazal kot *primer*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pregled simbolov, ki definirajo obliko:\n",
    "\n",
    "* *poševno*:\\*\n",
    "* **krepko**: \\*\\*\n",
    "* ~~prečrtano~~: \\~\\~\n",
    "* `simbol`: \\`\n",
    "* ``funkcije``: \\`\\`\n",
    "* ```blok kode```: \\`\\`\\`.\n",
    "\n",
    "Opomba: za primer bloka kode Python glejte uvodno poglavje, primer Fibonacci."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "V okviru markdowna lahko uporabljamo tudi LaTeX sintakso. LaTeX je zelo zmogljiv sistem za urejanje besedil; na Fakulteti za strojništvo, Univerze v Ljubljani, so predloge za diplomske naloge pripravljene v [LaTeXu](http://lab.fs.uni-lj.si/ladisk/?what=incfl&flnm=latex.php) in Wordu. Tukaj bomo LaTeX uporabljali samo za pisanje matematičnih izrazov.\n",
    "\n",
    "Poznamo dva načina:\n",
    "\n",
    "* vrstični način (angl. *inline*): se začne in konča z znakom \\\\$, primer: $a^3=\\sqrt{365}$,\n",
    "* blokovni način (angl. *block mode*): se začne in konča z znakoma \\\\$\\\\$, primer: \n",
    "$$\\sum F=m\\,\\ddot{x}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Zgoraj smo že uporabljali sezname, ki jih začnemo z znakom \\* v novi vrstici:\n",
    "\n",
    "* lahko pišemo sezname\n",
    "     - z več nivoji\n",
    "         - 3$.$ nivo\n",
    "     - 2$.$ nivo\n",
    "* lahko pišemo *poševno*\n",
    "* lahko pišemo **krepko**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Če želimo oštevilčene sezname, začnemo z \"1.\" nato pa nadaljujemo z \"1.\":\n",
    "\n",
    "1. prvi element\n",
    "1. drugi\n",
    "1. naslednji ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "V dokument lahko vključimo tudi *html* sintakso (angl. *Hypertext Markup Language* ali po slovensko jezik za označevanje nadbesedila). Kot html najenostavneje vključimo slike.\n",
    "\n",
    "Uporabimo:\n",
    "```html\n",
    "<img width=200 src=\"./fig/ladisk.png\">\n",
    "```\n",
    "\n",
    "Za prikaz:\n",
    "<img width=200 src=\"./fig/ladisk.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Vključimo lahko tudi zunanje vire (npr. video posnetek iz Youtube). Ker gre za morebitno varnostno tveganje, tega ne naredimo v celici tipa *markdown* kakor zgoraj, ampak v celici tipa *code*, pri tem pa uporabimo t. i. magični ukaz (angl. *magic*) ``%%html``, ki definira, da bo celoten blok v obliki html sintakse (privzeto so celice tipa *code* Python koda):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/VLcPd07-gnk\" frameborder=\"0\" allowfullscreen></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html \n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/VLcPd07-gnk\" frameborder=\"0\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Magičnih ukazov je v notebooku še veliko (glejte [dokumentacijo](http://ipython.readthedocs.io/en/stable/interactive/magics.html)) in nekatere bomo spoznali pozneje, ko jih bomo potrebovali!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Doslej smo že večkrat uporabili sklicevanje na zunanje vire, to naredimo tako:\n",
    "\n",
    "``[Ime povezave](naslov do vira)``\n",
    "\n",
    "Primer: ``[Spletna stran laboratorija Ladisk](www.ladisk.si)`` se oblikuje kot: [Spletna stran laboratorija Ladisk](http:\\\\www.ladisk.si)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "V okviru markdowna lahko pripravimo preproste tabele. Priprava je relativno enostavna: med besede enostavno vstavimo navpične znake | tam, kjer naj bi bila navpična črta. Po naslovni vrstici sledi vrstica, ki definira poravnavo v tabeli. \n",
    "\n",
    "Primer: \n",
    "\n",
    "```\n",
    "| Ime   | Masa [kg]  | Višina [cm]  |\n",
    "|:-|-:|:-:|\n",
    "| Lakotnik  | 180  | 140  |\n",
    "| Trdonja | 30  | 70  |\n",
    "| Zvitorepec  | 40  | 100  |\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Rezultira v:\n",
    "\n",
    "| Ime | Masa [kg]  | Višina [cm]  |\n",
    "|-----|-----------:|:------------:|\n",
    "| Lakotnik  | 180  | 140  |\n",
    "| Trdonja | 30  | 70  |\n",
    "| Zvitorepec  | 40  | 100  |\n",
    "\n",
    "Opazimo, da dvopičje definira poravnavo teksta v stolpcu (levo `:-`, desno `-:` ali sredinsko `:-:`). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Prvi program in PEP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Sedaj smo pripravljeni na prvi program napisan v Pythonu:\n",
    "```python\n",
    "a = 5.0\n",
    "print(a)\n",
    "```\n",
    "Program lahko zapišemo v poljubnem urejevalniku tekstovnih datotek (npr. *Beležka*/*Notepad*) in ga shranimo v datoteko `ime.py`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Primer [kode](./moduli/prvi_program.py) v okolju *Visual Studio Code*:\n",
    "<img width=400 src=\"./fig/vsc_prvi_program.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To datoteko nato poženemo v ukazni vrstici (predpostavimo, da je pot do datoteke python.exe dodana v spremenljivke okolja; distribucija *Anaconda* s privzetimi nastavitvami to uredi pravilno, sicer glejte tale [vir](https://docs.python.org/3/using/windows.html#configuring-python)):\n",
    "```\n",
    "python ime.py\n",
    ">>> 5.0\n",
    "```\n",
    "Z znaki `>>>` označimo rezultat, ki ga dobimo v ukazni vrstici."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Zgornji primer izvajanja Python programa predstavlja t. i. *klasični način poganjanja programov* od začetka do konca. Tukaj bomo bolj pogosto uporabljali t. i. *interaktivni način*, ko kodo izvajamo znotraj posamezne celice tipa *code*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "a = 5.0  # to je komentar\n",
    "print(a) # izpiše vrednost a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## PEP - Python Enhancements Proposal\n",
    "\n",
    "Python ima visoke standarde glede kakovosti in estetike. Že zgodaj v razvoju jezika se je uveljavil princip predlaganja izboljšav prek t. i. *Python Enhancements Proposal* (PEP na kratko)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### PEP8\n",
    "Eden od bolj pomembnih je [PEP8](https://www.python.org/dev/peps/pep-0008/), ki definira stil:\n",
    "\n",
    "* zamik: 4 presledki,\n",
    "* en presledek pri operatorju `=`, torej: ``a = 5`` in ne ``a=5``,\n",
    "* spremenljivke in imena funkcij naj bodo opisne, pišemo jih s podčrtajem: ``širina_valja = 5``,\n",
    "* za razrede uporabljamo t. i. format CamelCase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* pri aritmetičnih operaterjih postavimo presledke po občutku: ``x = 3*a + 4*b`` ali ``x = 3 * a + 4 * b``,\n",
    "* za oklepajem in pred zaklepajem ni presledka, prav tako ni presledka pred oklepajem ob klicu funkcije: ``x = sin(x)``, ne pa ``x = sin( x )`` ali ``x = sin (x)``,\n",
    "* presledek za vejico: ``range(5, 10)`` in ne ``range(5,10)``,\n",
    "* brez presledkov na koncu vrstice ali v prazni vrstici,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* znotraj funkcije lahko občasno dodamo po *eno* prazno vrstico,\n",
    "* med funkcije postavimo dve prazni vrstici,\n",
    "* vsak modul uvozimo (`import`) v ločeni vrstici,\n",
    "* najprej uvozimo standardne pythonove knjižnice, nato druge knjižnice (npr. numpy) in na koncu lastne.\n",
    "\n",
    "Opomba: moderna razvojna orodja nam pomagajo pri oblikovanju kode, ki ustreza PEP8 (v VSC pritisnite `ctrl`+`shift`+`P` ter napišite *\"Format document\"* in pritisnite `enter`)!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### PEP20\n",
    "\n",
    "[PEP20](https://www.python.org/dev/peps/pep-0020/) je naslednji pomemben PEP, ki se imenuje tudi *The zen of Python*, torej *zen Pythona*; to so vodila, ki se jih poskušamo držati pri programiranju. Tukaj navedimo samo nekatera vodila:\n",
    "\n",
    "* Lepo je bolje kot grdo.\n",
    "* Preprosto je bolje kot zakomplicirano.\n",
    "* Premočrtno je bolje kot gnezdeno.\n",
    "* Berljivost je pomembna.\n",
    "* Posebni primeri niso dovolj posebni, da bi prekršili pravilo\n",
    "* Če je implementacijo težko pojasniti, je verjetno slaba ideja; če jo je lahko, je mogoče dobra."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Osnove Pythona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Osnovni podatkovni tipi in operatorji"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dinamično tipiziranje\n",
    "\n",
    "Python\tje\tdinamično\ttipiziran jezik. Tipi\tspremenljivk\tse\tne\tpreverjajo. Posledično nekatere operacije niso mogoče na nekaterih tipih oz. so prilagojene tipu podatka (pozneje bomo na primer pogledali množenje niza črk). Tip se določi pri dodelitvi vrednosti, poglejmo primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1 # to je komentar: a je celo število (integer)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Tip prikažemo z ukazom `type`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Vrednost `a` lahko prepišemo z novo vrednostjo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1.0  # to je sedaj število s plavajočo vejico (float)\n",
    "a        # če `a` tako zapišemo v zadnji vrstici, se bo izpisala vrednost "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Za izpis vrednosti sicer lahko uporabimo tudi funkcijo `print()`, ki jo bomo podrobneje spoznali pozneje:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Dokumentacijo funkcije lahko kličemo s pritiskom [shift + tab]. Npr: napišemo `pri` in pritisnemo [shift + tab] ter se bo v pojavnem oknu prikazala pomoč; če pridržimo [shift], se z dodatnim pritiskom na [tab] prikaže razširjena pomoč, z nadaljnjim dvojnim pritiskom [tab] (skupaj torej 4-krat) se pomoč prikaže v novem oknu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Do pomoči dostopamo tudi, tako, da pred funkcijo postavimo `?` (za pomoč) ali `??` (prikaže tudi izvorno kodo, če je ta na voljo).\n",
    "\n",
    "Primer:\n",
    "```python\n",
    "?print\n",
    "??print\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Logični operatorji\n",
    "\n",
    "Logični operatorji so ([vir](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not)):\n",
    "* `or`, primer: `a or b`; opomba: drugi element se preverja samo, če prvi ni res,\n",
    "* `and`, primer: `a and b`; opomba: drugi element se preverja samo, če prvi je res,\n",
    "* `not`, primer: `not a`; opomba: ne-logični operatorji imajo prednost: `not a == b` se interpretira kot `not (a == b)`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Primerjalni operatorji\n",
    "\n",
    "Primerjalni operatorji ([vir](https://docs.python.org/3/library/stdtypes.html#comparisons)):\n",
    "* `<` manj kot,\n",
    "* `<=`\tmanj ali enako,\n",
    "* `>` večje kot,\n",
    "* `>=` večje ali enako,\n",
    "* `==` enako,\n",
    "* `!=` neenako,\n",
    "* `is` istost objekta primerjanih operandov,\n",
    "* `is not` ali operanda nista isti objekt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 < 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lahko naredimo niz logičnih operatorjev:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 3 < 6 < 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "preverimo istost (ali gre za isti objekt):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1\n",
    "a == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Uporabimo še logični operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 3 and 6 < 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 3 and not 6 < 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Tukaj velja izpostaviti, da je v logičnih izrazih poleg `False` neresnična tudi vrednost `0`, `None`, prazen seznam (ali niz, terka, ...); **vse ostalo je `True`**.\n",
    "\n",
    "Poglejmo nekaj primerov:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1,) and True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Podatkovni tipi za numerične vrednosti\n",
    "\n",
    "Pogledali si bomo najbolj pogoste podatkovne tipe, ki jih bomo pozneje uporabili ([vir](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)):\n",
    "\n",
    "* `int` za zapis poljubno velikega celega števila,\n",
    "* `float` za zapis števil s plavajočo vejico,\n",
    "* `complex` za zapis števil v kompleksni obliki.\n",
    "\n",
    "Bolj podrobno bomo podatkovne tipe (natančnost zapisa in podobno) spoznali pri uvodu v numerične metode."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Primeri:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "celo_število = -2**3000         # `**` predstavlja potenčni operator\n",
    "racionalno_število = 3.141592\n",
    "kompleksno_število = 1 + 3j     # `3j` predstavlja imaginarni del"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Operatorji numeričnih vrednosti\n",
    "\n",
    "Podatkovni tipi razvrščeni po naraščajoči prioriteti ([vir](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)):\n",
    "\n",
    "1. `x + y` vsota,\t \t \n",
    "1. `x - y`razlika,\t \t \n",
    "1. `x * y` produkt,\t \t \n",
    "1. `x / y` deljenje,\t \t \n",
    "1. `x // y` celoštevilsko deljenje (rezultat je celo število zaokroženo navzdol),\n",
    "1. `x % y` ostanek pri celoštevilskem deljenju,\t \n",
    "1. `-x` negiranje,\t \n",
    "1. `+x` nespremenjen, \t \t \n",
    "1. `abs(x)` absolutna vrednost,\n",
    "1. `int(x)` celo število tipa `int`,\n",
    "1. `float(x)` racionalno število tipa `float`,\n",
    "1. `complex(re, im)` compleksno število tipa `complex`,\n",
    "1. `c.conjugate()` kompleksno konjugirano število,\t \t \n",
    "1. `divmod(x, y)` vrne par `(x // y, x % y)`,\n",
    "1. `pow(x, y)` vrne `x` na potenco `y`,\n",
    "1. `x ** y`\tvrne `x` na potenco `y`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pri aritmetičnih operatorjih velja izpostaviti različico, pri kateri se rezultat priredi operandu ([vir](https://docs.python.org/3/reference/simple_stmts.html#augmented-assignment-statements)). To imenujemo *razširjena dodelitev* (angl. *augmented assignement).\n",
    "\n",
    "Poglejmo si primer. Namesto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1\n",
    "a = a + 1 # prištejemo vrednost 1\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "lahko zapišemo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1\n",
    "a += 1 \n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Operatorji na nivoju bitov\n",
    "\n",
    "Operatorje na nivoju bitov bomo v inženirski praksi redko uporabljali, vseeno jih navedimo po naraščajoči prioriteti ([vir](https://docs.python.org/3/library/stdtypes.html#bitwise-operations-on-integer-types)):\n",
    "\n",
    "* `x | y` *ali* na nivoju bitov `x` in `y`,\n",
    "* `x ^ y` *ekskluzivni ali* (samo en, ne oba) na nivoju bitov `x` in `y`,\n",
    "* `x & y` bitni *in* na nivoju bitov `x` in `y`,\t \n",
    "* `x << n` premik bitov `x` za `n` bitov levo,\n",
    "* `x >> n` premik bitov `x` za `n` bitov desno,\n",
    "* `~x` negiranje bitov `x`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Poglejmo si primer ([vir](https://www.tutorialspoint.com/python/bitwise_operators_example.htm)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 21  # 21 v bitni obliki: 0001 0101 \n",
    "b = 9   # 9 v bitni obliki:  0000 1001 \n",
    "\n",
    "c = a & b; # 0000 0001 v bitni obliki predstavlja število 1 v decimalni\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prikažimo število v bitni obliki:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b1'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sestavljene podatkovne strukture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Niz (string)\n",
    "\n",
    "Niz je sestavljen iz znakov po standardu *Unicode*. V podrobnosti se ne bomo spuščali; pomembno je navesti, da je Python od verzije 3 naprej naredil velik napredek ([vir](https://docs.python.org/3/howto/unicode.html)) in da lahko poljubne znake po standardu *Unicode* uporabimo tako v tekstu, kakor tudi v programskih datotekah .py."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Niz se začne in zaključi z dvojnim \" ali enojnim ' narekovajem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tekst'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 'tekst' # b je niz (string)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pri tem ni težav z imeni, ki smo jih bolj vajeni:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "π = 3.14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Znak $\\pi$ se v notebooku zapiše, da napišemo `\\pi` (imena so ponavadi ista kot se uporabljajo pri zapisu v LaTeXu) in nato pritisnemo [tab]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Nekatere operacije nad nizi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kratek tekst\n",
      "To je množenje niza. To je množenje niza. To je množenje niza. \n",
      "Celo število: 10\n",
      "Število s plavajočo vejico: 10.0\n"
     ]
    }
   ],
   "source": [
    "print('kratek ' + b) # seštevanje\n",
    "print(3 * 'To je množenje niza. ')      # množenje niza\n",
    "print('Celo število:', int('5') + int('5'))      # pretvorba niza '5' v celo število\n",
    "print('Število s plavajočo vejico:', float('5') + float('5'))  # pretvorba niza '5' v število s plavajo vejico"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Terka (tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples ([vir](https://docs.python.org/tutorial/datastructures.html#tuples-and-sequences)) ali po slovensko terke so seznami poljubnih **objektov**, ki jih ločimo z vejico in pišemo znotraj okroglih oklepajev:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "terka_1 = (1, 'programiranje', 5.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'programiranje', 5.0)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "terka_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Večkrat smo že uporabili besedo *objekt*. Kaj je objekt? Objekte in razrede si bomo podrobneje pogledali pozneje; zaenkrat se zadovoljimo s tem, da je objekt več kot samo *ime* za določeno vrednost; objekt ima tudi metode.\n",
    "Npr. drugi element je tipa `str`, ki ima tudi metodo `replace` za zamenjavo črk:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'p8og8ami8anje'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "terka_1[1].replace('r', '8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Če ima terka samo en objekt, potem jo moramo zaključiti z vejico (sicer se ne loči od objekta v oklepaju):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "terka_2 = (1,)\n",
    "type(terka_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Terke lahko zapišemo tudi brez okroglih oklepajev:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "terka_3 = 1, 'brez oklepajev', 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'brez oklepajev', 5.0)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "terka_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Do objektov v terki dostopamo prek indeksa (**se začnejo z 0**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "terka_1[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Terke **ni mogoče spreminjati** (angl: *immutable*), elementov ne moremo odstranjevati ali dodajati. Klicanje spodnjega izraza bi vodilo v napako:\n",
    "\n",
    "```python\n",
    "terka_1[0] = 3\n",
    ">>> TypeError: 'tuple' object does not support item assignment\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Seznam (list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seznami ([vir](https://docs.python.org/tutorial/datastructures.html#more-on-lists)) se zapišejo podobno kot terke, vendar se uporabijo oglati oklepaji:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "seznam = [1., 2, 'd']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 2, 'd']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Za razliko od terk, se sezname lahko spreminja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 2, 'd']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam[0] = 10\n",
    "seznam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Seznami so spremenljivi (angl. *mutable*) in treba se je zavedati, da **ime** v bistvu **kaže** na mesto v pomnilniku računalnika:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 2, 'd']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = seznam\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sedaj tudi ``b`` kaže na isto mesto v pomnilniku. \n",
    "\n",
    "Poglejmo, kaj se zgodi s ``seznam``, če spremenimo element seznama ``b``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 2, 'd']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[0] = 9\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 2, 'd']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Če želimo narediti kopijo podatkov, potem moramo narediti tako:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[99, 2, 'd']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = seznam.copy()\n",
    "b[0] = 99\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 2, 'd']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Primer seznama seznamov:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrika = [[1, 2, 3],\n",
    "           [4, 5, 6],\n",
    "           [7, 8, 9]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrika"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Več o matrikah bomo izvedeli pozneje."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Izbrane operacije nad seznami"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tukaj si bomo pogledali nekatere najbolj pogoste operacije, za več, glejte [dokumentacijo](https://docs.python.org/tutorial/datastructures.html).\n",
    "\n",
    "Najprej si poglejmo dodajanje elementa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 'test', 'dodajanje elementa']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam = [0, 1, 'test']\n",
    "seznam.append('dodajanje elementa')\n",
    "seznam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Potem vstavljanje na določeno mesto (z indeksom 1, ostali elementi se zamaknejo):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 'na drugo mesto', 1, 'test', 'dodajanje elementa']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam.insert(1,'na drugo mesto')\n",
    "seznam"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Potem lahko določeni element odstranimo. To naredimo s `seznam.pop(i)` ali `del seznam[2]`. Prvi način vrne odstranjeni element, drugi samo odstrani element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seznam: [0, 'na drugo mesto', 'test', 'dodajanje elementa']\n",
      "odstranjeni element: 1\n"
     ]
    }
   ],
   "source": [
    "odstranjeni_element = seznam.pop(2) # odstani element z indeksom 2 in ga vrne \n",
    "# podoben učinek bi imel ukaz: del seznam[2]\n",
    "print('seznam:', seznam)\n",
    "print('odstranjeni element:', odstranjeni_element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Z metodo `.index(v)` najdemo prvi element vrednosti `v`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 'na drugo mesto', 'test', 'dodajanje elementa']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seznam.index('test')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Zakaj uporabiti terko in ne seznama?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Terk ne moremo spreminjati, zato je njihova numerična implementacija bistveno bolj lahka (v numeričnem smislu) in spomin se lahko bolje izrabi. Posledično so terke **hitrejše** od seznamov; poleg tega jih ne moretmo po nerodnosti **spremeniti**. Za širši odgovor glejte [vir](http://getpython3.com/diveintopython3/native-datatypes.html#tuples)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Množice (Sets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Množice so v principu podobne *množicam* kot jih poznamo iz matematike. Množice v Pythonu ([dokumentacija](https://docs.python.org/tutorial/datastructures.html#sets)) za razliko od ostalih sestavljenih struktur:\n",
    "\n",
    "* **ne dovoljujejo podvojenih elementov** in \n",
    "* **nimajo urejenega vrstnega reda** (pomembno, npr. za pravilno uporabo v zankah).\n",
    "\n",
    "Vredno je poudariti, da sta dodajanje in ugotavljanje pripadnosti elementa množici zelo hitri operaciji.\n",
    "\n",
    "Kreiramo jih z zavitimi oklepaji  ``{}`` ali ukazom ``set()``:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 'a', 'ž'}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {'a', 4, 'a', 2, 'ž', 3, 3}\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Če se želimo v seznamu znebiti podvojenih elementov, je zelo enostaven način, da kreiramo množico iz seznama:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 6}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = set([6, 4, 6, 6])\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Uporabimo lahko tipične matematične operacije nad množicami:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{6}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B - A   # elementi v B brez elementov, ki so tudi v A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4, 6, 'a', 'ž'}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A | B   # elementi v A ali B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A & B   # elementi v A in B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 6, 'a', 'ž'}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A ^ B   # elementi v A ali B, vendar ne v obeh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Slovar (dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Slovar ([dokumentacija](https://docs.python.org/tutorial/datastructures.html#dictionaries)) lahko definiramo eksplicitno s pari *ključ : vrednost*, ločenimi z vejico znotraj zavitih oklepajev:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'višina': 5.2, 'širina': 43, 'g': 9.81}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parametri = {'višina': 5.2, 'širina': 43, 'g': 9.81}\n",
    "parametri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Do vrednosti (angl. *value*) elementa dostopamo tako, da uporabimo ključ (angl. *key*):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parametri['višina']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pogosteje uporabljamo metode:\n",
    "* `values()`, ki vrne vrednosti slovarja,\n",
    "* `keys()`, ki vrne ključe slovarja,\n",
    "* `items()`, ki seznam terk (ključ, vrednost); to bomo pogosto rabili pri zankah.\n",
    "\n",
    "Primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('višina', 5.2), ('širina', 43), ('g', 9.81)])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parametri.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Slovarje lahko spreminjamo; npr. dodamo element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'višina': 5.2, 'širina': 43, 'g': 9.81, 'lega_težišča': 99999}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parametri['lega_težišča'] = 99999\n",
    "parametri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Elemente odstranimo (podobno kot zgoraj `pop` odstrani in vrne vrednost `del` samo odstrani):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99999"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parametri.pop('lega_težišča')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'višina': 5.2, 'širina': 43, 'g': 9.81}"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parametri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Operacije nad sestavljenimi podatkovnimi strukturami\n",
    "\n",
    "Večina sestavljenih podatkovnih struktur dovoljuje sledeče operacije ([dokumentacija](https://docs.python.org/library/stdtypes.html#common-sequence-operations)):\n",
    "\n",
    "\n",
    "* `x in s` vrne `True`, če je kateri element iz `s` enak `x`, sicer vrne `False`,\n",
    "* `x not in s` vrne `False`, če je kateri element iz `s` enak `x`, sicer vrne `True`,\n",
    "* `s + t` sestavi `s` in `t`,\n",
    "* `s * n` ali `n * s` rezultira v `n`-krat ponovljen `s`,\n",
    "* `s[i]` vrne `i`-ti element iz `s`,\n",
    "* `s[i:j]` vrne `s` od elementa `i` (vključno) do `j` (ni vključen),\n",
    "* `s[i:j:k]` rezanje `s` od elementa `i` do `j`\tpo koraku `k`,\n",
    "* `len(s)` vrne dolžino `s`,\n",
    "* `min(s)` vrne najmanjši element iz `s`,\t \n",
    "* `max(s)` vrne največji element iz `s`,\n",
    "* `s.index(x[, i[, j]])` vrne indeks prve pojave `x` v `s` (od indeksa `i` do `j`),\n",
    "* `s.count(x)` vrne število elementov."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Nekateri primeri:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in 'abc' # in primerja ali je objekt v nizu, seznamu,..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Zgoraj smo imeli seznam `parametri`:\n",
    "```python\n",
    "{'g': 9.81, 'višina': 5.2, 'širina': 43}\n",
    "```\n",
    "Preverimo, ali vsebuje element s ključem `širina`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'širina' in parametri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Štetje in rezanje sestavljenih podatkovnih struktur\n",
    "\n",
    "Predpostavimo spodnji niz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "abeceda = 'abcčdefghijklmnoprsštuvzž'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**V Pythonu začnemo šteti indekse z 0**! Na spletu lahko najdete razprave o tem ali je prav, da se indeksi začnejo z 0 ali 1. Zakaj začeti z 0 zelo lepo pojasni prof. dr. Janez Demšar v knjigi Python za programerje ([vir](https://ucilnica.fri.uni-lj.si/file.php/166/Python%20za%20programerje.pdf), stran 28) ali pa tudi prof. dr. Edsger W. Dijkstra v zapisu na [spletu](http://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Rezanje imenujemo operacijo, ko iz seznama izrežemo določene člene.\n",
    "\n",
    "Splošno pravilo je:\n",
    "```python\n",
    " s[i:j:k]\n",
    "```\n",
    "\n",
    "kar pomeni, da se seznam `s` razreže od elementa `i` do `j`\tpo koraku `k`. Če katerega elementa ne podamo potem se uporabi (logična) vrednost:\n",
    "\n",
    "* `i` je privzeto 0, kar pomeni prvi element,\n",
    "* `j` je privzeto -1, kar pomeni zadnji element,\n",
    "* `k` je privzeto 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Prvi znak je torej:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abeceda[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Prvi trije znaki so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abeceda[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Od prvih 15 znakov, vsak tretji je:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ačfil'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abeceda[:15:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zadnjih petnajst znakov, vsak tretji:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jmpšv'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abeceda[-15::3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Ko želimo obrniti vrstni red, lahko to naredimo tako (beremo od začetka do konca po koraku -1, kar pomeni od konca proti začetku s korakom 1:)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'žzvutšsrponmlkjihgfedčcba'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abeceda[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Kontrola toka programa\n",
    "\n",
    "Pogledali si bomo nekatera osnovna orodja za kontrolo toka izvajanja programa ([dokumentacija](https://docs.python.org/tutorial/controlflow.html))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Stavek `if`\n",
    "\n",
    "Tipična oblika stavka `if` ([dokumentacija](https://docs.python.org/tutorial/controlflow.html#if-statements)):\n",
    "\n",
    "```python\n",
    "if pogoj0:\n",
    "    print('Izpolnjen je bil pogoj0')\n",
    "elif pogoj1:\n",
    "    print('Izpolnjen je bil pogoj1')\n",
    "elif pogoj2:\n",
    "    print('Izpolnjen je bil pogoj2')\n",
    "else:\n",
    "    print('Noben pogoj ni bil izpolnjen')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a je več od 5\n",
      "-------------\n"
     ]
    }
   ],
   "source": [
    "a = 6\n",
    "if a > 5:\n",
    "    print('a je več od 5') # se izvede, če je pogoj res. \n",
    "    print(13*'-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Zgoraj smo funkcijo ``print`` zamaknili, saj pripada bloku kode, ki se izvede v primeru ``a > 0``. Nekateri programski jeziki kodo znotraj bloka dajo v zavite ali kakšne druge oklepaje in dodatno še zamikajo. Pri Pythonu se samo zamikajo. Zamik je tipično **4 presledke**. Lahko je tudi **tabulator** (manj pogosto), vendar pa smemo v eni datoteki .py uporabljati le en način zamikanja.\n",
    "\n",
    "Stavke lahko zapišemo tudi v eno vrstico, vendar je taka uporaba odsvetovana, saj zmanjšuje preglednost kode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "taka oblika je odsvetovana\n",
      "----------------------------------------\n",
      "uporaba podpičja namesto nove vrstice\n"
     ]
    }
   ],
   "source": [
    "if a > 5: print('taka oblika je odsvetovana'); print(40*'-'); print('uporaba podpičja namesto nove vrstice')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Izraz `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Poleg stavka ``if`` ima Python tudi izraz ``if`` (angl. *ternary operator*, glejte [dokumentacijo](https://docs.python.org/faq/programming.html#is-there-an-equivalent-of-c-s-ternary-operator)).\n",
    "\n",
    "Sintaksa je:\n",
    "\n",
    "```python\n",
    "[izvedi, če je True] if pogoj else [izvedi, če je False]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Preprost primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ni res'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Je res' if 5==3 else 'Ni res'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If izrazi so zelo uporabni in jih bomo pogosto uporabljali pri izpeljevanju seznamov!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Zanka `while`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sintaksa zanke while ([dokumentacija](https://docs.python.org/reference/compound_stmts.html#the-while-statement)) je:\n",
    "\n",
    "```python\n",
    "while pogoj:\n",
    "    [koda za izvajanje]\n",
    "else:\n",
    "    [koda za izvajanje]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Pri tem je treba poudariti, da je del `else` opcijski in se izvede ob izhodu iz zanke `while`. Ukaz `break` prekine zanko in ne izvede `else` dela. Ukaz `continue` prekine izvajanje trenutne kode in gre takoj na testiranje pogoja."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Preprost primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "--\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "while a < 3:\n",
    "    print(a)\n",
    "    a += 1\n",
    "else:\n",
    "    print('--')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Zanka `for`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "V Pythonu bomo **zelo pogosto** uporabljali zanko `for` ([dokumentacija](https://docs.python.org/3/tutorial/controlflow.html#for-statements)). Sintaksa je:\n",
    "\n",
    "```python\n",
    "for element in seznam_z_elementi:\n",
    "    [koda za izvajanje]\n",
    "else:\n",
    "    [koda za izvajanje]\n",
    "```\n",
    "\n",
    "Podobno kakor pri `while` je tudi tukaj `else` del opcijski."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Poglejmo primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jaka\n",
      "Miki\n",
      "Luka\n",
      "Anja\n"
     ]
    }
   ],
   "source": [
    "imena = ['Jaka', 'Miki', 'Luka', 'Anja']\n",
    "for ime in imena: # tukaj se skriva prirejanje; ``ime`` vsakič pridobi novo vrednost\n",
    "    print(ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Zelo uporabno je zanke delati čez slovarje:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slovar je: {'višina': 5.2, 'širina': 43, 'g': 9.81}\n",
      "višina = 5.2\n",
      "širina = 43\n",
      "g = 9.81\n"
     ]
    }
   ],
   "source": [
    "print('Slovar je:', parametri)\n",
    "for key, val in parametri.items():\n",
    "    print(key, '=', val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Funkcija `zip`\n",
    "\n",
    "Ko želimo kombinirati več seznamov v zanki, si pomagamo s funkcijo `zip` ([dokumentacija](https://docs.python.org/library/functions.html#zip)); primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pari so:  1 in 10\n",
      "Pari so:  2 in 20\n",
      "Pari so:  3 in 30\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [10, 20, 30]\n",
    "\n",
    "for xi, yi in zip(x, y):\n",
    "    print('Pari so: ', xi, 'in', yi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Funkcija `range`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pogosto bomo uporabljali zanko ``for`` v povezavi s funkcijo ``range`` ([dokumentacija](https://docs.python.org/tutorial/controlflow.html#the-range-function)). Sintaksa je:\n",
    "\n",
    "```python\n",
    "range(stop)\n",
    "range(start, stop[, step])\n",
    "```\n",
    "Če torej funkcijo kličemo z enim parametrom, je to `stop`: **do** katere številke naštevamo. V primeru klica z dvema parametroma `start, stop`, naštevamo od, do! Tretji parameter je opcijski in definira korak `step`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Poglejmo primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Funkcija `enumerate`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zanko `for` pogosto uporabljamo tudi s funkcijo `enumerate`, ki elemente oštevilči ([dokumentacija](https://docs.python.org/library/functions.html#enumerate)).\n",
    "\n",
    "Poglejmo primer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Jaka\n",
      "1 Miki\n",
      "2 Luka\n",
      "3 Anja\n"
     ]
    }
   ],
   "source": [
    "for i, ime in enumerate(imena):\n",
    "    print(i, ime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Za konec: plonk list :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veliko jih je; tukaj je [povezava](http://perso.limsi.fr/pointal/_media/python:cours:mementopython3-english.pdf) do enega."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Nekaj vprašanj za razmislek!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Namestite *Anaconda*.\n",
    "2. Namestite *Visual Studio Code*, GIT in iz GitHuba ter prenesite predavanja.\n",
    "3. V poljubnem delovnem direktoriju zaženite Jupyter notebook.\n",
    "4. Prikažite uporabo stilov, uporabo poudarjenega, poševnega teksta, uporabo seznamov, enačbe ...\n",
    "5. Definirajte razliko med statičnim in dinamičnim tipiziranjem.\n",
    "6. Poiščite pomoč poljubnega ukaza (znotraj Pythona in na uradni domači strani).\n",
    "7. Prikažite uporabo *niza*, *celega števila* in *števila z uporabo plavajoče vejice*.\n",
    "8. Prikažite uporabo *terke* in njenih bistvenih lastnosti.\n",
    "9. Prikažite uporabo *seznama* in njegovih bistvenih lastnosti.\n",
    "10. Komentirajte tipične operacije nad seznami.\n",
    "11. Komentirajte uporabo *množic* in tipične uporabe.\n",
    "12. Prikažite uporabo slovarjev.\n",
    "13. Katere aritmetične operatorje poznamo v Pythonu? Prikažite uporabo.\n",
    "14. Katere primerjalne operatorje poznamo v Pythonu? Prikažite uporabo.\n",
    "15. Katere logične operatorje poznamo v Pythonu? Prikažite uporabo.\n",
    "16. Prikažite uporabo stavka ``if`.\n",
    "17. Kakšna je razlika med stavikom ``if`` in izrazom ``if``. Prikažite!\n",
    "18. Prikažite uporabo zanke ``while``.\n",
    "19. Prikažite uporabo zanke ``for``.\n",
    "20. Prikažite uporabo zanke ``for`` v povezavi s funkcijami ``range``, ``enumerate``, ``zip``     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Še nekaj branja: [automatetheboringstuff.com](https://automatetheboringstuff.com/).\n",
    "\n",
    "In en twit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">The most important slide from my <a href=\"https://twitter.com/PyData\">@PyData</a> talk. <a href=\"https://t.co/Hc8j4ZpHV4\">pic.twitter.com/Hc8j4ZpHV4</a></p>&mdash; Almar Klein (@almarklein) <a href=\"https://twitter.com/almarklein/status/708909917684568064\">March 13, 2016</a></blockquote>\n",
       "<script async src=\"//platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<blockquote class=\"twitter-tweet\" data-lang=\"en\"><p lang=\"en\" dir=\"ltr\">The most important slide from my <a href=\"https://twitter.com/PyData\">@PyData</a> talk. <a href=\"https://t.co/Hc8j4ZpHV4\">pic.twitter.com/Hc8j4ZpHV4</a></p>&mdash; Almar Klein (@almarklein) <a href=\"https://twitter.com/almarklein/status/708909917684568064\">March 13, 2016</a></blockquote>\n",
    "<script async src=\"//platform.twitter.com/widgets.js\" charset=\"utf-8\"></script>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Vključevanje lokalnega video posnetka s transformacijami"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.core.display import HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>video{  -moz-transform:scale(0.75) rotate(-90deg);  -webkit-transform:scale(0.75) rotate(-90deg);  -o-transform:scale(0.75) rotate(-90deg);  -ms-transform:scale(0.75) rotate(-90deg);  transform:scale(0.75) rotate(-90deg);}</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML('<style>video{\\\n",
    "  -moz-transform:scale(0.75) rotate(-90deg);\\\n",
    "  -webkit-transform:scale(0.75) rotate(-90deg);\\\n",
    "  -o-transform:scale(0.75) rotate(-90deg);\\\n",
    "  -ms-transform:scale(0.75) rotate(-90deg);\\\n",
    "  transform:scale(0.75) rotate(-90deg);\\\n",
    "}</style>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<video controls src=\"./fig/vodni-top.mkv\"/></video>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Zgornje celice se na github-u ne prikaže pravilno)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "pinm",
   "language": "python",
   "name": "pinm"
  },
  "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.8.8"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  },
  "livereveal": {
   "theme": "sky",
   "transition": "default",
   "width": 1200
  },
  "nav_menu": {},
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "479px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Kazalo",
   "title_sidebar": "Kazalo",
   "toc_cell": true,
   "toc_position": {
    "height": "500px",
    "left": "0px",
    "right": "983px",
    "top": "106px",
    "width": "235px"
   },
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}