{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programovací jayzk Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ing. Matuš Nečas\n",
    "\n",
    "<div style=\"text-align:center\">\n",
    "    <img src=\"obrazky/obalka.png\" width=70%/>\n",
    "</div"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Opis jazyka"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pôvod\n",
    "\n",
    "* **Autor:** Guido van Rossum (Holandsko).\n",
    "* **Rok vzniku:** Vianoce 1989.\n",
    "* **Cieľ:** jednoduchý, čitateľný a zároveň výkonný skriptovací jazyk.\n",
    "* **Pôvod mena:** inšpirácia humorom britskej komediálnej skupiny *Monty Python*.\n",
    "  \n",
    "#### Vlastnosti\n",
    "\n",
    "* **Interpretovaný** – kód sa vykonáva postupne pomocou tzv. *interpretera*.  \n",
    "* **Interaktívny** – riadky zdrojového kódu sa dajú priamo písať a spúšťať v konzole.  \n",
    "* **Objektovo orientovaný** – podporuje princípy OOP.  \n",
    "* **Vhodný pre začiatočníkov** – kód sa podobá jednoduchej angličtine.  \n",
    "* **Široké použitie** – napr. dátové inžinierstvo, databázy, strojové učenie, webové aplikácie.\n",
    "\n",
    "#### Oficiálna dokumentácia\n",
    "\n",
    "https://www.python.org"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Začíname"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align:center\">\n",
    "    <img src=\"obrazky/zaciname.jpg\" width=70%/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Komentáre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Slúžia na dokumentáciu kódu, na chod programu nemajú efekt.\n",
    "* V Pythone existujú:\n",
    "    * Jednoriadkové. \n",
    "    * Blokové."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jednoriadkoý kometár"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Začína znakom `#` a má platnosť iba jeden riadok."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# toto je jednoriadkový komentár"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Blokový komentár"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Je ohraničený apostrofmi `'`, resp. úvodzovkami `\"`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Toto je \n",
    "blokový\n",
    "komentár\n",
    "\"\"\"\n",
    "\n",
    "'''\n",
    "Aj toto \n",
    "je \n",
    "blokový\n",
    "komentár\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Štandardný vstup a výstup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Štandardný  vstup (klávesnica): `input()`.\n",
    "* Štandardný  výstup (konzola): `print()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Použitie štandardného výstupu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahoj Svet!\n"
     ]
    }
   ],
   "source": [
    "print(\"Ahoj Svet!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Použitie štandardného vstupu aj výstupu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadajte svoje meno:  Adam\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vaše meno je: Adam\n"
     ]
    }
   ],
   "source": [
    "meno = input(\"Zadajte svoje meno: \")\n",
    "print(\"Vaše meno je:\", meno)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Dátové typy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align:center\">\n",
    "    <img src=\"obrazky/datove_typy.jpg\" width=60%/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Vlastnosti"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Dynamická typová kontrola** - netreba deklarovať typ premennej.\n",
    "* Môžu niesť akúkoľvek hodnotu - celé číslo, reálne číslo, reťazec.\n",
    "* Case senzitivita - rozlišujú sa malé a veľké písmená.\n",
    "* Názvy premenných sa môžu skladať iba z písmen, číslic a podčiarkovníkov.\n",
    "* Existujú:\n",
    "    * Jednoduché dátové typy.\n",
    "    * Zložené dátové typy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Jednoduché dátové typy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Uchovávajú len jednu hodnotu.\n",
    "* Sú to:\n",
    "    * Booleovské hodnoty: `bool`.\n",
    "    * Celé čísla: `int`.\n",
    "    * Reálne čísla: `float`.\n",
    "    * Komplexné čísla: `complex`.\n",
    "    \n",
    "> *Poznámka:* Znak `char` v Pythone neexistuje."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vytvorenie jednoduchých dátových typov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 17.5 (2+3j) True\n"
     ]
    }
   ],
   "source": [
    "a = 20      # int\n",
    "b = 17.5    # float\n",
    "c = 2+3j    # complex\n",
    "d = True    # bool\n",
    "print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operácie s jednoduchými dátovými typmi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Aritmetické: (`+`, `-`, `*`, `/`, `%`, `//`, `**`).\n",
    "* Porovnávacie: (`<`,  `>`,  `==`,  `!=`,  `<=`,  `>=`).\n",
    "* Pretypovanie: (`int()`, `float()`, `bool()`, `complex()`).\n",
    "* Logické: (`and`, `or`, `not`).\n",
    "* Bitové: (`&`, `|`, `~`, `^`, `<<`, `>>`).\n",
    "* Priraďovacie (`+=`, `-=`, `*=`, ...)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aritmetické operácie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "súčet:  7\n",
      "rozdiel:  1\n",
      "súčin:  12\n",
      "podiel (reálny):  1.3333333333333333\n",
      "podiel (celočíselný):  1\n",
      "mocnina:  64\n",
      "zvyšok po delení:  1\n"
     ]
    }
   ],
   "source": [
    "# Príklad aritmetických operácií: \n",
    "a = 4\n",
    "b = 3\n",
    "\n",
    "sucet = a + b  \n",
    "rozdiel = a - b  \n",
    "sucin = a * b  \n",
    "podiel_r = a / b  \n",
    "podiel_c = a // b\n",
    "mocnina = a ** b \n",
    "zvysok = a % b\n",
    "\n",
    "print(\"súčet: \", sucet)\n",
    "print(\"rozdiel: \", rozdiel)\n",
    "print(\"súčin: \", sucin)\n",
    "print(\"podiel (reálny): \", podiel_r)\n",
    "print(\"podiel (celočíselný): \", podiel_c)\n",
    "print(\"mocnina: \", mocnina)\n",
    "print(\"zvyšok po delení: \", zvysok)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Porovnávacie operácie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a > b: True\n",
      "a < b: False\n",
      "a == b: False\n",
      "a != b: True\n",
      "a >= b: True\n",
      "a <= b: False\n"
     ]
    }
   ],
   "source": [
    "# Príklady porovnávacích operácií:\n",
    "a = 100\n",
    "b = 10\n",
    "\n",
    "print(\"a > b:\", a > b) \n",
    "print(\"a < b:\", a < b) \n",
    "print(\"a == b:\", a == b) \n",
    "print(\"a != b:\", a != b) \n",
    "print(\"a >= b:\", a >= b) \n",
    "print(\"a <= b:\", a <= b) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pretypovanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Typ: <class 'int'> , Hodnota: 3\n",
      "Typ: <class 'float'> , Hodnota: 3.14\n",
      "Typ: <class 'complex'> , Hodnota: (3.14+0j)\n",
      "Typ: <class 'bool'> , Hodnota: True\n"
     ]
    }
   ],
   "source": [
    "# Príklad pretypovania:\n",
    "\n",
    "cislo1 = 3.14\n",
    "\n",
    "cislo2 = int(cislo1) # integer\n",
    "print(\"Typ:\", type(cislo2), \", Hodnota:\", cislo2)\n",
    "\n",
    "cislo2 = float(cislo1) # float\n",
    "print(\"Typ:\", type(cislo2), \", Hodnota:\", cislo2)\n",
    "\n",
    "cislo2 = complex(cislo1) # complex\n",
    "print(\"Typ:\", type(cislo2), \", Hodnota:\", cislo2)\n",
    "\n",
    "cislo2 = bool(cislo1) # bool\n",
    "print(\"Typ:\", type(cislo2), \", Hodnota:\", cislo2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logické operácie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a and b: False\n",
      "a or b: True\n",
      "not a: False\n"
     ]
    }
   ],
   "source": [
    "# Príklady logických operácií:\n",
    "x = True\n",
    "y = False\n",
    "\n",
    "z = x and y         # a && b\n",
    "print(\"a and b:\", z) \n",
    "\n",
    "z = x or y          # a || b\n",
    "print(\"a or b:\", z) \n",
    "\n",
    "z = not x           # !a\n",
    "print(\"not a:\", z) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Priraďovacie operácie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# Príklad priraďovacích operácií:\n",
    "a = 3\n",
    "a = a + 2\n",
    "\n",
    "print(a)\n",
    "\n",
    "a += 2\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Zložené dátové typy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Uchovávajú viacero hodnôt.\n",
    "* Sú to:\n",
    "    * reťazce: *strings*,\n",
    "    * zoznamy: *lists*,\n",
    "    * množiny: *sets*,\n",
    "    * n-tice: *tuples*,\n",
    "    * slovníky: *dictionaries*.\n",
    "\n",
    "> *Poznámka:* Pre jednoduchosť sú v prednáške ďalej rozobraté iba `list` a `string`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Skupina znakov `str`.\n",
    "* Nie je modifikovateľný.\n",
    "* Znaky sú číslované od `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Usporiadaná skupina prvkov `list`.\n",
    "* Prvky môžu byť rovnakého i rôzneho dátového typu.\n",
    "* Je modifikovateľný.\n",
    "* Sú povolené duplicity.\n",
    "* Prvky sú číslované od `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vytvorenie zoznamov a reťazcov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reťazce:\n",
      "\n",
      "Ahoj Svet\n",
      "\n",
      "\n",
      "Zoznamy:\n",
      "[]\n",
      "[1, 2, 3, 4, 5]\n",
      "['Jablko', 1, 2, True, (3+1j), [1, 2, 3, 4, 5]]\n"
     ]
    }
   ],
   "source": [
    "# Príklad vytvorenia reťazcov:\n",
    "prazdny = \"\"\n",
    "slovo = 'Ahoj Svet'\n",
    "\n",
    "print(\"Reťazce:\")\n",
    "print(prazdny)\n",
    "print(slovo)\n",
    "\n",
    "# Príklad vytvorenia zoznamov:\n",
    "\n",
    "prazdny = []\n",
    "cisla = [1, 2, 3, 4, 5]\n",
    "mix = [\"Jablko\", 1, 2, True, 3+1j, cisla]\n",
    "\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Zoznamy:\")\n",
    "print(prazdny)\n",
    "print(cisla)\n",
    "print(mix)      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operácie so zloženými dátovými typmi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Zlučovanie: (`+`, `*`).\n",
    "* Porovnanie dĺžky reťazcov: (`<`,  `>`,  `==`,  `!=`,  `<=`,  `>=`).\n",
    "* Vyhľadávanie prvkov: (`in`, `not in`).\n",
    "* Indexovanie: (pre `list`, `string`, `tuple`).\n",
    "* Pretypovanie: (`str()`, `list()`, ...).\n",
    "* Pridávanie / mazanie prvkov: (pre `list`, `set`, `dictionary`).\n",
    "* Modifikácia prvkov: (pre `list`, `dictionary`).\n",
    "* Užitočné funkcie, špecifické pre konkrétny dátový typ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Zlučovanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reťazce:\n",
      "Janko Hraško\n",
      "12\n",
      "\n",
      "\n",
      "Zoznamy:\n",
      "Mix:  [10, 20, 30, 'jablko', 'hruška', 'slivka']\n",
      "Cisla 3x:  [10, 20, 30, 10, 20, 30, 10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "# Príklady zlučovania reťazcov:\n",
    "meno = \"Janko\" + \" Hraško\"\n",
    "cislo = \"1\" + \"2\"\n",
    "\n",
    "print(\"Reťazce:\")\n",
    "print(meno)\n",
    "print(cislo)\n",
    "\n",
    "# Príklady zlučovania zoznamov:\n",
    "cisla = [10, 20, 30]\n",
    "ovocie = [\"jablko\", \"hruška\", \"slivka\"]\n",
    "\n",
    "mix = cisla + ovocie\n",
    "cisla_3x = cisla * 3\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Zoznamy:\")\n",
    "print(\"Mix: \", mix)\n",
    "print(\"Cisla 3x: \", cisla_3x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Porovnanie dĺžky"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r1 > r2: True\n"
     ]
    }
   ],
   "source": [
    "# Príklady porovnávania dĺžky reťazcov:\n",
    "r1 = \"pomaranč\"\n",
    "r2 = \"kiwi\"\n",
    "\n",
    "print(\"r1 > r2:\", r1 > r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vyhľadávanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reťazce:\n",
      "Je Janko v reťazci meno?  True\n",
      "\n",
      "\n",
      "Zoznamy:\n",
      "Chýba číslo 6 v zozname cisla?  True\n"
     ]
    }
   ],
   "source": [
    "# Príklady vyhľadávania v reťazcoch:\n",
    "meno = \"Janko Hraško\"\n",
    "\n",
    "print(\"Reťazce:\")\n",
    "print(\"Je Janko v reťazci meno? \", \"Janko\" in meno)\n",
    "\n",
    "# Príklady vyhľadávania v zoznamoch:\n",
    "cisla = [1, 2, 3, 4, 5]\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Zoznamy:\")\n",
    "print(\"Chýba číslo 6 v zozname cisla? \", 6  not in cisla)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexovanie "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reťazce:\n",
      "a\n",
      "nk\n",
      "Jank\n",
      "anko Hraško\n",
      "12\n",
      "\n",
      "\n",
      "Zoznamy:\n",
      "jablko\n",
      "['jablko', 'hruška']\n",
      "['jablko', 'hruška']\n",
      "['hruška', 'slivka']\n"
     ]
    }
   ],
   "source": [
    "# Príklady indexovania reťazcov:\n",
    "meno = \"Janko Hraško\"\n",
    "\n",
    "print(\"Reťazce:\")\n",
    "print(meno[1])\n",
    "print(meno[2:4])\n",
    "print(meno[:4])\n",
    "print(meno[1:])\n",
    "\n",
    "print(len(meno))\n",
    "\n",
    "# Príklady indexovania zoznamov:\n",
    "ovocie = [\"jablko\", \"hruška\", \"slivka\"]\n",
    "\n",
    "print(\"\\n\")\n",
    "print(\"Zoznamy:\")\n",
    "print(ovocie[0])\n",
    "print(ovocie[0:2])\n",
    "print(ovocie[:2])\n",
    "print(ovocie[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pretypovanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "# Príklad pretypovania - súčet cifier:\n",
    "\n",
    "cislo = 945\n",
    "\n",
    "cifry = str(cislo)    # pretypovanie na reťazec\n",
    "\n",
    "cifra1 = int(cifry[0]) # pretypovanie znakov na čísla\n",
    "cifra2 = int(cifry[1])\n",
    "cifra3 = int(cifry[2])\n",
    "\n",
    "vysledok = cifra1 + cifra2 + cifra3\n",
    "\n",
    "print(vysledok)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pridávanie, mazanie a modifikácia prvkov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pôvodný zoznam: ['jablko', 'hruška', 'slivka']\n",
      "Modifikácia prvku: ['mango', 'hruška', 'slivka']\n",
      "Pridanie prvkov: ['kiwi', 'mango', 'hruška', 'slivka', 'banán']\n",
      "Mazanie prvkov: ['hruška', 'slivka', 'banán']\n"
     ]
    }
   ],
   "source": [
    "# Príklady pridávania, mazania a modifikácie zoznamov:\n",
    "ovocie = [\"jablko\", \"hruška\", \"slivka\"]\n",
    "print(\"Pôvodný zoznam:\", ovocie)\n",
    "\n",
    "# modifikácia prvku\n",
    "ovocie[0] = \"mango\"      # modifikovanie prvku na 0-tom indexe\n",
    "print(\"Modifikácia prvku:\", ovocie)\n",
    "\n",
    "# pridanie prvkov\n",
    "ovocie.append(\"banán\")    # pridanie prvku na koniec zoznamu\n",
    "ovocie.insert(0, \"kiwi\")  # pridanie prvku na 0-tú pozíciu\n",
    "print(\"Pridanie prvkov:\", ovocie)\n",
    "\n",
    "# mazanie prvkov\n",
    "ovocie.pop(1)              # vzmazanie prvku s indexom 1\n",
    "ovocie.remove(\"kiwi\")      # vymazanie prvku s hodnotou \"kiwi\"\n",
    "print(\"Mazanie prvkov:\", ovocie)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Špecifické funkcie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Velke jablko: JABLKO\n",
      "Zoradné ovocie: ['hruška', 'jablko', 'slivka']\n"
     ]
    }
   ],
   "source": [
    "# Príklad špecifickej funkcie reťazca:\n",
    "jablko = \"jablko\"\n",
    "jablko = jablko.upper()\n",
    "\n",
    "print(\"Velke jablko:\", jablko)\n",
    "\n",
    "# Príklad špecifickej funkcie zoznamu:\n",
    "ovocie = [\"jablko\", \"hruška\", \"slivka\"]\n",
    "ovocie.sort()\n",
    "\n",
    "print(\"Zoradné ovocie:\", ovocie)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Riadiace štruktúry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align:center\">\n",
    "    <img src=\"obrazky/riadiace_struktury.jpg\" width=60%/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Podmienky"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Predstavujú rozhodovanie programu.\n",
    "* Kľúčové slová: `if`, `elif`, `else`.\n",
    "* Jednotlivé vetvy musia byť odsadené: **1x TAB**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jednoduchá podmienka"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadajte číslo:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kladné\n"
     ]
    }
   ],
   "source": [
    "# Príklad jednoduchej podmienky - znamienko čísla:\n",
    "\n",
    "cislo = int(input(\"Zadajte číslo: \"))\n",
    "\n",
    "if cislo > 0:\n",
    "    print(\"kladné\")\n",
    "elif cislo < 0:\n",
    "    print(\"záporné\")\n",
    "else: \n",
    "    print(\"nula\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vnorená podmienka"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadajte číslo:  4000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kladné\n",
      "veľké\n",
      "cislo\n"
     ]
    }
   ],
   "source": [
    "# Príklad vnorenej podmienky - znamienko čísla 2.0:\n",
    "\n",
    "cislo = int(input(\"Zadajte číslo: \"))\n",
    "\n",
    "\n",
    "if cislo > 0:\n",
    "    print(\"kladné\")\n",
    "        \n",
    "    if cislo > 2000:    # vnorená podmienka\n",
    "        print(\"veľké\")\n",
    "    \n",
    "    print(\"cislo\")\n",
    "        \n",
    "elif cislo < 0:\n",
    "    print(\"záporné\")\n",
    "else: \n",
    "    print(\"nula\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jednoriadková podmienka (ternárny operátor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadajte číslo:  200\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kladné\n"
     ]
    }
   ],
   "source": [
    "# Príklad jednoriadkovej podmienky - znamienko čísla 3.0:\n",
    "# nepočítame so vstupom 0\n",
    "\n",
    "cislo = int(input(\"Zadajte číslo: \"))\n",
    "\n",
    "vysledok = \"kladné\" if cislo > 0 else \"záporné\"\n",
    "\n",
    "print(vysledok) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Cykly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Umožňujú opakovať tie isté príkazy viackrát za sebou.\n",
    "* Dva rôzne typy: `for` a `while` (v Pythone neexistuje `do..while`).\n",
    "* Python podporuje príkazy: `break` a `continue`.\n",
    "* Telo cyklu musí byť odsadené: <b>1x TAB</b>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For cyklus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Cyklus s <b>pevným počtom opakovaní</b> – dopredu vieme povedať, koľkokrát sa kód vykoná.\n",
    "* Slúži najmä na <b>prechádzanie dátových štruktúr</b>, ako sú reťazce, zoznamy, n-tice, množiny a slovníky. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Prechádzanie dátových štruktúr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150\n"
     ]
    }
   ],
   "source": [
    "# Príklad použitia cyklu for na prechádzanie zložených dátových typov:\n",
    "# Súčet prvkov.\n",
    "\n",
    "cisla = [10, 20, 30, 40, 50]\n",
    "vysledok = 0\n",
    "\n",
    "for c in cisla:\n",
    "    vysledok += c\n",
    "\n",
    "print(vysledok)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vytvorenie postupností (zoznamov)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "postupnosť č. 1 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
      "postupnosť č. 2 [1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Príklad vytvorenia postupnosti od 0 do 9 s využitím cyklu for:\n",
    "\n",
    "postupnost1 = []\n",
    "\n",
    "for prvok in range(1, 10, 1):\n",
    "    postupnost1.append(prvok)\n",
    "    \n",
    "for prvok in range(10, 0, -1):\n",
    "    postupnost1.append(prvok)\n",
    "\n",
    "print(\"postupnosť č. 1\", postupnost1)\n",
    "\n",
    "# zjednodušená konštrukcia:\n",
    "\n",
    "postupnost2 = [prvok for prvok in range(1, 10, 1)]\n",
    "\n",
    "print(\"postupnosť č. 2\", postupnost2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While cyklus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Cyklus s podmienkou na začiatku.\n",
    "* Slúži na vykonávanie tých istých príkazov, pokiaľ je splnená **riadiaca podmienka**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Použitie cyklu while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Príklad použitia cyklu while:\n",
    "# Výpis postupnosti prvkov od 0 do 9.\n",
    "\n",
    "x = 0\n",
    "\n",
    "while x < 10:\n",
    "    print(x) \n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Použitie cyklu while s využitím break a continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Príklad použitia break a continue v cykle while:\n",
    "# Výpis postupnosti: iteruj od 0 do 9, vynechaj číslo 5.\n",
    "z = 0\n",
    "\n",
    "while True:       # podmienka je vždy splnená\n",
    "    if z == 5:    # vynechaj číslo 5\n",
    "        z += 1\n",
    "        continue \n",
    "    if z == 10:  # ukonči cyklus ak dosiahneš číslo 10\n",
    "        break\n",
    "    print(z)\n",
    "    z += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vnáranie cyklov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, 2, 3, \n",
      "4, 5, 6, \n",
      "7, 8, 9, \n"
     ]
    }
   ],
   "source": [
    "# Príklad použitia vnorených cyklov:\n",
    "# Výpis matice.\n",
    "\n",
    "matica = [[1, 2, 3], \n",
    "          [4, 5, 6], \n",
    "          [7, 8, 9]]\n",
    "\n",
    "for riadok in matica:\n",
    "    for stlpec in riadok:\n",
    "        print(stlpec, end=\", \")\n",
    "    print()  # nový riadok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "# Organizácia kódu a riadenie chýb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"text-align:center\">\n",
    "    <img src=\"obrazky/organizacia_kodu.jpg\" width=60%/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Funkcie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Sú bloky kódu, vykonávajúce určitú úlohu.\n",
    "* Kľúčové slová: `def` a `return`.\n",
    "* Môžu mať ľubovoľný počet parametrov (aj žiadne).\n",
    "* Môžu vracať ľubovoľný počet návratových hodnôt (aj žiadnu).\n",
    "* Telo funkcie musí byť odsadené: <b>1x TAB</b>.\n",
    "* Funkcie v Pythone podporujú rekurziu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahoj Svet\n",
      "Meno: Janko Priezvisko: Hraško\n",
      "súčet: ab\n",
      "súčet: 50 rozdiel: -30\n"
     ]
    }
   ],
   "source": [
    "# Príklady použitia funkcií:\n",
    "\n",
    "# funkcia bez parametrov a návratovej hodnoty:\n",
    "def ahojSvet():\n",
    "    print(\"Ahoj Svet\")\n",
    "\n",
    "# funkcia s 2-mi parametrami a bez návratovej hodnoty:\n",
    "def vypisMeno(x, y):\n",
    "    print(\"Meno:\", x, \"Priezvisko:\", y)\n",
    "\n",
    "# funkcia, čo vracia súčet čísel x a y (2 parametre, 1 návratová hodnota):\n",
    "def sucetCisel(x, y):\n",
    "    return x + y\n",
    "\n",
    "# funkcia, čo vracia viacero hodnôt (2 parametre, 2 návratové hodnoty):\n",
    "def vratSucetRozdiel(x, y):\n",
    "    return x + y, x - y\n",
    "\n",
    "# volanie funkcií:\n",
    "ahojSvet()\n",
    "vypisMeno(\"Janko\", \"Hraško\")\n",
    "\n",
    "A = sucetCisel(\"a\", \"b\")\n",
    "S, R = vratSucetRozdiel(10, 40)\n",
    "\n",
    "print(\"súčet:\", A)\n",
    "print(\"súčet:\", S, \"rozdiel:\", R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Výnimky"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Sú to udalosti, vyvolané pri chybe programu.\n",
    "* Kľúčové slová `try`, `except`, `finally` a `raise`.\n",
    "* Jednotlivé bloky musia byť odsadené: **1x TAB**.\n",
    "* Môžu byť vyvolané:\n",
    "    * Automaticky.\n",
    "    * Programovo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automatické vyvolávanie výnimiek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadajte číslo:  0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chyba, nastalo delenie nulou!\n",
      "Tento kód sa vykoná vždy.\n"
     ]
    }
   ],
   "source": [
    "# Príklad automatického vyvolania výnimky:\n",
    "\n",
    "cislo = int(input(\"Zadajte číslo: \" ))\n",
    "\n",
    "try:\n",
    "    vysledok = 2 / cislo   # môže nastať delenie 0\n",
    "    print(\"Výseldok je:\", vysledok)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Chyba, nastalo delenie nulou!\") # blok, ktorý sa vykoná pri chybe delenia 0\n",
    "finally:\n",
    "    print(\"Tento kód sa vykoná vždy.\")     # blok, ktorý sa vykoná vždy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automatické aj programové vyvolávanie výnimiek"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Zadajte kladné číslo:  -2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chyba, číslo je záporné!\n",
      "Tento kód sa vykoná vždy.\n"
     ]
    }
   ],
   "source": [
    "# Príklad automatického aj programového vyvolania výnimky:\n",
    "\n",
    "cislo = int(input(\"Zadajte kladné číslo: \" ))\n",
    "\n",
    "try:\n",
    "    if(cislo < 0):          # ak je číslo záporné, vyvolaj výnimku\n",
    "        raise ValueError(\"Chyba, záporné číslo\")\n",
    "    \n",
    "    vysledok = 2 / cislo    # môže nastať delenie 0\n",
    "    print(\"Výsledok je:\", vysledok)\n",
    "    \n",
    "except ValueError:                            # blok, ktorý sa vykoná, ak je číslo záporné alebo 0\n",
    "    print(\"Chyba, číslo je záporné!\")\n",
    "    \n",
    "except ZeroDivisionError:\n",
    "    print(\"Chyba, nastalo delenie nulou!\")    # blok, ktorý sa vykoná pri chybe delenia 0\n",
    "finally:\n",
    "    print(\"Tento kód sa vykoná vždy.\")        # blok, ktorý sa vykoná vždy\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Moduly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Sú to súbory, obsahujúce sadu preddefinovaných funkcií, procedúr a premenných.\n",
    "* Možno importovať **celý modul** alebo **iba jeho časť**.\n",
    "* Možno v aplikácii vytvárať vlastné pomenovania modulov - **aliasy**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importovanie celého modulu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0 2.0\n"
     ]
    }
   ],
   "source": [
    "# Príklad importovania celého modulu:\n",
    "\n",
    "import numpy # modul pre matematické funkcie\n",
    "\n",
    "a = numpy.sqrt(100) # použitie funkcií sqrt a log10 z modulu numpy\n",
    "b = numpy.log10(100)\n",
    "\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importovanie celého modulu s aliasom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0 2.0\n"
     ]
    }
   ],
   "source": [
    "# Príklad importovania celého modulu s aliasom:\n",
    "\n",
    "import numpy as pikachu # modul pre matematické funkcie s aliasom np\n",
    "\n",
    "a = pikachu.sqrt(100) # použitie funkcií sqrt a log10 z modulu numpy\n",
    "b = pikachu.log10(100)\n",
    "\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importovanie časti modulu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0 2.0\n"
     ]
    }
   ],
   "source": [
    "# Príklad importovania časti modulu:\n",
    "#import numpy\n",
    "from numpy import sqrt, log10 # z modulu numpy importuj iba funkcie sqrt a log10\n",
    "\n",
    "a = sqrt(100) # použitie funkcií sqrt a log10 z modulu numpy\n",
    "b = log10(100)\n",
    "\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Dokumentácia kódu pomocou docstringov"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* <b>Docstring</b> - špeciálne reťazcové komentáre umiestnené na začiatku funkcií, tried alebo modulov. \n",
    "* Hlavným cieľom je poskytnúť dokumentáciu kódu, ktorá je následne ľahko dostupná pre ľudí, ktorí čítajú alebo používajú daný kód.\n",
    "* Existuje viacero používaných formátov:\n",
    "    - reST (reStructuredText).\n",
    "    - javadoc.\n",
    "    - epytext.\n",
    "    - Google.\n",
    "    - Numpydoc.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dôvody dokumentácie funkcií"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Vyhnutie sa neočakávaným chybovým stavom počas behu programu.\n",
    "- Dokumentácia je priamo integrovaná do vývojového prostredia.\n",
    "- Ľahšie debugovanie.\n",
    "- Lepšia komunikácia v tíme."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dôležité body"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Bližšie definovaný opis správania funkcie.\n",
    "- Jasné definovanie dátových typov parametrov a výstupu funkcie.\n",
    "- Jasné definovanie výnimiek, ktoré funkcia vracia (ak vracia)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Príklad kódu bez dokumentácie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Nasledujúci príklad demonštruje funkciu \"zmen\". K funkcii nie sú priložené ďalšia informácie.\n",
    "Tentokrát vidíme telo funkcie, takže je pomerne ľahké zistiť, čo robí. \n",
    "Ale napr. pri externýchknižniciach spravidla nemáme prístup k implementácii funkcie. \n",
    "\n",
    "Vynára sa niekoľko otázok:\n",
    "    - Čo tá funkcia mení? Hrušky na jablká?\n",
    "    - Akého typu je parameter hodnota? Celé číslo, reálne číslo, reťazec?\n",
    "    - Aký typ funkcia vracia? A vracia funkcia vôbec niečo?\n",
    "    - Môže funkcia zlyhať? A čo sa stane, keď funkcia zlyhá?\n",
    "    \n",
    "Bez priloženej dokumentácie to musíme zistiť experimentálne ...\n",
    "\"\"\"\n",
    "\n",
    "def zmen(hodnota):\n",
    "    cifry_str = str(hodnota)\n",
    "    cifry_int = []\n",
    "    \n",
    "    try:\n",
    "        for c in cifry_str:\n",
    "            cifry_int.append(int(c))\n",
    "    \n",
    "    except ValueError as err:\n",
    "        print(\"Chyba: \" + str(err))\n",
    "\n",
    "    return cifry_int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Príklad kódu s dokumentáciou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 2, 7, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "V tomto príklade je tá istá funkcia `zmen`, ale teraz obsahuje aj dokumentáciu.  \n",
    "Dokumentácia je napísaná vo formáte reStructuredText (reST),  \n",
    "čo je bežne používaný štandard napríklad v PyCharm IDE.  \n",
    "\n",
    "Funkcia používa typové anotácie pre lepšie definovanie rozhrania funkcie.\n",
    "\"\"\"\n",
    "\n",
    "def zmen(hodnota: int) -> list[int]:\n",
    "    \"\"\"\n",
    "    Funkcia zmení celé číslo na zoznam cifier.\n",
    "    \n",
    "    :param hodnota: číslo ktoré sa má konvertovať    \n",
    "    :return: pole cifier\n",
    "    :raises ValueError: ak vstup nie je celé číslo\n",
    "    \"\"\"\n",
    "    \n",
    "    cifry_str = str(hodnota)\n",
    "    cifry_int = []\n",
    "    \n",
    "    try:\n",
    "        for c in cifry_str:\n",
    "            cifry_int.append(int(c))\n",
    "    \n",
    "    except ValueError as err:\n",
    "        print(\"Chyba: \" + str(err))\n",
    "\n",
    "    return cifry_int     \n",
    "\n",
    "# použitie\n",
    "print(zmen(32768))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
