|
|
@@ -0,0 +1,1556 @@
|
|
|
+{
|
|
|
+ "cells": [
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "# Jazyk Python - TPAR prednáška\n",
|
|
|
+ "\n",
|
|
|
+ "Tento materiál predstavuje úvod do jazyka Python v rámci predmetu TPAR. Jeho cieľom je poskytnúť vám prvotné informácie a zahájiť vašu cestu programovania v tomto jazyku. Ak máte záujem o hlbšie pochopenie, odporúčam vám preštudovať si učebnicu TPAR <i>(Gašpar G., Ďuďák J. - Využitie mikrokontrolérov v automatizovanom riadení)</i>, kde nájdete podrobnejšie vysvetlenia a rozšírenia danej problematiky. Som presvedčený, že materiál vás zaujme a odštartuje vašu zvedavosť.\n",
|
|
|
+ "\n",
|
|
|
+ "Bc. Matúš Nečas"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "# Vlastnosti jazyka Python\n",
|
|
|
+ "* <b>Interpretovaný</b>: kód jazyka sa spracováva postupne za behu programu, takzvaným interpreterom.\n",
|
|
|
+ "* <b>Interaktívny</b>: možno písať riadok po riadku program priamo do konzoly, ktorý sa okamžite bude vykonávať.\n",
|
|
|
+ "* <b>Objektovo orientovaný</b>: podporuje princípy OOP.\n",
|
|
|
+ "* <b>Vhodný pre začiatočníkov</b>: kód sa podobá jednoduchej angličtine.\n",
|
|
|
+ "* <b>Široké použitie</b>: databázy, machine learning, web aplikácie.\n"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "# Komentáre\n",
|
|
|
+ "* slúžia na dokumentáciu kódu, na program nemajú efekt,\n",
|
|
|
+ "* v Pythone existujú:\n",
|
|
|
+ " * jednoriadkové, \n",
|
|
|
+ " * blokové."
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "## Jednoriadkoý kometár\n",
|
|
|
+ "* začína znakom: (#)."
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "code",
|
|
|
+ "execution_count": null,
|
|
|
+ "metadata": {},
|
|
|
+ "outputs": [],
|
|
|
+ "source": [
|
|
|
+ "# toto je jednoriadkový komentár"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "## Blokový komentár\n",
|
|
|
+ "* je ohraničený úvodzovkami: (') alebo (\"). "
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "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": {},
|
|
|
+ "source": [
|
|
|
+ "# Štandardný vstup a výstup\n",
|
|
|
+ "* štandardný vstup (klávesnica): <b>input()</b>.\n",
|
|
|
+ "* štandardný výstup (konzola): <b>print()</b>."
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "## Použitie štandardného výstupu"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "code",
|
|
|
+ "execution_count": 20,
|
|
|
+ "metadata": {},
|
|
|
+ "outputs": [
|
|
|
+ {
|
|
|
+ "name": "stdout",
|
|
|
+ "output_type": "stream",
|
|
|
+ "text": [
|
|
|
+ "Ahoj Svet!\n"
|
|
|
+ ]
|
|
|
+ }
|
|
|
+ ],
|
|
|
+ "source": [
|
|
|
+ "# Príklad použitia štandardného výstupu: \n",
|
|
|
+ "print(\"Ahoj Svet!\")"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "## Použitie štandardného vstupu aj výstupu"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "code",
|
|
|
+ "execution_count": 21,
|
|
|
+ "metadata": {},
|
|
|
+ "outputs": [
|
|
|
+ {
|
|
|
+ "name": "stdin",
|
|
|
+ "output_type": "stream",
|
|
|
+ "text": [
|
|
|
+ "Zadajte svoje meno: Janko Hraško\n"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "name": "stdout",
|
|
|
+ "output_type": "stream",
|
|
|
+ "text": [
|
|
|
+ "Vaše meno je: Janko Hraško\n"
|
|
|
+ ]
|
|
|
+ }
|
|
|
+ ],
|
|
|
+ "source": [
|
|
|
+ "# Príklad použitia štandardného vstupu aj výstupu: \n",
|
|
|
+ "meno = input(\"Zadajte svoje meno: \")\n",
|
|
|
+ "print(\"Vaše meno je:\", meno)"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "# Dátové typy\n",
|
|
|
+ "* 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, čísel a podčiarkovníkov.\n",
|
|
|
+ "* existujú:\n",
|
|
|
+ " * jednoduché dátové typy,\n",
|
|
|
+ " * zložené dátové typy.\n",
|
|
|
+ "\n",
|
|
|
+ "## Jednoduché dátové typy\n",
|
|
|
+ "* uchovávajú len jednu hodnotu,\n",
|
|
|
+ "* sú to:\n",
|
|
|
+ " * booleovské hodnoty: <b>bool</b>,\n",
|
|
|
+ " * celé čísla: <b>integer</b>,\n",
|
|
|
+ " * reálne čísla: <b>float</b>,\n",
|
|
|
+ " * komplexné čísla: <b>complex</b>.\n",
|
|
|
+ " \n",
|
|
|
+ "<i> Poznámka: Znak \"char\" v Pythone neexistuje.</i>\n"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "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\n",
|
|
|
+ "* 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": 23,
|
|
|
+ "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": 25,
|
|
|
+ "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": {},
|
|
|
+ "source": [
|
|
|
+ "## Zložené dátové typy\n",
|
|
|
+ "\n",
|
|
|
+ "* uchovávajú viacero hodnôt,\n",
|
|
|
+ "* sú to:\n",
|
|
|
+ " * reťazce: <b>strings</b>,\n",
|
|
|
+ " * zoznamy: <b>lists</b>,\n",
|
|
|
+ " * množiny: <b>sets</b>,\n",
|
|
|
+ " * n-tice: <b>tuples</b>,\n",
|
|
|
+ " * slovníky: <b>dictionaries</b>.\n",
|
|
|
+ "\n",
|
|
|
+ "### String\n",
|
|
|
+ "* skupina znakov,\n",
|
|
|
+ "* <b>nie je modifikovateľný</b>,\n",
|
|
|
+ "* <b>znaky sú číslované od 0</b>.\n",
|
|
|
+ "\n",
|
|
|
+ "### List\n",
|
|
|
+ "* usporiadaná skupina prvkov,\n",
|
|
|
+ "* prvky môžu byť <b>rovnakého i rôzneho dátového typu</b>,\n",
|
|
|
+ "* je modifikovateľný,\n",
|
|
|
+ "* sú povolené duplicity,\n",
|
|
|
+ "* <b>prvky sú číslované od 0</b>."
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "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\n",
|
|
|
+ "* 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": {},
|
|
|
+ "source": [
|
|
|
+ "# Podmienky\n",
|
|
|
+ "* predstavujú rozhodovanie programu,\n",
|
|
|
+ "* kľúčové slová: <b>if</b>, <b>elif</b>, <b>else</b>,\n",
|
|
|
+ "* jednotlivé vetvy musia byť odsadené: <b>1x TAB</b>."
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "## Jednoduchá podmienka"
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "code",
|
|
|
+ "execution_count": 38,
|
|
|
+ "metadata": {},
|
|
|
+ "outputs": [
|
|
|
+ {
|
|
|
+ "name": "stdin",
|
|
|
+ "output_type": "stream",
|
|
|
+ "text": [
|
|
|
+ "Zadajte číslo: 7\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": {},
|
|
|
+ "source": [
|
|
|
+ "# Cykly\n",
|
|
|
+ "* umožňujú opakovať tie isté príkazy viackrát za sebou,\n",
|
|
|
+ "* dva rôzne typy: <b>for</b> a <b>while</b> (v Pythone neexistuje do..while),\n",
|
|
|
+ "* Python podporuje príkazy: <b>break</b> a <b>continue</b>,\n",
|
|
|
+ "* telo cyklu musí byť odsadené: <b>1x TAB</b>."
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "cell_type": "markdown",
|
|
|
+ "metadata": {},
|
|
|
+ "source": [
|
|
|
+ "## For cyklus\n",
|
|
|
+ "* 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": 40,
|
|
|
+ "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\n",
|
|
|
+ "* cyklus s podmienkou na začiatku,\n",
|
|
|
+ "* slúži na vykonávanie tých istých príkazov, pokiaľ je splnená <b>riadiaca podmienka</b>."
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "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": {},
|
|
|
+ "source": [
|
|
|
+ "# Funkcie\n",
|
|
|
+ "* sú bloky kódu, vykonávajúce určitú úlohu,\n",
|
|
|
+ "* kľúčové slová: <b>def</b> a <b>return</b>,\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": 45,
|
|
|
+ "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": {},
|
|
|
+ "source": [
|
|
|
+ "# Výnimky\n",
|
|
|
+ "* sú to udalosti, vyvolané pri chybe programu,\n",
|
|
|
+ "* kľúčové slová <b>try</b>, <b>except</b>, <b>finally</b> a <b>raise</b>,\n",
|
|
|
+ "* jednotlivé bloky musia byť odsadené: <b>1x TAB</b>.\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": {},
|
|
|
+ "source": [
|
|
|
+ "# Moduly\n",
|
|
|
+ "* sú to súbory, obsahujúce sadu preddefinovaných funkcií, procedúr a premenných,\n",
|
|
|
+ "* možno importovať <b>celý modul</b> alebo <b>iba jeho časť</b>,\n",
|
|
|
+ "* možno v aplikácii vytvárať vlastné pomenovania modulov - <b>aliasy</b>."
|
|
|
+ ]
|
|
|
+ },
|
|
|
+ {
|
|
|
+ "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": {},
|
|
|
+ "source": [
|
|
|
+ "## Dokumentácia kódu pomocou docstringov\n",
|
|
|
+ "* <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",
|
|
|
+ "\n",
|
|
|
+ "\n",
|
|
|
+ "### Dôvody dokumentácie funkcií:\n",
|
|
|
+ "- 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.\n",
|
|
|
+ " \n",
|
|
|
+ "### Dôležité body\n",
|
|
|
+ "- 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": "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": "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
|
|
|
+}
|
