{"id":22889988,"url":"https://github.com/frantallukas10/python-fundamentals","last_synced_at":"2025-03-31T20:42:23.682Z","repository":{"id":267481445,"uuid":"901385401","full_name":"frantallukas10/python-fundamentals","owner":"frantallukas10","description":null,"archived":false,"fork":false,"pushed_at":"2024-12-10T15:06:05.000Z","size":447,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-02-07T00:29:23.858Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/frantallukas10.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-12-10T15:03:28.000Z","updated_at":"2024-12-10T15:06:26.000Z","dependencies_parsed_at":"2024-12-10T16:40:40.200Z","dependency_job_id":null,"html_url":"https://github.com/frantallukas10/python-fundamentals","commit_stats":null,"previous_names":["frantallukas10/python-fundamentals"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/frantallukas10%2Fpython-fundamentals","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/frantallukas10%2Fpython-fundamentals/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/frantallukas10%2Fpython-fundamentals/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/frantallukas10%2Fpython-fundamentals/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/frantallukas10","download_url":"https://codeload.github.com/frantallukas10/python-fundamentals/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":246540159,"owners_count":20793928,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-12-13T21:57:39.109Z","updated_at":"2025-03-31T20:42:23.629Z","avatar_url":"https://github.com/frantallukas10.png","language":"Python","readme":"# Python fundamentals\n\n## 1. SYNTAX\n\n# Komentare\n\n- ak iba jeden riadok =\u003e #\n- na viac riadkov =\u003e \"\"\"...\"\"\"\n\n```py\nnapatie = 5  # V s t u p n e n a p a t i e [ V ]\ndef pocitaj_odpor(napatie, prud):\n\"\"\"\nvypocet podla Ohmovho zakona [ V ]\n\"\"\"\nodpor = napatie / prud\nreturn odpor\n```\n\n# Premenne\n\n- nesmie zacinat cislom a nesmie byt zhodna s klucovym slovom\n\n```python\nroky, polomer_kruhu, x1, x2, y...\n```\n\n- hodnotu priratam pomocou `=`\n\n```python\na = 22\nb = 10\n```\n\n# Dynamicke typovanie\n\n- Python typuje hodnoty a premenne nemaju typ:\n  Zakladne typy:\n  - noneType - `None`\n  - boolean - `True/False`\n  - cele cisla - `integer (i)`\n  - desatine/realne cisla - `float (f)`\n  - komplexne cisla/komplexna zlozka j - `complex, 1+2j`\n  - retazce - `str`\n  - kolekcie - `list`, `dict`, `set`\n\n```python\nx = 22\ntype(x) # vypise sa int\n```\n\n# Funkce\n\n- `type`\n\n```python\ntype(True) # vypise sa bool ako boolean\n```\n\n- `print`\n\n```python\nprint(\"Hello\") # vypise sa Hello\n```\n\n- `abs`\n\n```python\nabs(-5) # vypise sa 5, ako absolutna hodnota\n```\n\n- patria sem aj knihovne - `modules` =\u003e subor konstant, premennych a dalsich funkcii\n  `Moduly` - nacitam pomocou `import`\n\n```python\nimport math\nmath.pi # vypise sa mi 3.14159...\n\nmath.sqrt(2) # vypise sa odmocnina = 1.14142...\n\nmath.pow(2, 2) # vypise sa mocnina = 4.0\n\nmath.log(100) # prirodzeny logaritmus...\n\nmath.log10(100) # desiatkovy logaritmus...\n\nmath.sin(90) # sinus...\n\nmath.radians(90) # 1.5707963267948966\n\nmath.degrees(2 * math.PI) # 360.0\n```\n\n# Pretypovanie\n\n```python\ntype(10) # vypise sa int\n\nfloat(10) # vypise sa 10.0\n\ntype(float(10)) # vypise sa float\n\nstr(10) # vypise sa \"10\"\n\ntype(str(10)) # vypise sa str\n\n```\n\n# Bloky\n\n- za pomoci dvojbodky a odsadzovania textu\n\n```python\ndef block1():\n    a = 2\n    b = 3\n    def block2():\n        c = 4\ndef block3():\n    d = 4\n```\n\n- ak su zle odsadenia vyskoci error hlaska `IndentationError`\n\n# Matematicke operacie a operatory\n\n- klasicke operatory: +, -, \\*, /\n\n```python\n2 + 3 # vypise sa 5\n```\n\n- operator `modulo` =\u003e celociselne delenie: %, vracia zbytok\n\n```python\n10 % 3 # vypise sa zbytok 1\n```\n\n- mocniny a odmocniny\n\n```python\n2 ** 8 # vypise sa 256\n\n16 ** 0.5 # vypise sa 4.0 (odmocnina z 2)\n```\n\n- poradie matematickych funkcii je ako v matematiken\n\n- porovnavacie operatory: \u003c, \u003e, =, ==, !=, \u003c=, \u003e=\n\n```python\nx = 5   # do premennej x priradi hodnotu 5!\nx == 5  # je x rovne 5\n```\n\n- logicke operatory: and, or, not\n\n## 2. RETAZCE, VSTUPY A VYSTUPY\n\n# Znak `(character)`\n\n- je prvok konkretnej znakovej sady\n\n# Retazce `(string)`\n\n- postupnost znakovej\n- zapis pomocou ',(tiez ked su uvodzovky) \" alebo aj pri viacriadkovych retazcoch ''', \"\"\"\n\n```python\n'Hello'\n\"Hello\"\n'''Hello'''\n\"\"\"Hello\"\"\"\n\nretazec = \"\"\"dlhy retazec\ncez viacero riadkov\"\"\"\nprint(retazec) # dlhy retazec cez viacero riadkov\n\nprint(\"I'm sorry.\") # I'm sorry.\n```\n\n# Vypis retazcov funkcii `print`\n\n- v normalnom aj interaktivnom mode, uvodzovky sa nevypisuju\n\n```python\nretazec = 'moj string'\nprint(retazec) # vypise sa: moj string\n```\n\n- iba v ineteraktivnom mode s uvodzovkami ak:\n\n```python\nretazec = 'moj string'\nretazec # vypise sa: 'moj string'\n```\n\n# Specialne znaky a escapovanie\n\n- zapisujeme pomocou nespravneho lomitka `\\`\n- Naj:\n  - `\\n` novy riadok\n  - `\\t` tabulator\n  - `\\'` apostrof\n  - `\\\"` uvodzovky\n  - `\\\\` nespravne lomitko\n\n# Operacie s retazcami\n\n- funkcia `len()` - zisti dlzku retazca\n\n```python\nlen('ahoj') # 4\nlen('Dobry den. \\n') # 11\n```\n\n- operator `+` -\u003e spojovanie retazca\n\n```python\n'dve' + ' ' + 'slova' # 'dve slova'\na = 2\nb = 'slova'\nstr(a) + ' ' + b # '2 slova'\n```\n\n- operator `*`\n\n```python\n'ha' * 5 # 'hahahahaha'\n```\n\n- volanie znakovej -\u003e pomocou [] a indexu\n- zaporne indexi sprava od -1\n\n```python\nretazec = 'Hello World'\nretazec[0] # 'H'\nretazec[1] # 'e'\nretazec[-1] # 'd'\nretazec[-2] # 'l'\n```\n\n- podretazec -\u003e zapisujem [od:do]\n\n```python\nretazec = 'Hello World'\nretazec[2:5] # 'llo'\nretazec[-4:] # 'orld'\nretazec[:4] # 'Hell'\nretazec[:] # 'Hello World'\n```\n\n- preskakovanie znaku [od:do:krok]\n- vieme vynechat od, do alebo obe\n- obrateny retazec - krok = -1\n\n```python\nretazec = '0123456789'\nretazec[1:8:2] # '1357'\n\nretazec[::3] # '0369'\n\nretazec[::-1] # '9876543210'\n```\n\n# Retazec nemozno upravovat!\n\n```python\nretazec = 'Hello World'\nretazec[6] = 'X' # error\n\nretazec = retazec[:6] + 'X' + retazec[7:]\nretazec # 'Hello Xorld'\n```\n\n- hladanie podretazcov `(substrings)`-\u003e operatory `in` a `not in` testuju ci je/nie je ihla v kope sena\n\n```python\n'123' in 'ABCDefgh1234' # True\n'456' in 'ABCDefgh1234' # False\n'456' not in 'ABCDefgh1234' # True\n'ABCDefgh1234' in '123' # False\n```\n\n- METODY:\n  - metoda `count()`- pocitam pocet\n\n```python\nretazec = 'Neznesie sa so sestrou.'\nretazec.count('sa') # 4\n\n'sa'.count(retazec) # 0\n```\n\n- metoda `find()`- hladam index\n\n```python\nretazec = 'Neznesie sa so sestrou.'\nretazec.find('sa') # 5\n```\n\n- metoda `startswith()`- hlada iba na zaciatku\n- metoda `endswith()`- hlada iba na konci\n\n```python\nretazec = 'Neznesie sa so sestrou.'\nretazec.startswith('sa') # False\n\nretazec.startswith('Nez') # True\n\nretazec.endswith('.') # True\n```\n\n- metoda `replace()`- nahradi stary podretazec za novy\n  - treti parameter nastavi max pocet nahradeni\n\n```python\n'kormorán'.replace('or', 'ol') # 'kolmolán'\n\n'kormorán'.replace('or', 'ol', 1) # 'kolmorán'\n```\n\n- metoda `split()`-rozdeli retazec podla zadaneho separatoru\n  - pokial nie je separator nastaveny beru sa defaultne zhluky bielych znakov(medzera, \\t, \\n)\n\n```python\nretezec = 'dve slova \\t tri cele slova'\nretezec.split() # ['dve', 'slova', 'tri', 'cele', 'slova']\n\nretezec.split(' ') # ['dve', '', 'slova', '\\t', 'tri', 'cele', 'slova']\n```\n\n- odstranenie bielych znakov na okrajoch\n\n  - metoda `strip()` - odstranenie z oboch koncov retazca\n  - metoda `lstrip()` - odstranenie z lava (left-strip)\n  - metoda `rstrip()` - odstranenie z prava (right-strip)\n\n- zmena velkosti pisma\n  - metoda `upper()` - velke pismena\n  - metoda `lower()` - male pismena\n  - metoda `swapcase()` - zmena velkosti, male na velke a naopak\n  - metoda `capitalize()` - prve pismeno velke v prvom slove\n  - metoda `title()` - prve pismeno velke v kazdom slove\n\n```python\nretazec = 'ABCD efgh Ijkl'\nretazec.upper() # 'ABCD EFGH IJKL'\n\nretazec.lower() # 'abcd efgh ijkl'\n\nretazec.swapcase() # 'abcd EFGH iJKL'\n\nretazec.capitalize() # 'Abcd efgh ijkl'\n\nretazec.title() # 'Abcd Efgh Ijkl'\n```\n\n# Logicke operacie\n\n- `isalpha()` - obs iba pismena\n- `isdigit()` - obs iba cislice\n- `isalnum()` - obs iba pismena a cisla\n\n```python\n'ABCDefgh1234'.isalnum() # True\n\n'ABCD efgh 1234'.isalnum() # False\n```\n\n- `isspace()`- obs iba biele znaky\n\n```python\n' \\t\\n\\r'.isspace() # True\n\n'a \\t\\n\\r'.isspace() # False\n```\n\n- `isupper()`, `islower()`-su vsetky pismena velke/male\n\n```python\n'Mám 5 jablk.'.islower() # False\n\n'mám 5 jablk.'.islower() # True\n\n'A Je To Tu'.istitle() # True\n```\n\n# Formatovanie retazca\n\n1. metoda `format()` - mame sablonu do ktorej umiestnujeme znacku `{}`, kt sa nahradia hodnotamy y parametru funkcie\n\n```python\nsablona = 'Volam sa {} a mam {} rokov.'\nsablona.format('Anička', 5) # 'Volam sa Anička a mam 5 rokov.'\n```\n\n- znacky mozem indexovation a aj pomenovat\n\n```python\nsablona = 'Volam sa {}, mam {} rokov, paci sa mi {}.'\nsablona.format('Anička', 5, 'Prasiatko Peppa')\n# 'Volam sa Anička, mam 5 rokov, paci sa mi Prasiatko Peppa.'\n\nsablona = 'Volam sa {2}, mam {1} rokov, paci sa mi {0}.'\nsablona.format('Anička', 5, 'Prasiatko Peppa')\n# 'Volam sa Prasiatko Peppa, mam 5 rokov, paci sa mi Anička.'\n\nsablona = 'Volam sa {2}, mam {0} rokov, paci sa mi {1}.'\nsablona.format('Anička', 5, 'Prasiatko Peppa')\n# 'Volam sa Prasiatko Peppa, mam Anička rokov, paci sa mi 5.'\n\nsablona = 'Volam sa {jmeno}, mam {vek} rokov, paci sa mi {co}.'\nsablona.format(vek=5, co='Prasiatko Peppa', jmeno='Anička')\n# 'Volam sa Anička, mam 5 rokov, paci sa mi Prasiatko Peppa.'\n```\n\nTYPY:\n\n- vo znacke za dvojbodkov definujeme:\n  - zarovnanie `{:\u003c}`, `{:\u003e}` alebo `{:^}`\n  - dlzku `{:100}`\n  - pocet desatinych miest `{:.2}`\n  - typ1/format: `{:s}` retazec, `{:n}` cislo, `{:f}` realne cislo, `{:e}` vedecky format cisla\n- zadane poradie je nutne dodrzat\n\n```python\n'{}'.format(1000.2) # '1000.2'\n\n'{:\u003e20.2e}'.format(1000.2) # '     1.00e+03'\n\n'{x:^20.2E}'.format(x=1000.2) # '   1.00E+03   '\n```\n\n2. `f-string` - funguje podobne ako `format` ale znacky musia byt pomenovane\n\n- hodnoty sa beru priamo z premennych v prostredi\n\n```python\nmeno = 'Anička'\nvek = 5\nco = 'Prasiatko Peppa'\n\nf'Volam sa {meno}, je mi {vek:.2f} rokov, paci sa mi {co:^25}.'\n# 'Volam sa Anička, je mi 5.00 rokov, paci sa mi      Prasiatko Peppa     .'\n```\n\n# VSTUP (input) a VYSTUP (output)\n\n- funkcia `input()` - sluzi na predanie info. do beziaceho programu\n  - uzivatelovi vypise hlasku, vysledok je retazec, kt. zadal uzivatel\n\n```python\nmeno = input('Ako sa volas? ')\nvek = input('Kolko mas rokov? ')\nco = input('Co sa ti paci? ')\nprint(f'Volas sa {meno}, je ti {vek} rokov, pacia sa ti {co}.')\n\n#Ako sa volas? Honza\n#Kolko mas rokov? 7\n#Co sa ti paci? Pokémoni\n#Volas sa Honza, je ti 7 rokov, pacia sa ti Pokémoni.\n```\n\n- funkcia `output` teda `print` - sluzi na predanie info. von z beziaceho programu\n  - vsetky parametre premeny na retazec a vypise ich\n\n```python\nprint('ahoj', 5, True) # ahoj 5 True\n```\n\n# Specialne parametre funkcie `print()`:\n\n- `sep`(default je ' ')\n\n```python\nprint(1, 2, 3) # 1 2 3\n\nprint(1, 2, 3, sep=', ') # 1, 2, 3\n\nprint(1, 2, 3, sep='\\t') # 1     2     3\n\nprint(1, 2, 3, sep='') # 123\n```\n\n- `end`(default je '\\n')\n\n```python\nprint(1, 2, 3) # 1 2 3\nprint(4, 5, 6) # 4 5 6\n\nprint(1, 2, 3, end=';')\nprint(4, 5, 6)\n# 1 2 3;4 5 6\n\nprint(1, 2, 3, sep=',', end=' ---\u003e ')\nprint(4, 5, 6, sep='|', end='.')\n# 1,2,3 ---\u003e 4|5|6.\n```\n\n# Reprezentacia znakov v pocitaci\n\n- kazdy znak je v znakovej sade reprezentovany svojim ordinalnym cislom\n- funkcia `ord()` zistuje ordinalne cislo znaku\n- opakom je funkcia `chr()`, ktora vracia znak pre zadane ordinalne cislo\n\n```python\nord('A') # 65\n\nord('č') # 269\n\nchr(97) # 'a'\n\nchr(367) # 'ů'\n```\n\n- escapovanie pomocou ordinalnych cisel\n  - `\\x??` kde ?? je ord. cislo znaku v 16 sustave\n  - `\\u????` kde ???? je ord. cislo znaku 16 sustave\n  - `\\U????????` kde ???????? je ord. cislo znaku v 16 sustave\n  - `\\N{name}` kde name je nazov Unicode znaku\n\n```python\nprint('\\x41 \\u0041 \\U00000041 \\xE1 \\N{pound sign}')\n# A A A á £\n```\n\n## 3.PODMIENKY A CYKLY\n\n# Logicke operatory\n\n- `and` - \"a\" (logicky sucin)\n- `or` - \"alebo\" (logicky sucet)\n- `not` - negacia\n\n```python\n'abc'.startswith('a') and 9 \u003e 1 # True\n\nnot False # True\n```\n\n- operator `and` vracia lavu stranu vyrazu, pokial je nepravdiva, inak vracia pravu cast vyrazu\n- opertator `or` vracia lavu stranu vyrazu, pokial je pravdiva, inak vracia pravu cast vyrazu\n\n```python\nNone or 1 # 1\n\n0 and True # False\n10 and True # True\n```\n\n- in/ not in - je/nie je sucasti\n- is/ is not - testovanie identity objektu\n\n```python\n'abc' not in 'abcdef' # False\n\n5 == 5.0 # True\n\n5 is 5.0 # False\n```\n\n# poradie operacii\n\n1. Matematicke: \\*_, _, /, +, -\n2. Porovnavacie: \u003c, \u003e, \u003c=, \u003e=, ==, !=, is is not, in , not in\n3. not\n4. and\n5. or\n\n```python\n9 + 3 \u003e 11 and 5 != 6 or not True # True\n```\n\n# Bloky\n\n- casti kodu, kt. sa vykonavaju v konkretnych situaciach\n- zacinaju na predchadzajucom riadku dvojbodkou `:`\n- su odsadene urcitym poctom medzier/tabulatorov\n- bloky mozu byt aj vnorene\n\n```python\nif 1 == 2:\n  print('1 == 2') # Blok 1\n  print('This is strange') # Blok 1\nelif 1 \u003e 2:\n  print('1 \u003e 2') # Blok 2\n  print('This is even stranger') # Blok 2\nwhile 1 \u003e 2: # Blok 2\n  print('It is strange indeed') # Blok 2, vnorený blok 3\n  x = 5 # Blok 2, vnorený blok 3\n  y = x + 2 # Blok 2, vnorený blok 3\n  print('Blablabla') # Blok 2\nelse:\n  pass # Blok 4\n  print('This is the end') # This is the end\n```\n\n- odsadenie celeho bloku musi byt rovnake, inak cakajte `IndentationError`\n- doporucene odsadenie su medzery, VS Code - automaticky nahradzuje tabulator za 4 medzery\n\n```python\nif 1 == 2:\n    print('Hmmm...')\n      print('I am confused')\n# File \"\u003cipython-input-13-d8dc889750bf\u003e\", line 3\n# print('I am confused')\n# ^\n# IndentationError: unexpected indent\n```\n\n- bloky nemozu byt prazdne\n\n```python\nif 1 == 2:\nelse:\n# File \"\u003cipython-input-15-c11bbeb9214a\u003e\", line 2\n# else:\n# ^\n# IndentationError: expected an indented block\n```\n\n- ked chceme blok, v kt. sa nerobi nic, pouzije prikaz `pass`\n\n```python\nif 1 == 2:\n    pass\nelse:\n    pass\n```\n\n# Podmienky\n\n- `if`\n\n```python\nif podminka:\n    urob_nieco\n```\n\n```python\nx = 15\nif x \u003e 10:\n    print(f'{x} je vacsie ako 10.') # 15 je vacsie ako 10\nprint('Koniec') # Koniec\n\nx = 3\nif x \u003e 10:\n    print(f'{x} je vacsie ako 10.')\nprint('Koniec') # Koniec\n```\n\n- `if.. else`\n\n```python\nif podmienka:\n    urob_nieco\nelse:\n    urob_nieco_ine\n```\n\n```python\nx = 15\nif x \u003e 10:\n    print(f'{x} je vacsie ako 10.') # 15 je vacsie ako 10\nelse:\n    print(f'{x} je menšie alebo rovne 10.')\nprint('Koniec') # Koniec\n\nx = 3\nif x \u003e 10:\n    print(f'{x} je vacsie ako 10.')\nelse:\n    print(f'{x} je menšie alebo rovne 10.') # 3 je menšie alebo rovne 10\nprint('Koniec') # Koniec\n```\n\n- `if... elif... else`\n- moze byt aj viacej podmienok s `elif`\n\n```python\nif podmienka1:\n    urob_nieco_1\nelif podmienka2:\n    urob_nieco_2\nelse:\n    urob_nieco_jine\n```\n\n- vykona sa vzdy iba prvy blok v kt. je splnena podmianka\n\n```python\nx = 8\nif x \u003e 10:\n    print(f'{x} je vacsie ako 10.')\nelif x \u003e 5:\n    print(f'{x} je vacsie ako 5.') # 8 je vacsie ako 5\nelse:\n    print(f'{x} je menšie alebo rovne 5.')\nprint('Koniec') # Koniec\n```\n\n# Cykly\n\n- cyklus `while`\n\n```python\nwhile podmienka:\n    urob_nieco\n```\n\n- jedno prevedenie urob_nieco sa nazyva jedna iterace\n- treba davat pozor na zacyklenie\n\n```python\nslovo = 'ozvena'\nwhile len(slovo) \u003e 0:\n    print(slovo)\n    slovo = slovo[1:]\nprint('Konec')\n# ozvena\n# zvena\n# vena\n# ena\n# na\n# a\n# Konec\n```\n\n# Iterovatelne objekty (iterables)\n\n- objekty, kt. vieme prechadzat po prvkoch (iterovat)\n- napr.\n  - retazce: 'Ahoj' ---\u003e 'A', 'h', 'o', 'j'\n  - zoznamy: 'Dobrý den vsetkym'.split() ---\u003e 'Dobrý', 'den', 'vsetkym'\n- nevieme iterovat: 5, True, 3.14, print ...\n\n- cyklus `for`\n- určeny na iterovanie\n\n```python\nfor i in iterable:\n    urob_nieco(i)\n```\n\n```python\nfor znak in 'abcd':\n    print(znak + '!')\n# a!\n# b!\n# c!\n# d!\n\nfor slovo in 'Toto je pekna veta'.split():\n    print(slovo, len(slovo))\n# Toto 4\n# je 2\n# pekna 5\n# veta 4\n```\n\n# Rozsah, funckia `range()`\n\n- reprezentuje postupnost cisel\n- iterovany objekt\n\n```python\nfor i in range(5):\n    print(i)\n# 0\n# 1\n# 2\n# 3\n# 4\n```\n\n- `for` cyklus a `range()`\n\n```python\nfor i in range(5):\n    print(i, i * 'ha')\n#0\n#1 ha\n#2 haha\n#3 hahaha\n#4 hahahaha\n```\n\n- tri sposoby volania funkcie `range()`\n  - s jednim argumentom `end`\n\nrange(10) ---\u003e 0, 1, 2, 3, 4, 5, 6, 7, 8, 9\n\n- s dvoma argumentami `start`, `end`\n\nrange(3, 10) ---\u003e 3, 4, 5, 6, 7, 8, 9\n\n- s troma argumentami `start`, `end`, `step`\n\nrange(3, 10, 2) ---\u003e 3, 5, 7, 9\n\n- vsetky argumenty musia byt `int` !!!\n- `start` je zahrnuty v rozsahu ale `end` nie je\n\n```python\nfor i in range(-5, 0):\n    print(i, end=' ') # -5 -4 -3 -2 -1\n\nfor i in range(10, 0, -1):\n    print(i, end=' ') # 10 9 8 7 6 5 4 3 2 1\n\nfor i in range(0, -10, -1):\n    print(i, end=' ') # 0 -1 -2 -3 -4 -5 -6 -7 -8 -9\n```\n\n# Riadenie behu cyku pomocou `break` a `continue`\n\n- `continue` ukonci vykonavanie aktualnej iteracie a spusti nasledjucu\n- `break` ukonci vykonavanie celeho cyklu\n\n```python\nfor i in range(6):\n    if i % 2 == 1:\n        continue\n    print(i)\nprint('Konec')\n# 0\n# 2\n# 4\n# Konec\n```\n\n```python\nfor i in range(6):\n    if i % 2 == 1:\n        break\n    print(i)\nprint('Konec')\n# 0\n# Konec\n```\n\n# Riadenie cyklu `for` pomocou `break` a `else`\n\n- pokial cyklus prebehol cely(neukoncil sa pomocou `break`), spusti sa blok `else`\n\n```python\nfor prvok in iterable:\n    delej_nieco ...\n    break\n    ...\nelse:\n    urob_nieco_dalsie\n```\n\n```python\nfor i in range(30, 35):\n    print(i)\n    if i % 11 == 0:\n        print(f'Najdeni nasobok cisla jedenast: {i}')\n        break\nelse:\n    print('Žiadne cislo delitelne 11 sa nenaslo.')\n# 30\n# 31\n# 32\n# 33\n# Najdeni nasobok cisla jedenast: 33\n```\n\n## 4.KOLEKCE\n\n- objekty, kt. obs. strukturne viac hodnot, vsetky kolekce su iterovane objekty\n- zakladne kolekce:\n  - `list` (zoznam) - upravovatelny zoznam zoradenich hodnot, [1, 5, 1]\n  - `tuple` (n-tice) - neupraveny subor zoradenich hodnot so specifickym vyznamom(nechceme menit), (1, 5, 1)\n  - `set` (mnozina) - upravovatelny subor unikatnych hodnot, {1, 5}\n  - `dict` (slovnik) - slovnik nezoradenych hodnot indexovanych pomocou kluca, {'x': 1, 'y': 5}\n- dalsie typy kolekce:\n  - `namedtuple`\n  - `defaultdict`\n  - `OrderedDict`\n  - `Counter`\n  - `frozenset`\n  - `deque`\n  - ...\n\n# Zoznam `list`\n\n- vytvorime ho pomocou:\n\n  - [] z jednotlivych prvkov\n  - funkcii `list` z ineho iterovatelneho objektu\n\n- vieme ho modifikovat narozdiel od retazcov teda: menit, pridavat, odoberat prvky\n- je to najcastejsie pouzivany typ kolekce\n- na poradi zalezi !!!\n- pouzitie:\n  - ked mame viac obdobnych objektov ako zoznam cisel, zoznam studentov\n\n```python\nzoznam = [1, 2, 3, 4, 5]\nzoznam # [1, 2, 3, 4, 5]\n\nzoznam = []\nzoznam # []\n\npismena = list('hello')\npismena # ['h', 'e', 'l', 'l', 'o']\n\ncisla = list(range(5))\ncisla # [0, 1, 2, 3, 4]\n\n[1, 2, 3] == [1, 2, 3] # True\n[1, 2, 3] == [1, 3, 2] # False\n```\n\n- Indexovanie\n\n```python\nzoznam = [1, 2, 3, 4, 5]\nzoznam[2] # 3\n\nzoznam[-1] # 5\n\nzoznam[1:4] # [2, 3, 4]\n\nzoznam[:-2] # [1, 2, 3]\n```\n\n# Operacie so zoznamami\n\n- `len` - dlzka\n- `in`, `not in` - pritomnost prvku\n- `count` - pocet vyskytu prvku\n- `index` - prvi vyskyt prvku\n\n```python\ncisla = [1, 2, 5, 2]\nlen(cisla) # 4\n\n5 in cisla # True\n\ncisla.count(2) # 2\n\ncisla.index(2) # 1\n```\n\n- Zretazenie\n\n```python\n[1, 2] + [5, 2, 8] # [1, 2, 5, 2, 8]\n```\n\n- Opakovanie\n\n```python\n[1, 2] * 3 # [1, 2, 1, 2, 1, 2]\n```\n\n- Matematicke operacie `sum`, `min`, `max`\n\n```python\ncisla = [1, 2, 5, 2]\nsum(cisla) # 10\n\nmin(cisla) # 1\n\nmax(cisla) # 5\n```\n\n- Logicke funkcie `all(vsetky prvky pravdive)` a `any(aspon 1 prvok pravdivy)`\n\n```python\nall([True, True, True, False]) # False\nany([True, True, True, False]) # True\n```\n\n# Modifikacia zoznamu\n\n```python\nzoznam # [1, 2, 3, 4, 5]\n\nzoznam[2] = 8\nzoznam # [1, 2, 8, 4, 5]\n```\n\n- Pridavanie prvkov\n  - metoda `appender(prvok)` - prida novy prvok na koniec\n  - metoda `insert(index, prvok)` - prida prvok na dany index\n  - metoda `extend(iterable)` - prida na koniec zoznamu vsetky prvky z ineho iterovatelneho objektu\n\n```python\nzoznam = [1, 2, 3]\nzoznam # [1, 2, 3]\n\nzoznam.append(4)\nzoznam # [1, 2, 3, 4]\n\nzoznam.insert(2, 10)\nzoznam # [1, 2, 10, 3, 4]\n\nzoznam.extend([1, 2, 3])\nzoznam # [1, 2, 10, 3, 4, 1, 2, 3]\n```\n\n- Odoberanie prvkov\n  - metoda `pop()` - odobere posledny prvok a vrati ho ako vysledok\n  - metoda `pop(i)` - odobere i-ty prvok a vrati ho ako vysledok\n  - metoda `remove(prvok)`- odobere prvy vyskyt prvku\n  - metoda `del` - odstrani prvok\n\n```python\nzoznam # [1, 2, 10, 3, 4, 1, 2, 3]\n\nx = zoznam.pop() # Odstraň a vrať poslední prvek\nprint(zoznam, x) # [1, 2, 10, 3, 4, 1, 2] 3\n\nx = zoznam.pop(2) # Odstraň a vrať druhý prvek\nprint(zoznam, x) # [1, 2, 3, 4, 1, 2] 10\n\nzoznam # [1, 2, 3, 4, 1, 2]\n\nzoznam.remove(2) # Odstraň prvek 2\nzoznam # [1, 3, 4, 1, 2]\n```\n\n- Zmena smeru `reverse()`\n\n```python\nzoznam # [1, 3, 4, 1, 2]\n\nzoznam.reverse()\nzoznam # [2, 1, 4, 3, 1]\n\ndel sesznam[2]\nzoznam # [1, 3, 1, 2]\n```\n\n- Usporiadanie\n  - metoda `sort()` s volitelným parametrom `reverse`\n\n```python\nzoznam = [1, 4, 2, -3, 5, 0]\nzoznam.sort()\nzoznam # [-3, 0, 1, 2, 4, 5]\n\nzoznam.sort(reverse=True)\nzoznam # [5, 4, 2, 1, 0, -3]\n\nzoznam = ['pes', 'mačka', 'slon']\nzoznam.sort()\nzoznam # ['mačka', 'pes', 'slon']\n\nzoznam.sort(key=len)\nzoznam # ['pes', 'slon', 'mačka']\n```\n\n# n-tice `tuple`\n\n- vytvorime ho pomocou:\n  - `()` z jednotlivych prvkov\n  - funkciou `tuple` z ineho iterovatelneho objektu\n- nevieme modifikovat\n- pouzivam ak maju prvky svoj specificky vyznam a nie je nutne modifikovat prvky =\u003e ulice, cislo, mesto\n- indexovanie je rovnake ako u retazcov a zoznamov\n\n```python\nadresa = ('Vlhká', 5, 'Brno')\nadresa # ('Vlhká', 5, 'Brno')\n\nzoznam # ['pes', 'slon', 'mačka']\n\nntice = tuple(zoznam)\nntice # ('pes', 'slon', 'mačka')\n```\n\n- \"Nultice\" =\u003e empty tuple\n\n```python\nnultice = ()\nnultice # ()\n```\n\n- \"Jedince\" =\u003e singleton\n\n```python\njednice = (5,)\njednice # (5,)\n\ncislo = (5)\ncislo # 5\n```\n\n- Pozor na rozdiel medzi \"jedincami\" a samotnym prvkom\n\n```python\n(5,) == 5 # False\n```\n\n# Operace s n-ticemi\n\n- ako u zoznamu\n\n```python\ncisla = (1, 2, 3)\nlen(cisla) # 3\n\nsum(cisla) # 6\n\ncisla.count(8) # 0\n\ncisla + cisla[::-1] # (1, 2, 3, 3, 2, 1)\n\ncisla * 3 # (1, 2, 3, 1, 2, 3, 1, 2, 3)\n```\n\n# Mnozina `set`\n\n- vytvorime ju pomocou:\n  - `{}` z jednotlivych prvkov\n  - funkcie `set` z ineho iterovatelneho objektu\n- vieme ju modifikovat\n\n```python\nmnozina = {1, 2, 3}\nmnozina # {1, 2, 3}\n\nmnozina = set('hello')\nmnozina # {'e', 'h', 'l', 'o'}\n```\n\n- kazdy prvok obsadeny najviac jeden-krat\n\n```python\nzoznam = [1, 1, 2, 3, 3]\nset(zoznam) # {1, 2, 3}\n```\n\n- nevieme indexovat\n\n```python\nmnozina = {1, 2, 3}\nmnozina[0]\n# TypeError Traceback (most recent call last)\n# \u003cipython-input-69-a0d66b3a8e7f\u003e in \u003cmodule\u003e()\n# 1 mnozina = {1, 2, 3}\n# ----\u003e 2 mnozina[0]\n# TypeError: 'set' object does not support indexing\n```\n\n- Poradie nie je dane\n\n```python\n{1, 2, 3} == {3, 2, 1} # True\n```\n\n- prazdna mnozina sa zapisuje `set()`, pretoze {} je zarezervovane pre prazdny slovnik\n\n```python\ntype(set()) # set\n\ntype({}) # dict\n```\n\n# Operacie s mnozinamy\n\n- `len` - pocet prvkov\n- `in`, `not in` - pritomnost prvku (efektivnejsie ako pri zozname lebo nemusia sa kontrolovat vsetky prvky)\n\n```python\nA = {1, 2, 3}\nlen(A) # 3\n\n2 in A # True\n```\n\n```python\nA = {1, 2, 3}\nB = {2, 4, 6}\n\nA \u0026 B # Prienik A ∩ B\n# {2}\n\nA | B # Zjednotenie A ∪ B\n# {1, 2, 3, 4, 6}\n\nA - B # Rozdiel množin A - B (prvky A okrem prvkov B)\n# {1, 3}\n\nA \u003c= B # A je podmnožinou B (A ⊆ B)\n# False\n\nA \u003c B # A je vlastnou podmnožinou B (A ⊂ B)\n# False\n```\n\n- Pridavanie prvkov\n  - metoda `add()`\n\n```python\nA = set()\nA.add(5)\nA.add(6)\nA # {5, 6}\n\nA.add(5)\nA # {5, 6}\n```\n\n- Odoberanie prvkov\n  - metoda `discard(x)` - odoberie prvok `x` (ak tam x nie je nestane sa nic)\n  - metoda `remove(x)` - odoberie prvok `x` (skonci chybou, pokial tam x nie je)\n\n```python\nA = set(range(5))\nA # {0, 1, 2, 3, 4}\n\nA.discard(2)\nA # {0, 1, 3, 4}\n```\n\n- metoda `pop()` - odoberie jeden lubovolny prvok a vrati ho ako vysledok\n- metoda `clear()` - odoberie vsetky prvky\n\n```python\nA # {0, 1, 3, 4}\nx = A.pop()\nx # 0\n\nA # {1, 3, 4}\n\nA.clear()\nA # set()\n```\n\n# Slovnik `dict`\n\n- vytvorime ho pomocou\n  - `{}` z jednotlivych dvojic klucovych hodnot\n  - funkcie `dict` z ineho iterovatelneho objektu\n- slovnik vieme modifikovat\n- kazdy kluc je obsiahnuty najviac jeden-krat\n- indexujeme podla klucu (nie podla poradia)\n\n```python\nslovnik = {'kluc1': 'hodnota1', 'kluc2': 'hodnota2'}\nslovnik # {'kluc1': 'hodnota1', 'kluc2': 'hodnota2'}\n\nslovnik = {} # Prázdný slovník\nslovnik # {}\n\nzoznam_dvojic = [('jack', 4098), ('sape', 4139), ('guido', 4127)]\nslovnik = dict(zoznam_dvojic)\nslovnik # {'guido': 4127, 'jack': 4098, 'sape': 4139}\n```\n\n- Indexovanie pomocou kluca\n\n```python\nslovnik # {'guido': 4127, 'jack': 4098, 'sape': 4139}\n\nslovnik['jack'] # 4098\nslovnik['bob'] # error...\n```\n\n- metoda `get(key, value)` je ako [], ale riesi i chybajuce kluce\n\n```python\nprint(slovnik.get('guido')) # 4127\n\nprint(slovnik.get('bob')) # None\n\nprint(slovnik.get('bob', 'defaultni_hodnota')) # defaultni_hodnota\n```\n\n- Testovanie pritomnosti kluca\n  - u slovnikov sa pomocou `in` dotazujeme na kluce nie na hodnoty\n\n```python\nslovnik = {'a': 1, 'b': 2, 'c': 3, 'd': 4}\n'a' in slovnik # True\n\n1 in slovnik # False\n\n1 in slovnik.values() # True\n```\n\n- Pridanie alebo uprava stavajucich hodnot\n  - pokial kluc nie je v slovniku, prida sa a priradi sa mu hodnota\n  - pokial kluc je vo slovniku, stara hodnota sa zahodi a prida sa nova\n\n```python\nslovnik # {'a': 1, 'b': 2, 'c': 3, 'd': 4}\n\nslovnik['bob'] = 1234\nslovnik # {'a': 1, 'b': 2, 'bob': 1234, 'c': 3, 'd': 4}\n\nslovnik['guido'] = 666\nslovnik # {'a': 1, 'b': 2, 'bob': 1234, 'c': 3, 'd': 4, 'guido': 666}\n```\n\n- metoda `update` - prijma ako parameter dalsi slovnik, ktorym upravim stavajuci\n\n```python\nslovnik # {'a': 1, 'b': 2, 'bob': 1234, 'c': 3, 'd': 4, 'guido': 666}\n\nslovnik.update({'guido': 1111, 'alice': 9876})\nslovnik # {'a': 1, 'alice': 9876, 'b': 2, 'bob': 1234, 'c': 3, 'd': 4, 'guido': 1111}\n```\n\n- metoda `pop` a `clear` ako u zoznamu\n\n# Homegenne a heterogenne kolekce, kolekce v kolekci\n\n- Homegenne kolekce - hodnoty rovnakeho typu [1, 2, 3]\n- heterogenne kolekce - hodnoty zmiesaneho typu [1, 'ahoj', True]\n- kolekce v kolekci\n  - vynimka: Kluce v slovniku a prvky mnozin mozu byt iba nemodifikovatelne objekty\n\n```python\n[1, '2', 3.0, [4, 5], (6, 7)]\n# [1, '2', 3.0, [4, 5], (6, 7)]\n\n{'a': [(1,),(1,2)], 'b': [(2,3),(1,)], 'c': [(9,),(1,)], 'd':[]}\n# {'a': [(1,), (1, 2)], 'b': [(2, 3), (1,)], 'c': [(9,), (1,)], 'd': []}\n```\n\n# Rozbalovanie (unpacking)\n\n- pomocou operatora `*`\n- vytiahneme vsetky prvky z iterovatelneho objektu\n\n```python\nzoznam = [1, 2, 3, 4]\nprint(zoznam) # [1, 2, 3, 4]\n\nrint(*zoznam) # Rovnako ako print(1, 2, 3, 4)\n# 1 2 3 4\n\n[0, zoznam, 5, 6] # [0, [1, 2, 3, 4], 5, 6]\n\n[0, *zoznam, 5, 6] # Rovnako ako [0, 1, 2, 3, 4, 5, 6]\n# [0, 1, 2, 3, 4, 5, 6]\n```\n\n- pomocou viacej premennych na lavej strane priradenia\n\n```python\nzoznam # [1, 2, 3, 4]\n\na, b, c, d = zoznam\na # 1\nb # 2\n\nprvy, druhy, *zbytok, posledni = range(10)\nprvy # 0\ndruhy # 1\nzbytok # [2, 3, 4, 5, 6, 7, 8]\nposledni # 9\n```\n\n# Prechadzanie kolekcie\n\n- pomocou cyklu `for`\n\n```python\nfor prvok in {1, 2, 3, 2}:\nprint(prvok)\n# 1\n# 2\n# 3\n```\n\n- cez kluc\n\n```python\nslovnik = {'guido': 4127, 'jack': 4098}\nfor meno in slovnik:\nprint(meno)\n# guido\n# jack\n```\n\n- cez hodnoty zmiesaneho\n\n```python\nfor telefon in slovnik.values():\nprint(telefon)\n# 4127\n# 4098\n```\n\n- cez kluce a hodnoty\n\n```python\nfor meno, telefon in slovnik.items():\nprint(f'{meno}: {telefon}')\n# guido: 4127\n# jack: 4098\n```\n\n# Chytre prechadzanie kolekci\n\n- funkcia `enumerate()` ocisluje prvky\n\n```python\nmena = ['Bob', 'Alice', 'Cyril']\nfor i, meno in enumerate(mena):\nprint(f'{i}. {meno}')\n# 0. Bob\n# 1. Alice\n# 2. Cyril\n\nfor i, meno in enumerate(mena, 1):\nprint(f'{i}. {meno}')\n# 1. Bob\n# 2. Alice\n# 3. Cyril\n```\n\n- funkcia `reversed()` prechadza od konca\n\n```python\nfor jmeno in reversed(mena):\nprint(meno)\n# Cyril\n# Alice\n# Bob\n```\n\n- funkcia `sorted()` vytvara novy zoradeni zoznam\n\n```python\nfor meno in sorted(mena):\nprint(meno)\n# Alice\n# Bob\n# Cyril\n```\n\n- funckia `zip()` prechadza viac objektami na raz\n\n```python\nfor meno, pismenko in zip(mena, 'XYZW'):\nprint(meno, pismenko)\n# Bob X\n# Alice Y\n# Cyril Z\n```\n\nPOZOR !!! tieto funkcie nevytvaraju kolekce, iba iteratie urceny k jednorazovemu prejdeni prvku\n\n```python\niterator = reversed(mena)\nfor meno in iterator:\nprint(meno)\n# Cyril\n# Alice\n# Bob\n```\n\n# Generator vyrazu (generator expression)\n\n- pomocou `for...in...` [if...] mozeme vytvarat a filtrovat kolekcie\n\n```python\npovodni = [1, 2, 3, 4, 5, 6]\nstr(x) for x in povodni]\n# ['1', '2', '3', '4', '5', '6']\n\n{i: i**2 for i in povodni}\n# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}\n```\n\n- filtrujeme pridanim `if`\n\n```python\n{x for x in povodni if x % 2 == 0}\n# {2, 4, 6}\n```\n\n- typ vyslednej kolekce je dany typom zatvoriek: [zoznam], {mnozina} alebo slovnik\n  - Vynimka: () vytvaraju iterator a nie n-tici\n\n```python\n(x for x in povodni if x \u003e= 3) # iterátor\n# \u003cgenerator object \u003cgenexpr\u003e at 0x7f887c3b09e8\u003e\n\ntuple(x for x in povodni if x \u003e= 3) # n-tice\n# (3, 4, 5, 6)\n```\n\n- funkcia `join()` spojuje prvky pomocou separatoru, funguje ale iba na prvky typu `str`\n\n```python\niterable = ['1', '2', '3']\n' - '.join(iterable)\n# '1 - 2 - 3'\n```\n\n# Vytvaranie noveho objektu vs modifikacie objektu\n\n- vytvaranie noveho objektu:\n\n```python\npovodni = 'Spam spam spam.'\nnovy = povodni.replace('spam', 'ham')\nprint(povodni) # Spam spam spam.\nprint(novy) # Spam ham ham.\n\npovodni = [1, 8, 5, 2]\nnovy = sorted(povodni)\nprint(povodni) # [1, 8, 5, 2]\nprint(novy) # [1, 2, 5, 8]\n```\n\n- modifikacia objektu:\n\n```python\npovodni = [1, 8, 5, 2]\nnovy = povodni.sort()\nprint(povodni) # [1, 2, 5, 8]\nprint(novy) # None\n\npovodni = [1, 8, 5, 2]\nnovy = povodni.append(0)\nprint(povodni) # [1, 8, 5, 2, 0]\nprint(novy) # None\n```\n\n# Rovnake objekty vs ten isty objekt\n\n- Operatory: `==`, `!=` testuju, ci su dva objekty rovnake\n- Operatory: `is`, `is not` testuju, ci sa jedna o ten samy objekt\n- rovnake objekty:\n\n```python\na = [1, 2, 3]\nb = [1, 2, 3]\na == b\n# True\n\na is b # False\n\na.append(4)\nprint(a, b) # [1, 2, 3, 4] [1, 2, 3]\n```\n\n- ten samy objekt:\n\n```python\na = [1, 2, 3]\nb = a\na == b\n# True\n\na is b # True\n\na.append(4)\nprint(a, b) # [1, 2, 3, 4] [1, 2, 3, 4]\n```\n\n- vsetky modifikovatelne kolekce mozem duplikovat pomocou metody `copy()` - vytvorime tak novy objekt\n\n```python\na = [6, 8, 3, 1]\nb = a.copy()\nb.sort()\nprint(a, b) # [6, 8, 3, 1] [1, 3, 6, 8]\n```\n\n## 5. FUNKCIE\n\n- objekt, ktory vieme volat\n- funkcia pri volani:\n  - 1. nieco vezme(argumenty)\n  - 2. nieco urobi\n  - 3. nieco vrati(navratova hodnota)\n- funkcia `print`:\n  - 1. vezme lubovolny pocet argumentov\n  - 2. prevedie vsetky arg. na retazec a vypise ich na vystup\n  - 3. vrati navratovu hodnotu: `None`\n- funkcia `input`:\n  - 1. vezme 0 arg.\n  - 2. pocka na vstup od uzivatela\n  - 3. vrati navratovu hodnotu: retazec zadany uzivatelom\n\nARGUMENTY\n\n- pozicne(positional) - uvadzaju sa ako prve\n- pomenovane(keyword) - vieme prehadzovat\n- napriklad: 3 pozicne:1, 2, 'A' a 2 pomenovane: '-', ';\\n'\n\n```python\nprint(1, 2, 'A', sep='-', end=';\\n')\n# 1-2-A;\n```\n\nMETODY\n\n- normalna funkcia, iba ju inak volame\n- viazu sa ku konkretnemu objektu, kt. je akoby parameter\n\n```python\n'ukazatel'.count('a') # 2\n```\n\n- mozme si vytvarat vlastne funkcie napriklad ked nejaku operaciu vyuzivame casto a nechce sa nam ju neustale pisat alebo chceme iba sprehladnit kod\n- pomcou klucoveho slova `def ...` vytvorime fukciu\n\n- parametre a premenne vytvorene vnutri funkcie existuju IBA TAM!!!\n\n# Navratova hodnota funkcie (return value)\n\n- je to hodnota, kt. je vysledkom volania funkcie\n- ked sa prevedie `return` funkcia skonci a vyskoci ako u `break`\n\n```python\ndef obsah_stvorca(a):\n    print('Počítám obsah štvorca...')\n    S = a**2\n    return S\nS1 = obsah_stvorca(5)\nS1 # 25\n```\n\n- defaultna navratova hodnota:\n  - bez najdenia `return`\n  - navratova hodnota je None\n\n# Parametre a argumenty funkcie\n\n- pri volani funkcie sa arg. dosadzuju do parametru funkcie\n- pocet argumentov musi sediet\n\n- defaultna hodnota parametru:\n  - mozeme nastavit v definicii funkcie pomocou `=`\n\n```python\ndef pozdrav(meno, opakovanie=1):\n    for i in range(opakovanie):\n        print(f'Hello {meno}!')\npozdrav('Bob', opakovanie=3)\n# Hello Bob!\n# Hello Bob!\n# Hello Bob!\n```\n\n# Dokumentacia\n\n- aby bolo jasne, co funkcie robia, je zvykom doplnit `docsstring` na zaciatku funkcie\n- nepovinne, ale uzitocne\n\n```python\ndef objem_valce(r, h):\n    \"\"\"Spočítaj a vrať objem válca o polomeru r a výške h.\"\"\"\n    V = math.pi * r**2 * h\n    return V\n```\n\n# TYPOVE ANOTACIE\n\n- moze oznacit typy parametrov a navratove hodnoty\n- kontorolu vieme urobit pomocou modulu `- m mypy`\n- vyuziva VSCode\n\n```python\nimport math\ndef objem_valca(r: float, h: float) -\u003e float:\n    \"\"\"Spočítaj a vrať objem válca o polomeru r a výške h.\"\"\"\n    V = math.pi * r**2 * h\n    return V\n\nV1 = objem_valca(5, 2)\nprint(V1) # .....\n```\n\n```python\ndef pozdrav(meno: str, opakovanie: int = 1) -\u003e None:\n    \"\"\"Vypiš pozdrav osobe meno opakovany-krát.\"\"\"\n    for i in range(opakovanie):\n        print(f'Hello {meno}!')\n```\n\n- pomocou modulo `typing` mozeme presnejsie specifikovat typy:\n\n```python\ndef min_max_pocet(cisla: list) -\u003e tuple:\n    \"\"\"Vrať najmenší, najvacsie číslo a počet čísel.\"\"\"\n    return (min(cisla), max(cisla), len(cisla))\n```\n\n```python\nfrom typing import Tuple, List\ndef min_max_pocet(cisla: List[float]) -\u003e Tuple[float, float, int]:\n    \"\"\"Vrať najmenší, najvacsie číslo a počet čísel.\"\"\"\n    return (min(cisla), max(cisla), len(cisla))\n```\n\n# Rekurzia\n\n- ked funkcia vola sama seba\n- Pozor!!! hrozi zacyklenie(volanie faktorial(0)) - ukoncim to `Ctrl+C`\n\n```python\ndef faktorial(n: int) -\u003e int:\n    \"\"\"Spočítej faktoriál čísla n.\"\"\"\n    if n == 1:\n        return 1\n    else:\n        return n * faktorial(n - 1)\n\nfaktorial(5) # 120\n```\n\nPRIKLAD REKURZIE\n\n- Platy zamestnancov máme uložene vo slovníkovej strukture rozdelené podla hierarchie\n  univerzity (fakulty, ústavy apod.).\n- Chceme spočítat sučet platov všetkych zamestnancov.\n\n```python\nplaty = {\n    'PrF': {\n        'Biologia': {'Alica': 30, 'Bob': 30},\n        'Chemia': {\n            'Organika': {'Cyril': 35},\n            'Anorganika': {'Dana': 28}\n        },\n        'Fyzika': {'Emil': 27}\n    },\n    'LF': {'Filip': 34, 'Gertruda': 33},\n    'FSpS': {'Hana': 30}\n}\n\ndef rekurzivni_sucet(celek):\n    if isinstance(celek, dict): # Testuje ci cast je typu dict.\n        return sum(rekurzivni_sucet(cast) for cast in celek.values())\n    else:\n        return celek\n\nrekurzivni_sucet(platy) # 247\n```\n\n# Rozbalovanie argumentov (unpacking)\n\n- pozicne =\u003e rozbalim pomocou `*`(z iterovatelneho objektu)\n- pomenovane =\u003e rozbalim pomocou `**`(zo slovnika)\n\n```python\ncisla = [3, 2, 1]\nformatovanie = {'sep': ', ', 'end': '.'}\nprint(*cisla, **formatovanie) # 3, 2, 1.\n\nprint(cisla) # [3, 2, 1]\nprint(*cisla) # Ekvivalentny print(3, 2, 1)\n# 3 2 1\nprint(*cisla, **formatovanie) # Ekvivalentny print(3, 2, 1, sep=', ', end='.')\n# 3, 2, 1.\n```\n\n# Nenasytne parametry\n\n- pokial pouzijete `*` pred nazvom posledneho parametru, tento parameter bude obs. vsetky nadbytocne pozicne arg.\n- pokial pouzijete `**` pred nazvom posledneho parametru, tento parameter bude obs. vsetky nadbytocne klucove arg.\n\n```python\ndef foo(a, b, *args, **kwargs):\n    print(a)\n    print(b)\n    print(args)\n    print(kwargs)\n\nfoo(1, 2, 3, 4, 5, 6, x=100, y=200)\n# 1\n# 2\n# (3, 4, 5, 6)\n# {'x': 100, 'y': 200}\n```\n\n# Anonymna funkcia `lambda`\n\n- vytvorenie funkcie bez mena\n\n```python\nstudenti = [('Alice', 'Nováková'), ('Cyril', 'Veselý'), ('Bob', 'Marley')]\nsorted(studenti) # Zoraduje podla krsneho mena\n# [('Alice', 'Nováková'), ('Bob', 'Marley'), ('Cyril', 'Veselý')]\n#---------------------------------------------------------------------------\n\ndef priezvysko(osoba):\n    return osoba[1]\nsorted(studenti, key=prijmeni) # Zoraduje podla priezvyska\n# [('Bob', 'Marley'), ('Alice', 'Nováková'), ('Cyril', 'Veselý')]\n```\n\n- ekvivalent bez pomenovanych funkcii:\n\n```python\nsorted(studenti, key = lambda osoba: osoba[1]) # Zoraduje podla priezvyska\n# [('Bob', 'Marley'), ('Alice', 'Nováková'), ('Cyril', 'Veselý')]\n```\n\n# Generatorove funkcie (generatir functions)\n\n- navratova hodnota je `generator`, co je typ iteratoru\n- generuje hodnoty az kym je nutne\n  - jednu hodnotu vyziadame pomocou funkcie `next`\n  - viacej hodnout pomocou `for` cyklu\n- generovane hodnoty sa v tele funkcie uvadzaju slovom `yield` namiesto `return`\n\n```python\n# Generátorová funkce\ndef ozvena(slovo):\n    while len(slovo) \u003e 0:\n        yield slovo\n        slovo = slovo[1:]\ngenerator = ozvena('ahoj') # Vytvorime generátor\ngenerator # \u003cgenerator object ozvena at 0x7fd18c493830\u003e\n\nnext(generator) # Vygenerujeme 1. hodnotu\n# 'ahoj'\n\nfor s in generator: # Vygenerujeme zvysne hodnoty\nprint(s)\n# hoj\n# oj\n# j\n\nfor s in generator: # Generátor se už vyčerpal, nevypíše se nic\nprint(s)\n```\n\n- generator moze generovat i nekonecno postupnosti(nie je to problém, pretože\n  hodnoty se generují až ked je potreba)\n\n```python\ndef parne_cisla():\n    i = 2\n    while True:\n        yield i\n        i += 2\nenerator = parne_cisla()\ngenerator # \u003cgenerator object parne_cisla at 0x7fd18c3c56d0\u003e\n\nfor x in generator:\n    print(x)\n    if x \u003e= 10:\n        break\n# 2\n# 4\n# 6\n# 8\n# 10\n```\n\n- funkcia `iter` urobi z akelkolvek iterovatelneho objektu iterator\n\n```python\niterator = iter('ahoj')\niterator # \u003cstr_iterator at 0x7fd18c3bd828\u003e\n\nnext(iterator) # 'a'\nnext(iterator) # 'h'\n\nfor x in iterator:\n    print(x)\n# o\n# j\n```\n\n## 6. CHYBY A TESTOVANIE + DEBAGOVANIE\n\n3 zakladne typi:\n\n- `Syntakticke chyby` program nie je vobec spusteny\n- `Vynimky` program bezi, ale nastane chyba v priebehu vyjonavania\n- `Systematicke chyby` z pohladu Python je vsetko v poriadku, program bezi bez chyb, ale nerobi to, co chceme\n\n# Syntakticke chyby\n\n- zle odsadenie, chybajuce alebo nadbytocne zatvroky, dvojbodky...\n\n```python\nif True:\nprint(\"Hello World!\") # Chyba odsadenie\n\n# File \"\u003cipython-input-1-97322b684b0b\u003e\", line 2\n# print(\"Hello World!\") # Chyba odsadenie\n# ^\n# IndentationError: expected an indented block\n```\n\n- casto sa chyba odhali az na nasledujucom riadku\n\n```python\nimport math\na = abs(math.sqrt((10 - 5)**2) # Chyba koniec zátvorky\nprint(a)\n\n# File \"\u003cipython-input-3-143e81d33c6d\u003e\", line 3\n# print(a)\n# ^\n# SyntaxError: invalid syntax\n```\n\n# Vynimky\n\n- za behu programu(runtime) sa zisti, ze nieco nejde vykonat -\u003e vyhodi sa vynimka\n- typ vynimky uprestnuje preco to nejde:\n  - [Typy_vynimiek](https://docs.python.org/3/library/exceptions.html)\n  - vacsina knihovien obs. vlastne\n  - vieme zadefinovat vlastne\n- bezne typi vynimiek:\n  - `NameError` - snazime sa pouzit premennu, kt. neexistuje\n  ```python\n  print(b)\n  ```\n  - `TypeError` - snazime sa urobit nieco s hodnotou zleho typu\n  ```python\n  'abc' + 5\n  ```\n  - `ZeroDivisionError` - snazime sa delit nulou\n  ```python\n  x = 5\n  y = 1 / (x - 5)\n  ```\n  - `IndexError` - index je mimo rozsah\n  ```python\n  cisla = [1, 2, 8]\n  cisla[3]\n  ```\n  - `KeyError` - kluc chyba vo slovniku\n  ```python\n  slovnik = {'a': 1, 'c': 4}\n  slovnik['b']\n  ```\n  - `ValueError` - davame funkcii spravneho typu ale zlu hodnotu\n  ```python\n  int('12a')\n  ```\n  - `StopIteration` - chceme dalsiu hodnotu od iteratoru, kt. sa uz vycerpal\n  ```python\n  iterator = reversed('ab')\n  next(iterator)\n  next(iterator)\n  next(iterator)\n  ```\n  - `RecursionError` - rekurzivna funkcia sa zacyklila\n  ```python\n    def factorial(n):\n  return n * factorial(n-1)\n  factorial(5)\n  ```\n  **Traceback** popisuje kde nastala vynimka a ako sa tam program dostal\n\n```python\ndef foo(cisla):\n    for x in cisla:\n        print(podiel(1, x))\ndef podiel(a, b):\n    return a / b\nfoo([3, 2, 0])\n\n# 0.3333333333333333\n# 0.5\n# ---------------------------------------------------------------------------\n# ZeroDivisionError Traceback (most recent call last)\n# \u003cipython-input-6-2159f2a70615\u003e in \u003cmodule\u003e()\n# ----\u003e 1 foo([3, 2, 0])\n# \u003cipython-input-4-ba5814e3052f\u003e in foo(cisla)\n# 1 def foo(cisla):\n# 2 for x in cisla:\n# ----\u003e 3 print(podiel(1, x))\n# \u003cipython-input-5-0a3c1262fa57\u003e in podiel(a, b)\n# 1 def podiel(a, b):\n# ----\u003e 2 return a / b\n# ZeroDivisionError: division by zero\n```\n\n**Osetrenie vynimky** ked sa vieme s konkretnou vynimkou nejako vyrovnat, odchytime ju pomocou bloku `try... except`\n\n```python\nimport math\ndef podiel(a, b):\n  print(f'Počita sa {a}/{b}...')\n  try:\n    c = a / b\n    print('Delenie prebehlo bez problémov')\n    return c\n  except ZeroDivisionError:\n    print('Delenie nulou ¯\\_(ツ)_/¯')\n    return math.nan # Not-a-number\n\npodiel(5, 2)\n\n# Počítá se 5/2...\n# Delenie prebehlo bez problemov\n# 2.5\n#---------------------------------------------\npodiel(5, 0)\n\n# Počítá se 5/0...\n# Delenie nulou ¯\\_(ツ)_/¯\n# nan\n```\n\n**Kombinacia vynimiek**\n\n```python\ntry:\n  menovatel = int(input())\n  vysledok = 1 / menovatel\n  print(f'OK: {vysledok}')\nexcept ZeroDivisionError:\n  print('Nulov nevieme delit!')\nexcept ValueError:\n  print('Nemozeme previest zadany vstup na cislo!')\nexcept (RuntimeError, TypeError, NameError):\n  pass # ako by sa chyba nestala\nexcept:\n  print('Chyba vole!')\n  raise # výjimka se znovu vyvolá\n\n# tisíc\n# Nemozeme previest zadany vstup na cislo!\n```\n\n`try... except... else... finally`\n\n```python\ndef podiel(a, b):\n  try:\n    c = a / b\n  except ZeroDivisionError:\n    print('Nulov sa neda delit')\n    c = math.inf\n  else:\n    print('Prebehlo bez výjimky!')\n  finally:\n    print('Ja sa prevediem stale')\n    return c\n\npodiel(5, 2)\n\n# Proběhlo bez výjimky!\n# Ja sa prevediem stale\n# 2.5\n#-------------------------------------------------------------\npodiel(5, 0)\n\n# Nulov sa neda delit\n# Ja sa prevediem stale\n# inf\n```\n\n**Vyhodenie vynimky**\n\n- pomocou `raise`\n- vytvorime:\n  - TypVyjimky()\n  - TypVyjimky('Chybová hláška')\n\n```python\ndef faktorial(n):\n  if n \u003e= 0:\n    vysledok = 1\n    for i in range(1, n+1):\n      vysledok *= i\n    return vysledok\n  else:\n    raise ValueError('Neda sa spočítat faktoriál záporného čísla.')\nfaktorial(10)\n\n# 3628800\n#----------------------------------------------------------------\nfaktorial(-5)\n# ---------------------------------------------------------------------------\n# ValueError Traceback (most recent call last)\n# \u003cipython-input-16-3635df1c3214\u003e in \u003cmodule\u003e()\n# ----\u003e 1 faktorial(-5)\n# \u003cipython-input-14-a68bea9aa445\u003e in faktorial(n)\n# 6 return vysledok\n# 7 else:\n# ----\u003e 8 raise ValueError('Neda sa spočítat faktoriál záporného čísla.')\n# ValueError: Neda sa spočítat faktoriál záporného čísla.\n```\n\n**return** vs **raise**\n\n- obe ukoncuju beh funkcie\n- `return x` - uspesne ukoncenie, vrati sa navratova hodnota x\n- `raise x` - neuspesne ukoncenie, vyhodi sa vynimka\n\n```python\ndef fluffy(n):\n  if n == 0:\n    return 'OK'\n  elif n == 1:\n    return ValueError(n)\n  else:\n    raise ValueError(n)\n\nfluffy(0)\n# 'OK'\n#------------------------------------------\nfluffy(1)\n# ValueError(1)\n#------------------------------------------\nfluffy(2)\n# ---------------------------------------------------------------------------\n# ValueError Traceback (most recent call last)\n# \u003cipython-input-20-6396b24bbeda\u003e in \u003cmodule\u003e()\n# ----\u003e 1 fluffy(2)\n# \u003cipython-input-17-eb6aa5feffc2\u003e in fluffy(n)\n# 5 return ValueError(n)\n# 6 else:\n# ----\u003e 7 raise ValueError(n)\n# ValueError: 2\n```\n\n- iba `raise` vieme vyuzit v bloku `except` - opat vyhadzuje odchytenu vynimku\n\n```python\ndef podiel(a, b):\n  try:\n    return a / b\n  except:\n    print('Nastala výnimka.')\n    raise\n\npodiel(5, 0)\n# Nastala výjimka.\n# ---------------------------------------------------------------------------\n# ZeroDivisionError Traceback (most recent call last)\n# \u003cipython-input-22-f4456981ee1c\u003e in \u003cmodule\u003e()\n# ----\u003e 1 podiel(5, 0)\n# \u003cipython-input-21-e839663917b1\u003e in podiel(a, b)\n# 1 def podiel(a, b):\n# 2 try:\n# ----\u003e 3 return a / b\n# 4 except:\n# 5 print('Nastala výnimka.')\n# ZeroDivisionError: division by zero\n```\n\n# Testovanie\n\n- umoznuje automaticky skontrolovat, ci sa funkcia chova tak ako ocakavame\n- `Test` = popis ocakavaneho chovania na konkretnom vstupe\n- Vysledkom testu:\n  - `pass` test presiel, chova sa podla ocakavania `:)`\n  - `fail` test nepresiel, chova sa inak `:(`\n- moduly na testovanie: `doctest`, `pytest`...\n\n**Doctest**\nTesty v dokumentacii funkcie\n\n- vyzeraju ako interaktivny Python\n- popisuju, ako sa ma funkcia chovat na konkretnych vstupoch\n- modul `doctest` kontroluje, ci sa funkcia chova tak ako to popisuju testy\n- [viac_tu](https://docs.python.org/3/library/doctest.html)\n\n```python\ndef sucet(a, b):\n  \"\"\" Vracia sučet parametrov.\n  \u003e\u003e\u003e sucet(1, 2)\n  3\n  \u003e\u003e\u003e sucet(10, 2)\n  12\n  \"\"\"\n  return 3\n\nimport doctest\ndoctest.testmod()\n**********************************************************************\nFile \"__main__\", line 5, in __main__.sucet\nFailed example:\nsucet(10, 2)\nExpected:\n12\nGot:\n3\n**********************************************************************\n1 items had failures:\n1 of 2 in __main__.sucet\n***Test Failed*** 1 failures.\n# TestResults(failed=1, attempted=2)`\n```\n\n- spustenie doctestu z prikazoveho riadku:\n\n```\n- $ python3 -m doctest moj_skript.py\n```\n\n- i ked prejdu vsetky testy neznamena to ze funkcia je spravna!\n\n```python\ndef sucet(a, b):\n  \"\"\" Vracia sučet parametrov.\n  \u003e\u003e\u003e sucet(2, 2)\n  4\n  \u003e\u003e\u003e sucet(0, 0)\n  0\n  \"\"\"\n  return a * b\n\nimport doctest\ndoctest.testmod()\n# TestResults(failed=0, attempted=2)\n```\n\n**Pytest**\n\n- prechadza vsetky subory a zlozky `test*`\n- pouziva `assert` pre validaciu\n- [viac_tu](https://docs.pytest.org/en/latest/ 'https://docs.pytest.org/en/latest/')\n- `inc.py`\n\n```python\ndef inc(x):\n  return x + 1\n```\n\n- `test_inc.py`\n\n```python\ndef test_answer():\n  assert inc(3) == 5\n```\n\n**pytest - fixure a parametrize**\n\n```python\nimport pytest\n@pytest.mark.parametrize(\"test_input,expected\", [\n    (\"3+5\", 8),\n    (\"2+4\", 6),\n    (\"6*9\", 42),\n])\n\ndef test_eval(test_input, expected):\n    assert eval(test_input) == expected\n```\n\n## 7. PRACA SO SUBORMI\n\n`Subor` - sada informacii ulozenych pod konkretnym menom na datovom mediu, kazdy je ulozeny v nejakom formate\n\n- `textovy` (TXT, DOCX, HTML...)\n- `binarny` (ZIP, JPEG, MPEG4...)\n  !!!Poznamka - textovy subor je vlastne binarny subor, kde kazdy bajt(skupina bajtov) koduje nejaky znak. Rozdiel je v tom, ako bude subor citat.\n\n### Textove subory\n\n- subory tvorene postupnost znakov\n- `stream`, `file handler`, `file object` - je objekt, kt. nam ukazuje na koknretny subor a konkretne miesto v subore\n\n```python\nopen(file, mode=\"r\", encoding=None, ...)\n```\n\n## Zakladne operacie so suborom\n\n- otvorenie `open()`\n- citanie `read()`\n- zapis `write()`\n- zatvorenie `close()` = umoznuje zmeny na disk\n\n## Otvaranie a zatvaraie suboru\n\n1. Explicitne - nedoporucuje sa (hrozi, ze zabudneme subor zatvorit a zmeny sa neulozia)\n\n```python\nf = open('my_file.txt')\n# Pracujeme so suborom ...\n# Pracujeme so suborom ...\nf.close()\n```\n\n1. Pomocou bloku `with` - doporuceny sposob (subor sa zavrie automaticky na konci bloku)\n\n```python\nwith open('my_file.txt') as f:\n# Pracujeme so suborom ...\n# Pracujeme so suborom ...\n# Tu sa subor automaticky zavrie\n```\n\n- funkcia `open` - otvorime stream do suboru a mozeme s nim dalej pracovat\n  Argumenty:\n  - umiestnenie suboru (`path`)\n  - mozeme upresnit mod, kodovanie...\n    Navratova hodnota:\n  - `File object` - popisuje, kt. subor je otvoreny, ukazatel na konkretne miesto suboru, modu, kodovania...\n\n```python\nwith open('skarabeus.txt', mode='r', encoding='utf8') as f:\n    print(f)\n# \u003c_io.TextIOWrapper name='skarabeus.txt' mode='r' encoding='utf8'\u003e\n```\n\n# Mod otvarania textovych suborov - citame a zapisuje znaky `str()`\n\n- `r`: pre citanie `(read)` - defaultny mod\n  - subor neexistuje -\u003e `FileNotFoundErrror`\n  - subor existuje -\u003e cita ho od zaciatku\n- `r+` pre citanie a zapis\n  - subor neexistuje -\u003e `FileNotFoundException`\n  - subor existuje -\u003e cita/zapisu od zaciatku\n- `w`: pre zapis `(write)`\n  - subor neexistuje -\u003e vytvori ho\n  - subor existuje -\u003e **premaze** a zapisuje od zaciatku!\n- `w+` pre citanie a zapis\n  - subor neexistuje -\u003e vytvori ho\n  - subor existuje -\u003e premaze a cita/zapisuje od zaciatku\n- `x`: pre zapis\n  - subor neexistuje -\u003e vytvori ho\n  - subor existuje -\u003e `FileExistsError`\n- `a`: pre zapis `(append)`\n  - subor neexistuje -\u003e vytvori ho\n  - subor existuje -\u003e doplnuje na koniec\n\n**Citanie z textoveho suboru**\n\n- funguje iba v modoch `r`, `r+`, `w+`\n- metoda `read()` precita cely subor (bez argumentu) alebo dany pocet znakov (s argumentom)\n  - vrati nacitany subor\n- po zatvoreni suboru uz sa neda citat\n\n```python\nwith open('skarabeus.txt', mode='r') as f:\n    text = f.read()\ntext\n# 'Vruboun posvátný (Scarabaeus sacer), označovaný také jen krátce skarabeus či\n# skarab, je brouk z čeledi vrubounovití (Scarabaeidae). Žije ve Středomoří. Sam\n# ička naklade larvy do kuličky uhnětené z trusu, kterou posléze zahrabe do zem\n# ě. Vyvíjející se larva se živí trusem.\\n'\n```\n\n```python\nwith open('skarabeus.txt', mode='r') as f:\n    prvych_20_znakov = f.read(20)\n    zbytok = f.read()\nprvych_20_znakov # 'Vruboun posvátný (Sc'\nzbytok\n# 'arabaeus sacer), označovaný také jen krátce skarabeus či skarab, je brouk z č\n# eledi vrubounovití (Scarabaeidae). Žije ve Středomoří. Samička naklade larvy d\n# o kuličky uhnětené z trusu, kterou posléze zahrabe do země. Vyvíjející se larv\n# a se živí trusem.\\n'\n```\n\n- metoda `readline()` nacita jeden riadok zo suboru ako retazec\n- pokial sme uz na konci suboru, vrati sa prazdny retazec `' '`\n\n```python\nwith open('nakup.txt', mode='r') as f:\n    prvy = f.readline()\n    druhy = f.readline()\n    treti = f.readline()\n    stvrty = f.readline()\nprvy #'chleba\\n'\ndruhy #'jogurt\\n'\ntreti #'\\n'\nstvrty #''\n```\n\n- riadok sa nacita vzdy so znakom noveho riadku na konci - tohoto sa zbavime pomocou metody `rstrip()`\n\n```python\nwith open('nakup.txt', mode='r') as f:\n    prvy = f.readline()\nprvy # 'chleba\\n'\nprvy.rstrip() # 'chleba'\n```\n\n- metoda `readlines()` nacita vsetky riadky (od aktualnej pozicie) ako zoznam\n\n```python\nwith open('nakup.txt', mode='r') as f:\n    riadky = f.readlines()\nriadky # ['chleba\\n', 'jogurt\\n', '\\n']\n```\n\n## Citanie suboru pomocou `for`\n\n```python\nwith open('nakup.txt', mode='r') as f:\n    for riadok in f:\nprint(riadok)\n# chleba\n# jogurt\n```\n\n## Zapis do textoveho suboru\n\n- funguje iba v modoch `w`, `x`, `a`, `r+`, `w+`\n- metoda `write()` zapise retazec do suboru\n  - vrati pocet zapisanych znakov\n- na koniec nevklada automaticky novy riadok, ako u `print()`\n- po zavreni suboru uz nevieme zapisovat\n\n```python\nwith open('novy.txt', mode='w') as f:\n    f.write('Alica')\n    f.write('Bob')\n    f.write('Cyril')\nwith open('novy.txt', mode='r') as f:\n    text = f.read()\ntext # 'AlicaBobCyril'\n```\n\n- funkcia `print()` vieme presmerovat do suboru\n\n```python\nwith open('novy.txt', mode='w') as f:\n    print('Alica', 10, True, file=f)\nwith open('novy.txt', mode='r') as f:\n    text = f.read()\ntext # 'Alice 10 True\\n'\n```\n\n- mozeme otvarat niekolko suborov sucastne\n\n```python\nwith open('nakup.txt', mode='r') as fr:\n    with open('novy.txt', mode='w') as fw:\n        for radek in fr:\n            fw.write(radek.strip())\n            fw.write(';')\nwith open('novy.txt', mode='r') as f:\n    text = f.read()\ntext # 'chleba;jogurt;;'\n```\n\n## Metody `tell` a `seek`\n\n- metoda `tell()` vracia aktualnu poziciu ukazovatela, `seek()` nastavuje poziciu ukazovatela\n\n```python\nwith open('nakup.txt') as f:\n    print(f.tell()) # 0\n    print(f.readline().rstrip()) # chleba\n    print(f.tell()) # 7\n    print(f.readline().rstrip()) # jogurt\n    print(f.tell()) # 14\n\nwith open('nakup.txt') as f:\n    f.seek(7)\n    print(f.readline().rstrip()) # jogurt\n```\n\n## Specialne \"subory\"\n\n- `sys.stdin` - cita zo standardneho vstupu\n- `sys.stout` - zapisuje na standardny vystup\n- `sys.stderr` - zapisuje na standardny chybovy vystup\n\n## Kodovanie suborov `(encoding)`\n\n- v suboroch realne nie su ulozene znaky ale iba bajty\n- kodovanie popisuje, ako sa znaky zakoduju do bajtov `encode` a spat `decode`\n- ak natvarim subor a vidim, ze znaky sa mi neyhoduju napr. pri makkych spoluhlaskach tak mam zle nastavene kodovanie\n- priklady zleho kodovania:\n\n```python\nwith open('skarabeus.txt', encoding = 'windows-1250') as f:\n    text = f.read()\ntext\n# 'Vruboun posvátnĂ˝ (Scarabaeus sacer), oznaÄŤovanĂ˝ takĂ© jen krátce skarabe\n# us ÄŤi skarab, je brouk z ÄŤeledi vrubounovitĂ\\xad (Scarabaeidae). Ĺ˝ije ve St\n# Ĺ™edomoĹ™Ă\\xad. SamiÄŤka naklade larvy do kuliÄŤky uhnÄ›tenĂ© z trusu, kterou\n# poslĂ©ze zahrabe do zemÄ›. VyvĂ\\xadjejĂ\\xadcĂ\\xad se larva se ĹľivĂ\\xad truse\n# m.\\n'\n```\n\n- defaultne kodovanie zavisi na systeme\n\n```python\nimport locale\nlocale.getpreferredencoding()\n# 'UTF-8'\n```\n\n- priklady kodovania:\n  - `windows-1250. cp1250` - stredoeuropske\n  - `windows-1252 (cp1252)` - zapadoeuropske\n  - `iso-8859-2, latin2`\n  - `UTF-8(utf8)` - najmodernejsie, dokaze zakodovat celu znakovu sadu **Unicode** (niektore znaky sa ukladaju na viacej bajtov)\n- znaky `ASCII`(prvych 128 znakov z Unicode) sa koduje rovnako vo vacsine kodovania\n\n## Ukoncenie riadku\n\n- Unix(Linux a MacOS) ukoncuje riadky jednim znakom `\\n`\n- Windows ukoncuje riadky dvojicou znakov `\\r\\n`\n\n# NA CO SI DAT POZOR\n\n1. kodovanie suboru\n2. riadky vzdy koncia bielimy znakmi (NAJCASTEJSIE `\\n`), preto je vhodne pouzivanie metod `rstrip()` alebo `strip()`\n3. vzdy musite ukladat retazec, vzdy citat retazec\n4. pokial subor zavriete, uz s nim nemozte dalej pracovat (read, write); jedine ze si ho znohu otvorite\n5. pokial subor otvorite v mode `w`, hrozi strata dat - sucasny subor je ihned nenavratne prepisany novym prazdnym suborom\n\n## Binarne subory\n\n- subor tvoreny postupnosti bajtov\n- namiesto retazcov `(str)` citame a zapisujeme bajty `(bytes)`\n- binarene mody otvorenia: `rb`, `wb`, `xb`, `ab`, `r+b`, `w+b`\n- metoda `read()` vracia typ bytes\n- metoda `write()` berie typ bytes\n\n```python\nwith open('funny_cat.gif', mode='r+b') as f:\n    obsah = f.read(100)\nobsah\n# b'GIF89a\\xe0\\x01\\xe0\\x01\\xf7\\xff\\x00\\x11\\r\\x08\\x12\\x0f\\x0b\\x15\\x12\\x0e\\x1a\\x12\n# \\x0b\\x1a\\x15\\x0f\\x1b\\x18\\x14!\\x1c\\x17#\\x12\\x08#\\x19\\x0f% \\x19(#\\x1f)\\x18\\r)\\x1\n# c\\x15,\"\\x18.\\'!2\\x1a\\x0e4!\\x124$\\x195)!6/(7*\\x1a8.\"94+?%\\x19?,\\x1d?1\\x1e@1%A9.\n# D2%'\n```\n\n## Moduly `(module)`\n\n- subor funkcii a premennych, ktore vieme importovat\n\n```python\nimport math\nmath # \u003cmodule 'math' (built-in)\u003e\nmath.cos(0) # 1.0\nmath.pi # 3.141592653589793\n```\n\n### Balicek `(package)`\n\n- modul obsahujuci dalsie moduly (zlozka s modulmy)\n\n```python\nimport os\nos # \u003cmodule 'os' from '/usr/lib/python3.6/os.py'\u003e\n\nimport os.path\nos.path # \u003cmodule 'posixpath' from '/usr/lib/python3.6/posixpath.py'\u003e\n```\n\n### Import pomocou `from` a `as`\n\n`from` - importuje modul z balicka alebo premennu (funkciu) z modulu\n`as` - premenovanie importovaneho modulu/premennej/funkcie\n\n```python\nfrom os import path\npath # \u003cmodule 'posixpath' from '/usr/lib/python3.6/posixpath.py'\u003e\n\nimport numpy as np\nnp # \u003cmodule 'numpy' from '/home/adam/.local/lib/python3.6/site-packages/numpy/__in\n# it__.py'\u003e\n\nfrom math import factorial as fact\nfact(6) # 720\n```\n\n### Spustenie modulu ako scriptu\n\n- z prirodzenej riadky pomocou prepinaca `-m`\n\n```\n$ python3 -m doctest\n```\n\n### Zdroje modulu/balickov\n\n- standardna knihovna Pythonu\n  - moduly pritomne pri instalacii\n  - `math`, `os`, `sys`...\n  - [library](https://docs.python.org/3.7/library/)\n- `PyPI` - Python Package Index\n  - moduly doinstalovatelne napr. pomocou nastroja `pip`\n  - numpy, sklearn...\n  - [pypi](https://pypi.org/)\n- vlastne moduly\n  - kazdy pythonovsky skript vieme importovat ako modul\n\n## Pip\n\n- modul sluzi ku stahovaniu a doinstalovaniu balicku z `PyPI`\n- spustame ho vzdy z prikazoveho riadku pomocou `-m` (nesmie sa importovat)\n\n```python\n$ python3 -m pip install numpy # Nainstaluj balíček numpy\n$ python3 -m pip show numpy # Vypiš verziu a info o nainstalovanom balíčku\n$ python3 -m pip search sound # Vyhladaj balíčky suvisiace so zvukom\n$ python3 -m pip list # Vypiš zoznam nainstalovaných balíčkov\n$ python3 -m pip help # Vypiš nápovedu k pipu\n```\n\n## Vlastne moduly\n\n- mame dlhy program -\u003e mozeme ho roztriedit na viac modulov\n  - z hlavneho skriptu (**main**) potom importujeme ostatne moduly\n  - rovnaky modul vieme importovat do viacerych skriptov alebo do dalsich modulov\n- subor ukazkovej_moduly/obsahy.py:\n\n```python\n\"\"\"\nModul pre výpočet obsahu rozných geometrických útvarov.\n\"\"\"\nimport math\n\ndef obsah_obdlzniku(a: float, b:float) -\u003e float:\n    \"\"\"Vrať obsah obdlzniku o stranách a, b.\"\"\"\n    return a * b\n\ndef obsah_stvorca(a: float) -\u003e float:\n    \"\"\"Vrať obsah stvorca o strane a.\"\"\"\n    return a**2\n\ndef obsah_kruhu(r: float) -\u003e float:\n    \"\"\"Vrať obsah kruhu o polomere r.\"\"\"\n    return math.pi * r**2\n#-------------------------------------------------\nfrom ukazkove_moduly import obsahy\nobsahy.obsah_stvorca(5.0) # 25.0\n```\n\n- subor ukazkove_moduly/fibonacci.py:\n\n```python\n\"\"\"\nModul pre generovánie Fibonacciho postupnosti.\n\"\"\"\nfrom typing import List\n\ndef fib(n: int) -\u003e List[int]:\n    \"\"\"Vrať prvych n prvkov Fibonacciho postupnosti.\"\"\"\n    result = []\n    a, b = 1, 1\n    while len(result) \u003c n:\n        result.append(a)\n        a, b = b, a+b\n    return result\n\ndef main() -\u003e None:\n    \"\"\"Interaktivny výpis Fibonacciho postupnosti.\"\"\"\n    pocet = int(input('Zadej požadovaný počet prvků: '))\n    postupnost = fib(pocet)\n    print(*postupnost, sep=', ')\n\nif __name__ == '__main__':\nmain()\n```\n\n- tento blok sa vykona, iba ak modul spustime ako script\n- ked modul importujeme, tento blok sa nevykona\n- toto funguje vdaka tomu, ze pokial je modul importovany, v magickej premennej `__name__` je nazov modulu; pokial je spusteny ako script, v premennej `__name__je '__main__'`\n\n```python\nif __name__ == '__main__':\n```\n\n- import:\n\n```python\nfrom ukazkove_moduly import fibonacci as fib\nfib.fib(10) # [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n```\n\n- spustenie z prikazoveho riadku:\n\n```\n$ python3 ukazkove_moduly/fibonacci.py\n\nzadaj požadovaný počet prvkov: 10\n1, 1, 2, 3, 5, 8, 13, 21, 34, 55\n```\n\n## Uzitocne moduly\n\n- [standardnaknihovna](https://docs.python.org/3.7/library/ 'https://docs.python.org/3.7/library/')\n- [PythonPackageIndex](https://pypi.org/ 'https://pypi.org/')\n\n1. Modul `math` - matematicke funkcie\n2. Modul `cmath` - matematicke funkcie nad komplexnimi cislami\n3. Modul `random` - generovanie pseudo-nahodnych cisel\n\n```python\nimport random\nrandom.random() # Náhodné reálné číslo z intervalu [0, 1]\nrandom.randint(0, 100) # Náhodné celé číslo z intervalu [0, 100]\nrandom.choice(['červená', 'zelená', 'modrá', 'čierna']) # Náhodný výber\n```\n\n4. Modul `datetime` - praca s casovymi udajmi\n\n- zakladne typy:\n  - `datetime` - datum + cas\n  - `timedelta` - trvanie\n  - `date` - datum\n  - `time` - cas\n  - `timezone` - casova zona\n\n```python\nfrom datetime import datetime, timedelta\n\nzaciatok = datetime.now()\nmath.factorial(1000000)\nkoniec = datetime.now()\ndlzka_vypoctu = koniec - zaciatok\nprint(dlzka_vypoctu)\n# 0:00:05.916388\n#-----------------------------------------\ndnes = datetime.now().date()\nza_tyzden = dnes + timedelta(weeks=1)\nprint(dnes) # 2019-11-18\nprint(za_tyzden) # 2019-11-25\n\nza_tyzden.strftime('%A, %d. %B %Y') # 'Monday, 25. November 2019'\n```\n\n```python\nfrom datetime import datetime\ndatetime.strptime('1. 7. 2000, 13:30:05', '%d. %m. %Y, %H:%M:%S')\n# datetime.datetime(2000, 7, 1, 13, 30, 5)\n```\n\n5. Modul `itertools` - rozne moznosti iterovania\n\n```python\nimport itertools\nfor dvojice in itertools.combinations(['bílá', 'zelená', 'modrá', 'černá'], 2):\n    print(*dvojice)\n# biela zelená\n# biela modrá\n# biela čierná\n# zelená modrá\n# zelená čierná\n# modrá čierná\n\nfor pismeno, cislo in itertools.zip_longest('ABCDE', [1, 2, 3], fillvalue='?'):\n    print(pismeno, cislo)\n# A 1\n# B 2\n# C 3\n# D ?\n# E ?\n```\n\n6. Modul `sys` - funkcie zavisle na systeme\n\n```python\nimport sys\nsys.version # Verzia interpretru\n# '3.6.8 (default, Oct 7 2019, 12:59:55) \\n[GCC 8.3.0]'\n```\n\n- sys.argv - zoznam argumentov z prikazoveho riadku\n  - nulty argument = nazov argumentu\n- subor ukazkove_moduly/suma.py:\n\n```python\nimport sys\n\nprint(sys.argv)\nsuma = sum(int(x) for x in sys.argv[1:])\nprint(suma)\n```\n\n- spustenie z prikazovej riadky\n\n```\n$ python3 ukazkove_moduly/suma.py 1 5 8\n\n['suma.py', '1', '5', '8']\n# 14\n```\n\n7. Modul `os` - funkcie zavisle na operacnom systeme\n\n- `os.getcwd()` – zisti aktuálny pracovny adresár\n- `os.chdir()` – zmen pracovny adresár\n- `os.listdir()` – vráť obsah adresaru\n- `os.mkdir()` – vytvor nový adresar\n- `os.makedirs()` – vytvor nový adresár, vratane všetkych nadadresarov\n- `os.rename()` – premenuj subor alebo adresár\n- `os.remove()` – zmaž subor\n- `os.rmdir()` – zmaž prázdný adresár\n- ...\n\n8. Modul `shutil` - viac moznosti nez `os`\n\n```python\nimport shutil\nshutil.rmtree('ukazkove_moduly/novy') # Zmaž adresár nový a všetko v nom\nshutil.copy('Pictures/funny_cat.gif', 'Desktop/CLICK_HERE.gif') # Zkopíruj subor\nshutil.copytree('Pictures', 'Desktop/Studijni_materialy_z_Pythonu') # Zkopíruj adresár a všetko v nom\n```\n\n9. Modul `os.path` - funkcie pre pracu s cestami (`path` = umiestnenie suboru alebo adresara)\n\n- riesi za nas rozdiely medzi operacnymi systemami\n\n1. ABSOLUTNA CESTA - zacina v koreni suboroveho systemu (v Unixu / vo Windowse pismeno disku)\n\n```python\n/home/krtecek/Pictures/funny_cat.gif\nC:\\Users\\Krtecek\\Pictures\\funny_cat.gif\n```\n\n2. RELATIVNA CESTA - zacina v aktualnom adresare (., sa nemusi pisat)\n\n```python\nPictures/funny_cat.gif\n./Pictures/funny_cat.gif\nPictures\\funny_cat.gif\n.\\Pictures\\funny_cat.gif\n```\n\n- `os.path.join()` – spojenie časti cesty\n\n```python\nfrom os import path\npath.join('Pictures', 'funny_cat.png') # 'Pictures/funny_cat.png'\npath.abspath('Pictures/funny_cat.png') # '/home/adam/Pictures/funny_cat.png'\npath.dirname('/home/adam/Pictures/funny_cat.png') # '/home/adam/Pictures'\npath.basename('/home/adam/Pictures/funny_cat.png') # 'funny_cat.png'\npath.exists('/home/adam/Pictures/funny_cat.png') # False\npath.isfile('/home/adam/Pictures/funny_cat.png') # False\npath.isdir('/home/adam/Pictures/funny_cat.png') # False\n```\n\n10. Modul `glob()` - chytry vypis suboru v adresari pomocou funkcie `glob.glob()`\n    - `*` - lubovolny pocet znakov (tj. i 0 znakov)\n    - `**` - vsetky subory vratane podurovni (pokial `recursieve=True`)\n    - `?` - jeden lubovolny znak\n    - `[A-Za-z] - jeden znak z vyctu\n\n```python\nimport glob\n\nglob.glob('Pictures/*')\n# ['Pictures/funny_cat.gif',\n# 'Pictures/funny_dog.gif',\n# 'Pictures/grumpy_cat.gif',\n# 'Pictures/giraffes']\n\nglob.glob('Pictures/funny_*.gif')\n# ['Pictures/funny_cat.gif', 'Pictures/funny_dog.gif']\n\nglob.glob('Pictures/**', recursive=True)\n# ['Pictures/',\n# 'Pictures/funny_cat.gif',\n# 'Pictures/funny_dog.gif',\n# 'Pictures/grumpy_cat.gif',\n# 'Pictures/giraffes',\n# 'Pictures/giraffes/mad_giraffe.gif',\n# 'Pictures/giraffes/sad_giraffe.gif',\n# 'Pictures/giraffes/confused_giraffe.gif']\n\nglob.glob('Pictures/giraffes/?ad_giraffe.*')\n# ['Pictures/giraffes/mad_giraffe.gif', 'Pictures/giraffes/sad_giraffe.gif']\n\nglob.glob('Pictures/funny_[bcr]at.gif')\n# ['Pictures/funny_cat.gif']\n```\n\n### Dalsie uzivatelske moduly\n\n- argparse\n- requests\n- subprocess\n- **json**\n- **csv**\n- pickle\n- email\n- re\n- codecs\n- warnings\n- numpy\n- matplotlib\n- sklearn\n- pandas\n- ...\n\n## Skusanie otvorit subor\n\n- Ask for forgiveness, not for permission\n- Nezistujeme, ci subor existuje a ci ho vieme otvorit, proste ho skusime otvorit !!!\n\n```python\ntry:\n    with open('neexistujici_subor.txt') as f:\n        print(f.read())\nexcept FileNotFoundError:\n    print('Subor neexistuje.')\nexcept PermissionError:\n    print('Nemáš právo čítat subor.')\nexcept OSError:\n    print('Subor sa nepodarilo otvorit.')\n# Subor neexistuje.\n```\n\n# 8. Praca so subormy `CSV` a `JSON`\n\n## Format CSV\n\n- CSV = comma-separated values\n- sluzi pre ukladanie tabulkovych dat\n- hodnoty su do stlpcou rozdelene pomocou separatoru (delimeter, vacsinou ciarka) a do riadku pomocou znakov noveho riadku\n- [linka](https://cs.wikipedia.org/wiki/CSV)\n- Tabulka:\n- [tabulka](./MyImage/formatCSV.png)\n- CSV:\n  Rok vyroby,Značka,Model,Cena\n  1995,Opel,Vectra,45000\n  1998,Škoda,Felicia,80000\n  2002,Škoda,Octavia,70000\n\n## Modul `csv` v Pythone\n\n- `csv.reader` - nacitanie formatu CSV\n- `csv.writer` - ukladanie vo formate CSV\n\n### Citanie\n\n```python\nwith open('tabulka.csv', 'r') as f:\n    print(f.read())\n# Rok výroby,Značka,Model,Cena\n# 1995,Opel,Vectra,45000\n# 1998,Škoda,Felicia,80000\n# 2002,Škoda,Octavia,70000\n```\n\n```python\nimport csv\n\nwith open('tabulka.csv', 'r') as f:\n    reader = csv.reader(f)\n    for riadok in reader:\n        print(riadok)\n# ['Rok výroby', 'Značka', 'Model', 'Cena']\n# ['1995', 'Opel', 'Vectra', '45000']\n# ['1998', 'Škoda', 'Felicia', '80000']\n# ['2002', 'Škoda', 'Octavia', '70000']\n```\n\n- nacitane hodnoty su vzdy retazec, musime si ich sami previest na cislo\n\n```python\nwith open('tabulka.csv', 'r') as f:\n    reader = csv.reader(f)\n    tabulka = list(reader)\ntabulka\n# [['Rok výroby', 'Značka', 'Model', 'Cena'],\n# ['1995', 'Opel', 'Vectra', '45000'],\n# ['1998', 'Škoda', 'Felicia', '80000'],\n# ['2002', 'Škoda', 'Octavia', '70000']]\n```\n\n```python\nwith open('tabulka.csv') as f:\n    csvreader = csv.DictReader(f)\n    for riadok in csvreader:\n        print(dict(riadok))\n# {'Rok výroby': '1995', 'Značka': 'Opel', 'Model': 'Vectra', 'Cena': '45000'}\n# {'Rok výroby': '1998', 'Značka': 'Škoda', 'Model': 'Felicia', 'Cena': '80000'}\n# {'Rok výroby': '2002', 'Značka': 'Škoda', 'Model': 'Octavia', 'Cena': '70000'}\n```\n\n### Zapis\n\n```python\nvzdialenosti = [['', 'Brno', 'Praha', 'Ostrava'],\n              ['Brno', 0, 202, 165],\n              ['Praha', 202, 0, 362],\n              ['Ostrava', 165, 362, 0]]\n\nwith open('vzdialenosti.csv', 'w') as f:\n    csvwriter = csv.writer(f)\n    csvwriter.writerows(vzdialenosti)\n\nwith open('vzdialenosti.csv') as f:\n    print(f.read())\n# ,Brno,Praha,Ostrava\n# Brno,0,202,165\n# Praha,202,0,362\n# Ostrava,165,362,0\n```\n\n### Zapis specialnych znakov\n\n![Tabulka](./MyImage/tabulka.png)\n\n- CSV:\n  - 1995,Opel,Vectra,\"klimatizace, střešní okno\",45000\n    1998,Škoda,\"Felicia \"\"Fun\"\"\",,80000\n    2002,Škoda,Octavia,\"klimatizace, ABS\n    bouraná\",70000\n\n### Parametre pre upresnenie formatu\n\n- `delimiter` - oddelovac stlpcov (default `','`)\n- `quotechar` - vyclenenie pola sa specialnymi znakmi (default `'\"'`)\n- `doublequote` - zdvojenie quotecharu rusi jeho funkciu (default `True`)\n- `escapechar` - rusi funkciu specialnych znakov (delimetru a quotecharu) (default `None`)\n- `dialect` - nastavenie viacerych parametrov sucastne (napr. `excel`)\n\n```python\nwith open('vzdialenosti.csv', 'w') as f:\n    csvwriter = csv.writer(f, delimiter=';', quoting=csv.QUOTE_NONNUMERIC)\n    csvwriter.writerows(vzdialenosti)\nwith open('vzdialenosti.csv') as f:\n    print(f.read())\n# \"\";\"Brno\";\"Praha\";\"Ostrava\"\n# \"Brno\";0;202;165\n# \"Praha\";202;0;362\n# \"Ostrava\";165;362;0\n```\n\n## Format `JSON`\n\n- JavaScript Object Notation\n- [JSON](https://www.json.org/json-en.html)\n- Mapovanie na typy Pythonu:\n- ![Tabulka](./MyImage/formatjson.png)\n\n## Modul `json`\n\n- `json.load()` - nacitaj JSON zo suboru\n- `json.loads()` - nacitaj JSON z retazca\n- `json.dump()` - zapis JSON so suboru\n- `json.dumps()` - zapis Json do retazca\n\n### Citanie\n\n```python\nwith open('bob.json') as f:\n    bob = f.read()\nprint(type(bob)) # \u003cclass 'str'\u003e\nprint(bob)\n# {\n#   \"name\": \"Bob\",\n#   \"age\": 30,\n#   \"married\": false,\n#   \"cars\": [\"Ford\", \"BMW\", \"Fiat\"]\n# }\n```\n\n```python\nimport json\n\nwith open('bob.json') as f:\n    bob = json.load(f)\nprint(type(bob)) # \u003cclass 'dict'\u003e\nprint(bob) # {'name': 'Bob', 'age': 30, 'married': False, 'cars': ['Ford', 'BMW', 'Fiat']}\n\ntext = '{ \"name\": \"John\", \"age\": 35, \"married\": true, \"cars\": [\"Mercedes\", \"BM\nW\", \"Volkswagen\"] }'\njohn = json.loads(text)\nprint(type(john)) # \u003cclass 'dict'\u003e\nprint(john) # {'name': 'John', 'age': 35, 'married': True, 'cars': ['Mercedes', 'BMW', 'Volkswagen']}\n```\n\n### Zapis\n\n```python\nalice = {'name': 'Alice', 'age': 28, 'married': False, 'cars': ('Ford', 'Traban\nt'), 10: 20 }\n\nwith open('alice.json', 'w') as f:\n    json.dump(alice, f)\n\nwith open('alice.json') as f:\nprint(f.read())\n# {\"name\": \"Alice\", \"age\": 28, \"married\": false, \"cars\": [\"Ford\", \"Trabant\"], \"10\": 20}\n\ntext = json.dumps(alice)\nprint(type(text)) # \u003cclass 'str'\u003e\nprint(text)\n# {\"name\": \"Alice\", \"age\": 28, \"married\": false, \"cars\": [\"Ford\", \"Trabant\"], \"10\": 20}\n\ntext = json.dumps(alice, indent=4)\nprint(text)\n# {\n#     \"name\": \"Alice\",\n#     \"age\": 28,\n#     \"married\": false,\n#     \"cars\": [\n#         \"Ford\",\n#         \"Trabant\"\n#     ],\n#     \"10\": 20\n# }\n```\n\n## Format `XML`\n\n- Extensible Markup Language\n- [linka](https://cs.wikipedia.org/wiki/Extensible_Markup_Language)\n\n```xml\n\u003cmessages\u003e\n  \u003cnote id=\"501\"\u003e\n    \u003cto\u003eTove\u003c/to\u003e\n    \u003cfrom\u003eJani\u003c/from\u003e\n    \u003cheading\u003eReminder\u003c/heading\u003e\n    \u003cbody\u003eDon't forget me this weekend!\u003c/body\u003e\n  \u003c/note\u003e\n  \u003cnote id=\"502\"\u003e\n    \u003cto\u003eJani\u003c/to\u003e\n    \u003cfrom\u003eTove\u003c/from\u003e\n    \u003cheading\u003eRe: Reminder\u003c/heading\u003e\n    \u003cbody\u003eI will not\u003c/body\u003e\n  \u003c/note\u003e\n\u003c/messages\u003e\n```\n\n## Zvysne moduly\n\n1. Modul `lxml` - cita a zapisuje vo formate `XML`\n\n- externy balicek, nutne doinstalovat pomocou pipu\n\n2. Modul `pickle` - ulozenie pythonovskych dat v binarnom formate\n\n- dokaze ulozit takmer lubovolny objekt (napr. funkciu)\n- **Nebezpecie** - pickle subor z cudzieho zdroja moze obsahovat skodlivy kod\n\n3. Modul `argparse` - predava argumenty z prikazoveho riadku\n\n- rovnaky ucel ako `sys.argv`, ale sofistikovanejsi a krajsi pre uzivatela\n- argumenty z prikazovaho riadku (netyka sa iba Pythonu):\n  - Povinne\n  - Volby/prepinace/options\n    - zacinaju - (jednopismenne) alebo - - (viacpismenne)\n    - mozu mat vlastne parametre\n\n```python\nimport argparse\n\nparser = argparse.ArgumentParser()\nparser.add_argument('input', help='Input CSV file', type=str)\nparser.add_argument('-H', '--header',\n    help='Interpret the first line as column names', action='store_true')\nparser.add_argument('-v', '--verbose',\n    help='Print extra information', action='store_true')\nparser.add_argument('-d', '--delimiter',\n    help='Delimiter in the CSV file', type=str, default=',')\nparser.add_argument('-s', '--stat',\n    help='Statistics to be computed',\n    choices=['mean', 'median', 'min', 'max'], default='mean')\nargs = parser.parse_args()\nprint('Input file:', args.input)\nprint('Header:', args.header)\nprint('Verbose:', args.verbose)\nprint('Delimiter:', args.delimiter)\nprint('Statistics:', args.stat)\n```\n\n- spustenie z prikazoveho riadku:\n\n```\n$ python3 make_statistics.py\n$ python3 make_statistics.py --help\n$ python3 make_statistics.py data.csv --stat median --header --verbose\n$ python3 make_statistics.py data.csv -s median -Hv\n```\n\n1. Modul `requests` - internetova komunikacia cez protokol `HTTP`\n\n- nutne doinstalovat pomocou pipu\n- posielame poziadavky (request) na server pomocou metod `GET`, `POST`, `PUT`, `DELETE`, ...\n\n```python\nimport requests\n\nURL = 'http://endless.horse' # URL = Uniform Resource Locator = webová adresa\nodpoved = requests.get(URL) # Používáme HTTP metodu GET\nprint('STATUS:', odpoved.status_code) # Status code: 200 = OK, 404 = Not Foun\nd...\nprint('TEXT:', odpoved.text[-700:]) # Poslednych 700 znakov zo stiahnutého textu`python\nSTATUS: 200\nTEXT: le=\"padding-top: 222px\"\u003e\n        \u003cpre\u003e ,\n_,,)\\.~,,._\n(()`  ``)\\))),,_\n  |     \\ ''((\\)))),,_          ____\n  |6`   |   ''((\\())) \"-.____.-\"    `-.-,\n  |   .'\\     ''))))'                  \\)))\n  |   | `.       ''                     ((((\n  \\, _)   \\/                            |))))\n  `'       |                            (((((\n           \\                  |         ))))))\n            `|    |           ,\\       /((((((\n             |   / `-.______.\u0026lt;  \\     | )))))\n             |   |  /        `.  \\  \\    ((((\n             |  / \\ |          `. \\  |   (((\n             \\  | | |           ) |  |    ))\n              | | | |           | |  |    '\u003c/pre\u003e\n\u003ca href=\"legs.html\"\u003e\u003c/a\u003e\n\u003c/div\u003e\n  \u003c/body\u003e\n\u003c/html\u003e\n```\n\n5. Modul `re` - regularny vyraz = regular expression = regex = RE\n\n- sposob ako zapisat obecne vzorku textu, ktory chceme vyhladat/nahradit/...\n\n```python\nimport re\n\ntext = 'Helloooo! She sells sea shells. Good as hell!'\nvzorka1 = re.compile('[Hh]ello*')\nvzorka1.findall(text) # ['Helloooo', 'hell', 'hell']\n\nvzorka2 = re.compile(r'\\b[Hh]ello+\\b')\nvzorka2.findall(text) # ['Helloooo']\n\nvzorka2.sub('Ciao', text) # 'Ciao! She sells sea shells. Good as hell!'\n```\n\n**Vysvetlenie**\n\n- `[Hh]` jeden znak z vyctu ('H' alebo 'h')\n- `o*` lubovolny pocet (vratane O) opakovanie o ('' aleb 'o' alebo 'oo'...)\n- `o+` aspon 1 opakovanie o ('o' alebo 'oo' ...)\n- `\\b` hranica slova\n- `dlsie moznosti pouzitia`:\n  - [re.html](https://docs.python.org/3.7/library/re.html)\n  - [regex.html](https://docs.python.org/3.7/howto/regex.html)\n- **POZOR!!!** - pravidla `re` a `glob` su ine\n\n# 9. VEDECKY PYTHON\n\n- instalacia\n\n```\npython -m pip install numpy/jupyter/atplotlib\n```\n\n## NumPy\n\n- je to standard pre numericke vypocty v Pythone\n- velke mnozstvo dalsich modulov postavenych nad NumPy\n\n```python\nimport numpy as np\n```\n\n- zakl. objekt s ktorym NumpPy pracuje\n- iba prvky rovnakeho typu\n- fixna velkost\n\n```python\nnp.array([1, 3, 4])\n# array([1, 3, 4])\n```\n\n```python\nnp.arange(10) #array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n```\n\n- funkcia `linspace`\n\n```python\nnp.linspace(0, 1, 11)\n# array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])\n\nnp.random.sample(10)\n# array([0.62666803, 0.07045182, 0.20550107, 0.36733577, 0.38851806,\n#        0.03756064, 0.90113418, 0.6652082 , 0.43018563, 0.6772363 ])\n```\n\n# Zakladne operacie\n\n```python\na = np.arange(10)\na # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n```\n\n- Operacie sa prevadza nad celym polom, nie je nutne pouzivat `for` cyklus\n\n```python\na + 1 # array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n\na ** 2 # array([ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81])\n```\n\n# Viacejrozmerne pole\n\n```python\na = np.arange(25)\na # array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])\na.shape # (25,)\nb = a.reshape(5, 5)\nb # array([[ 0, 1, 2, 3, 4],\n        # [ 5, 6, 7, 8, 9],\n        # [10, 11, 12, 13, 14],\n        # [15, 16, 17, 18, 19],\n        # [20, 21, 22, 23, 24]])\n\nb.shape #(5, 5)\n\nb[2, :] # array([10, 11, 12, 13, 14])\nb[:, 4] # array([10, 11, 12, 13, 14])\nb[3:6, 2] # array([17, 22])\n```\n\n- vytvorenie pole 3 x 3 pomocou funkcie `zeros()`\n\n```python\nnp.zeros((3, 3)) # array([[0., 0., 0.],\n                        # [0., 0., 0.],\n                        # [0., 0., 0.]])\n```\n\n- to same s jednixckami `ones()`\n\n```python\nx = np.ones((3, 3))\nx # array([[1., 1., 1.],\n         # [1., 1., 1.],\n         # [1., 1., 1.]])\n```\n\n- vytvorim si jednotkovu maticu pomocou funkcie `eye()`\n\n```python\nnp.eye(3)\n# array([[1., 0., 0.],\n       # [0., 1., 0.],\n       # [0., 0., 1.]])\n```\n\n```python\n3 * np.eye(3) + np.arange(9).reshape(3, 3)\n# array([[ 3., 1., 2.],\n       # [ 3., 7., 5.],\n       # [ 6., 7., 11.]])\n```\n\n# Uzitocne funkcie\n\n```python\nb = np.arange(25), reshape(5, 5)\nb # array([[ 0, 1, 2, 3, 4],\n        # [ 5, 6, 7, 8, 9],\n        # [10, 11, 12, 13, 14],\n        # [15, 16, 17, 18, 19],\n        # [20, 21, 22, 23, 24]])\n```\n\n```python\na = np.arange(30).reshape(5, 6)\nnp.min(a), np.max(a), np.sum(a), np.mean(a) # (0, 29, 435, 14.5)\n```\n\n- vsetky spomenute funkcie maju parameter `axis`, ktory urcuje, ci previest funkciu cez riadkz alebo stlpce\n\n```python\na = np.arange(30).reshape(5, 6)\nnp.sum(a, axis=0) # array([60, 65, 70, 75, 80, 85])\n\nnp.sum(a, axis=1) # array([ 15, 51, 87, 123, 159])\n```\n\n# Linearna algebra\n\n- `np.linalg`\n- velke mnozstvo funkcii (determinaty, inverzne matice, vlastne hodnoty, ...)\n\n![obr](./MyImage/algebra.png)\n\n```python\nA = np.array([[1, 1], [2, -1]])\nA # array([[ 1, 1],\n        # [ 2, -1]])\n\nb = np.array([1, 2])\nb # array([1, 2])\n\nnp.linalg.solve(A, b) # array([1., 0.])\n```\n\n# Vizualizacia dat - `matplotlib`\n\n- asi najrozsirenejsi modul\n- podobny syntax ako v Matlabu\n- velke mnozstvo nastaveni, typy grafov\n- pracujeme nad NumPy polom\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n- funkcia `plot` - vykreslovacia funkcia\n- defaltne vykresluje spojenu ciaru\n- `-o` vykreslenie v bodoch, `'x'` - vykreslenie v znaku x\n- funkcia `grid` - zobrazi sa mi mriezka\n\n```python\nxs = np.linspace(0, 10, 50)\nplt.plot(xs, np.sin(xs))\nplt.show() # [\u003cmatplotlib.lines.Line2D at 0x7fef25f51250\u003e]\n```\n\n![obr](./MyImage/sinusoida.png)\n\n```python\nxs = np.linspace(0, 10, 50)\nplt.grid()\nplt.plot(xs, np.sin(xs), '-o', color='red')\n# [\u003cmatplotlib.lines.Line2D at 0x7fef25eb2950\u003e]\n```\n\n![obr](./MyImage/sinusoidabod.png)\n\n- ak vykreslujem viac os tak musim pouzit funkciu `legend()`\n\n```python\nplt.grid()\nplt.xlim(-1, 11)\nplt.ylim(-2, 2)\nplt.title('Goniometrické funkce')\nplt.plot(xs, np.sin(xs), label='$y = \\sin{x}$')\nplt.plot(xs, np.cos(xs), label='$y = \\cos{x}$')\nplt.legend() # \u003cmatplotlib.legend.Legend at 0x7fef25e975d0\u003e\n```\n\n![obr](./MyImage/goniometrickefun.png)\n\n- stlpcovy graf `bar`\n\n```python\nx = np.random.randint(10, size=10)\nx # array([1, 4, 4, 8, 6, 3, 4, 7, 1, 3])\n\nplt.bar(np.arange(10), x)\n# \u003cBarContainer object of 10 artists\u003e\n```\n\n![obr](./MyImage/stlpcovygraf.png)\n\n- histogram = ukazuje cetnost\n- funkcia `hist()` -\n- `bins`\n\n```python\nplt.hist(np.random.sample(100), bins=15)\n# (array([ 4., 9., 5., 4., 5., 5., 10., 5., 5., 7., 8., 12., 5.,\n# 11., 5.]),\n# array([0.02412496, 0.08896623, 0.1538075 , 0.21864877, 0.28349004,\n# 0.34833131, 0.41317258, 0.47801385, 0.54285512, 0.60769639,\n# 0.67253765, 0.73737892, 0.80222019, 0.86706146, 0.93190273,\n# 0.996744 ]),\n# \u003ca list of 15 Patch objects\u003e)\n```\n\n![obr](./MyImage/stlpcovygraf1.png)\n\n- Bodovy graf `scatter`\n\n```python\nxs = np.random.sample(50)\nys = np.random.sample(50)\nsizes = np.random.randint(100, size=50) # oplivnuje velkost bodov\ncolors = np.random.randint(3, size=50) # budem mat 3 farby\n\nplt.scatter(xs, ys, c=colors, s=sizes) # volam\n# \u003cmatplotlib.collections.PathCollection at 0x7fef25eba6d0\u003e\n```\n\n![obr](./MyImage/bodovygraf.png)\n\n# NumPy - masky\n\n- funkcia `mask` - zamaskujem urcite data, kt nevyhovuje mojejj odmienky\n\n```python\na = np.random.randint(100, size=16).reshape(4, 4)\na # array([[54, 23, 7, 62],\n        # [28, 53, 69, 81],\n        # [72, 76, 11, 63],\n        # [67, 40, 41, 61]])\na \u003e 20 # tie kt. splnaju podmienky\na # array([[ True, True, False, True],\n        # [ True, True, True, True],\n        # [ True, True, False, True],\n        # [ True, True, True, True]])\nmask = a \u003e 20\na[mask] # array([54, 23, 62, 28, 53, 69, 81, 72, 76, 63, 67, 40, 41, 61])\na[~mask] # array([ 7, 11])\n```\n\n- vyuzitie `mask`, napr. chcem vykreslit niektore data inou farbou.\n\n```python\nxs = np.arange(100)\nys = np.random.sample(100)\nplt.scatter(xs, ys)\n```\n\n![obr](./MyImage/bod.png)\n\n```python\nxs = np.arange(100)\nys = np.random.sample(100)\nfor threshold in np.linspace(0, 1, 6):\nmask = (ys \u003e threshold) \u0026 (ys \u003c threshold + 0.2)\nplt.scatter(xs[mask], ys[mask])\n```\n\n![obr](./MyImage/bod2.png)\n\n# Nahodny vypocet piii\n\n```python\nxs = np.random.sample(10000) * 2 - 1 # body suradnic ktore su v rozsahu od -1 do 1, vdaka nasobeniu 2 a odpocitaniu 1\nys = np.random.sample(10000) * 2 - 1\n\nmask = xs ** 2 + ys ** 2 \u003c= 1 # vykresli mi plnykruh\nplt.scatter(xs[mask], ys[mask])\nplt.scatter(xs[~mask], ys[~mask])\n\n4 * np.sum(mask) / len(mask) # pocet bodov v ktuhu/pocet bodov v celej maske a vyde mi moje pii\n# 3.138 - ak zvacsim pocet bodov tak ziskam presnejsie pii\n```\n\n![obr](MyImage/randombodfar.png)\n\n# NumPy Vstup a Vystup\n\n- textovy\n  - `np.savetxt` a `np.loadtxt`\n  - precuje so standartnym `CSV`\n  - potreba nastavit sposob ulozenia a nacitania\n- binarny\n\n  - `np.save` a `np.load`\n  - rychlejsi, mensia velkost\n\n- `%%timeit` - zmeriam cas ako dlho bude trvat vygenerovanie\n\n```python\n%%timeit\n[x ** 2 for x in range(1000)]\n# 185 μs ± 967 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n\n%%timeit\nnp.arange(1000) ** 2\n# 2.46 μs ± 23.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n```\n\n# Sucet dvoch zoznamov/poli\n\n```python\na = list(np.random.sample(1000))\nb = list(np.random.sample(1000))\n```\n\n- Python = tri sposoby:\n\n```python\n%%timeit\nc = []\nfor 1 in range(len(a)):\n    c.append(a[1] + b[1])\n```\n\n```python\n%%timeit\nc = []\nfor x, y in zip(a, b):\n    c.append(x + y)\n```\n\n```python\n%%timeit\nc = [x + y for x, y in zip(a, b)]\n```\n\n- NumPy:\n\n```np\n%%timeit\nc = a + b\n```\n","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ffrantallukas10%2Fpython-fundamentals","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ffrantallukas10%2Fpython-fundamentals","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ffrantallukas10%2Fpython-fundamentals/lists"}