|
|
@@ -0,0 +1,1841 @@
|
|
|
+{
|
|
|
+ "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
|
|
|
+}
|
