{
"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 (Gašpar G., Ďuďák J. - Využitie mikrokontrolérov v automatizovanom riadení), 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",
"* Interpretovaný: kód jazyka sa spracováva postupne za behu programu, takzvaným interpreterom.\n",
"* Interaktívny: možno písať riadok po riadku program priamo do konzoly, ktorý sa okamžite bude vykonávať.\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: 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): input().\n",
"* štandardný výstup (konzola): print()."
]
},
{
"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: bool,\n",
" * celé čísla: integer,\n",
" * reálne čísla: float,\n",
" * komplexné čísla: complex.\n",
" \n",
" Poznámka: Znak \"char\" v Pythone neexistuje.\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: , Hodnota: 3\n",
"Typ: , Hodnota: 3.14\n",
"Typ: , Hodnota: (3.14+0j)\n",
"Typ: , 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: strings,\n",
" * zoznamy: lists,\n",
" * množiny: sets,\n",
" * n-tice: tuples,\n",
" * slovníky: dictionaries.\n",
"\n",
"### String\n",
"* skupina znakov,\n",
"* nie je modifikovateľný,\n",
"* znaky sú číslované od 0.\n",
"\n",
"### List\n",
"* usporiadaná skupina prvkov,\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\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á: if, elif, else,\n",
"* jednotlivé vetvy musia byť odsadené: 1x TAB."
]
},
{
"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: for a while (v Pythone neexistuje do..while),\n",
"* Python podporuje príkazy: break a continue,\n",
"* telo cyklu musí byť odsadené: 1x TAB."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## For cyklus\n",
"* cyklus s pevným počtom opakovaní – dopredu vieme povedať, koľkokrát sa kód vykoná,\n",
"* slúži najmä na prechádzanie dátových štruktúr, 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á 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": {},
"source": [
"# Funkcie\n",
"* 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é: 1x TAB,\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á 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": {},
"source": [
"# Moduly\n",
"* 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": {},
"source": [
"## Dokumentácia kódu pomocou docstringov\n",
"* docstring - š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
}