import module_name

# příklad

# Základní import
import math

# Import s aliasem
import numpy as np

# Import konkrétních prvků
from random import randint, choice as volba

# Použití importovaných prvků
print(math.sqrt(25))
print(np.array([1, 2, 3]))
print(randint(1, 10))
print(volba(['a', 'b', 'c']))

5.0
[1 2 3]
10
a

# ukázka ... konflikt názvů
pi = "ahoj"
print(pi)

from math import pi
print(pi)

pi = "ahoj"
print(pi)

ahoj
3.141592653589793
ahoj

# modul nebyl nalezen
import hfd

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In[6], line 1
----> 1 import hfd

ModuleNotFoundError: No module named 'hfd'

import sys
print(type(locals()), type(globals()), type(sys.modules))
print(len(locals()), len(globals()), len(sys.modules))

<class 'dict'> <class 'dict'> <class 'dict'>
27 27 954

if 'x' in locals():
    print(locals()['x'] is pi)
print(locals().keys())

dict_keys(['__name__', '__doc__', '__package__', '__loader__', '__spec__', '__builtin__', '__builtins__', '_ih', '_oh', '_dh', 'In', 'Out', 'get_ipython', 'exit', 'quit', 'open', '_', '__', '___', '__session__', '_i', '_ii', '_iii', '_i1', 'sys', '_i2', '_i3', '_i4', '_i5'])

# pomocna funkce
def filter_keys(keys):
    return [key for key in keys if not key.startswith('_')]

# jen objekty, co nezačínají _
keys = locals().keys()
print(filter_keys(keys))

['In', 'Out', 'get_ipython', 'exit', 'quit', 'open', 'filter_keys', 'keys']

# locals() a globals() jsou zde identické
print('GLOBAL', filter_keys(globals()), end='\n\n')
print('LOCAL', filter_keys(locals()), end='\n\n')

import sys
import turtle as zelva
from collections import Counter

print("Po importech:\n")

# podivejme se na lokalni a globalni kontext - jsou stejne, jsme totiz v globalnim kontextu
# vypiseme pro prehlednost jen klice relevantni klice
print('GLOBAL', filter_keys(globals()), end='\n\n')
print('LOCAL', filter_keys(locals()), end='\n\n')
print('jsou identicke?', globals() is locals(), end='\n\n')

# vidime zde moduly/funkce vsazene do namespace, aby byly k dispozici
print(Counter([1,1,2,3]), end='\n\n')

GLOBAL ['In', 'Out', 'get_ipython', 'exit', 'quit', 'open', 'filter_keys', 'keys']

LOCAL ['In', 'Out', 'get_ipython', 'exit', 'quit', 'open', 'filter_keys', 'keys']

Po importech:

GLOBAL ['In', 'Out', 'get_ipython', 'exit', 'quit', 'open', 'filter_keys', 'keys', 'sys', 'zelva', 'Counter']

LOCAL ['In', 'Out', 'get_ipython', 'exit', 'quit', 'open', 'filter_keys', 'keys', 'sys', 'zelva', 'Counter']

jsou identicke? True

Counter({1: 2, 2: 1, 3: 1})

# Podivejme se treba na modul turtle. Je nacteny v pameti a reference na nej se objevuje
# ve slovniku sys.modules pod jeho originalnim nazvem
print('Modul turtle je v sys.modules pod originalnim nazvem:', 'turtle' in sys.modules, end='\n\n')
print('V glob. ns je dostupny pod aliasem:', 'zelva' in globals(), end='\n\n')
print('Je to ten stejny modul?:', globals()['zelva'] is sys.modules['turtle'], end='\n\n')

Modul turtle je v sys.modules pod originalnim nazvem: True

V glob. ns je dostupny pod aliasem: True

Je to ten stejny modul?: True

# jak vypada samostatna funkce/trida, ktera byla importovana
print('Counter je dostupny v namespace:', 'Counter' in globals(), end='\n\n')
print('Counter je dostupny v cache - sys.module:', 'Counter' in sys.modules, end='\n\n')

print('V sys.modules je dostupny jeho modul, ne samotna fce:', 
      'collections' in sys.modules, end='\n\n')

print('je Counter v ns totez, jako Counter ukryty v modulu v sys.modules?:', 
      globals()['Counter'] is sys.modules['collections'].Counter, end='\n\n')

Counter je dostupny v namespace: True

Counter je dostupny v cache - sys.module: False

V sys.modules je dostupny jeho modul, ne samotna fce: True

je Counter v ns totez, jako Counter ukryty v modulu v sys.modules?: True

# Podívejme se ještě na lokální namespace, například ve funkci
def import_test():
    # naimportujeme neco, co jsme jeste dnes neimportovali
    import cmath
    x = 8
    print('CMATH sqrt jde pouzit: ',cmath.sqrt(-1), end='\n\n')
    print('GLOBAL ve funkci', filter_keys(globals().keys()), end='\n\n')
    print('LOCAL ve funkci ', filter_keys(locals().keys()), end='\n\n')
    print('jsou identicke?', globals() is locals(), end='\n\n')


#zjistime jestli cmath je v sys.modules
print('Cmath in sys.modules', 'cmath' in sys.modules)
print('Cmath in globals()', 'cmath' in globals())
# spustime funkce
import_test()

print('Cmath in sys.modules', 'cmath' in sys.modules)
print('Cmath in globals()', 'cmath' in globals())
# vykonavani spadne, v globalnim ns to neni importovane
print(cmath.sqrt(-1))

Cmath in sys.modules True
Cmath in globals() False
CMATH sqrt jde pouzit:  1j

GLOBAL ve funkci ['In', 'Out', 'get_ipython', 'exit', 'quit', 'open', 'debugpy', 'math', 'np', 'randint', 'volba', 'pi', 'sys', 'filter_keys', 'zelva', 'Counter', 'import_test']

LOCAL ve funkci  ['cmath', 'x']

jsou identicke? False

Cmath in sys.modules True
Cmath in globals() False

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[24], line 21
     19 print('Cmath in globals()', 'cmath' in globals())
     20 # vykonavani spadne, v globalnim ns to neni importovane
---> 21 print(cmath.sqrt(-1))

NameError: name 'cmath' is not defined

import math
import cmath

print(cmath.sqrt(-1))  # komplexní varianta umi vypočítat odmocninu záporných čísel
#print(math.sqrt(-1))

print((-1)**0.5)

1j
(6.123233995736766e-17+1j)

# ukázka isclose
x = cmath.sqrt(-1)
y = (-1)**0.5
print(x == y)
cmath.isclose(x, y)

False

True

import random

# vygenerujeme nahodna cisla z mnoziny, kterou by vytvoril range(5, 50, 5)

print(random.randint(100, 200))


for i in range(5):
    print(random.randrange(5, 50, 5), end = " ")

129
35 30 10 30 10

# vybereme nahodny prvek ze sekvence
s = [1,2,3,4,5,6,7,8,9,10]
print(random.choice(s))
print(random.choice(s))
print(random.choice(s))
print(random.choice(s))

print(s)
random.shuffle(s)
print(s)

9
4
4
7
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 6, 7, 10, 9, 3, 8, 4, 5, 1]

# vygenerujeme nahodne cislo z daneho rozsahu
print(random.uniform(100, 200), random.random())

132.35304402217116 0.6652249794216701

# zazalohuje me si aktualni stav random objektu
random_state = random.getstate()

# nastavime vlastni seed - uvidime, ze to vzdy generuje stejne posloupnosti pri kazdem behu, pokud nastavime vlastni seed

random.seed(2)  # nejake konstantni cislo
for i in range(10):
    print(random.random())

0.9560342718892494
0.9478274870593494
0.05655136772680869
0.08487199515892163
0.8354988781294496
0.7359699890685233
0.6697304014402209
0.3081364575891442
0.6059441656784624
0.6068017336408379

# obnovime random do puvodniho stavu
random.setstate(random_state)

import sys
# parametry, se kterymi byl tento skript spusten
print(sys.argv, end='\n\n')

print(sys.version_info)

['/usr/lib/python3.12/site-packages/ipykernel_launcher.py', '-f', '/home/user/.local/share/jupyter/runtime/kernel-8ea5017a-b262-4c19-8798-391e1889fe8a.json']

sys.version_info(major=3, minor=12, micro=7, releaselevel='final', serial=0)

#import os
#print(filter_keys(os.environ))

import os
print(os.getenv("USER"))

# python funkce na vylistovani obsahu slozky
print(os.listdir('data'))

# zavolani alternativni funkce dostupne primo v terminalu operacniho systemu. Pouzijte dir pro windows OS.
# Ukazuje univerzalnost python funkci (vyse) a nezavislost na OS.
os.system('ls data')

None
['example.csv', 'readme.exe', 'touch.html', 'example-files', 'pokemon.txt', '.ipynb_checkpoints', 'text.txt', 'example.txt', 'rename.txt', 'inventory.txt', 'inventory.csv', 'testing-folder', 'argparse_test.py', 'data.txt', 'ukazka_argparse.py']
argparse_test.py
data.txt
example-files
example.csv
example.txt
inventory.csv
inventory.txt
pokemon.txt
readme.exe
rename.txt
testing-folder
text.txt
touch.html
ukazka_argparse.py

0

import sys

print(sys.argv, end='\n\n')

if len(sys.argv)> 1 and sys.argv[1] == '15':
    sys.exit(1)```

os.system('python muj.py')

['muj.py']

0

os.system('python muj.py 1 b')
os.system('python muj.py 15 -a 45 a b')

['muj.py', '1', 'b']

['muj.py', '15', '-a', '45', 'a', 'b']

256

0 user@jupyter-reitezuz:~/zpro-2024-public.git (main *>)$ python muj.py
['muj.py']

0 user@jupyter-reitezuz:~/zpro-2024-public.git (main *>)$ python muj.py a b
['muj.py', 'a', 'b']

0 user@jupyter-reitezuz:~/zpro-2024-public.git (main *>)$ python muj.py 15 a b
['muj.py', '15', 'a', 'b']

1 user@jupyter-reitezuz:~/zpro-2024-public.git (main *>)$ ```

from pprint import pprint as print

import pprint
d = {i: i**2 for i in range(20)}
print("Standardni print")
print(d)
print("\nPretty print")
pprint.pprint(d)

Standardni print
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289, 18: 324, 19: 361}

Pretty print
{0: 0,
 1: 1,
 2: 4,
 3: 9,
 4: 16,
 5: 25,
 6: 36,
 7: 49,
 8: 64,
 9: 81,
 10: 100,
 11: 121,
 12: 144,
 13: 169,
 14: 196,
 15: 225,
 16: 256,
 17: 289,
 18: 324,
 19: 361}

import pprint

# nahrazeni
original_print = print
print = pprint.pprint

print(d)

# vraceni
print = original_print

{0: 0,
 1: 1,
 2: 4,
 3: 9,
 4: 16,
 5: 25,
 6: 36,
 7: 49,
 8: 64,
 9: 81,
 10: 100,
 11: 121,
 12: 144,
 13: 169,
 14: 196,
 15: 225,
 16: 256,
 17: 289,
 18: 324,
 19: 361}

from collections import Counter
data = [1, 2, 3, 1, 2, 1, 4, 5]
counter = Counter(data)
print(counter)

data = "abrakadabra"
counter = Counter(data)
print(counter)

Counter({1: 3, 2: 2, 3: 1, 4: 1, 5: 1})
Counter({'a': 5, 'b': 2, 'r': 2, 'k': 1, 'd': 1})

p = (1, 2)
x, y = p
print(p[0], p[1])

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p.x, p.y)  # Vytiskne hodnoty x a y

# funguje i originalni "tuple" přístup přes indexy
print(p[0], p[1])

1 2
1 2
1 2

from collections import defaultdict
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

d = defaultdict(list)

# výhoda je v tom, že nemusíme ověřovat, jestli daný klíč je ve slovníku
# pro každý neexistující klíč se při přístupu automaticky vytvoří s danou defaultní hodnotou 
# list v tomto případě
for k, v in s:
    d[k].append(v)
print(d.items())

dict_items([('yellow', [1, 3]), ('blue', [2, 4]), ('red', [1])])
defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})

# ukázka, jak by to bylo s obyčejným slovníkem:
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

d = {}
for k, v in s:
    if k not in d:
        d[k] = []
    d[k].append(v)
    
print(d)

{'yellow': [1, 3], 'blue': [2, 4], 'red': [1]}

# varianta s počtem:
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]

d = defaultdict(int)
for k, v in s:
    d[k] += v
print(d)

defaultdict(<class 'int'>, {'yellow': 4, 'blue': 6, 'red': 1})

s = "abrakadabra"
d = defaultdict(int)
for x in s:
    d[x] += 1
print(d)

defaultdict(<class 'int'>, {'a': 5, 'b': 2, 'r': 2, 'k': 1, 'd': 1})

import itertools
c = itertools.count()

for i in range(20):
    print(next(c), end = " ")

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

for i in itertools.count():
    print(i, end = " ")
    if i > 10:
        break

0 1 2 3 4 5 6 7 8 9 10 11

i = 0
for x in itertools.cycle("abc"):
    print(x, end = " ")
    i += 1 
    if i > 10:
        break
        
# Nekonecna smycka tisknouci 1,2,3,1,2,3,1,2,3,.....
#for i in itertools.cycle( [1,2,3]):
#    print(i)

a b c a b c a b c a b

for i in itertools.product('abc', [1,2,3,4]):
    print(i)

('a', 1)
('a', 2)
('a', 3)
('a', 4)
('b', 1)
('b', 2)
('b', 3)
('b', 4)
('c', 1)
('c', 2)
('c', 3)
('c', 4)

for i in itertools.product('abc', repeat=2):
    print(i)

('a', 'a')
('a', 'b')
('a', 'c')
('b', 'a')
('b', 'b')
('b', 'c')
('c', 'a')
('c', 'b')
('c', 'c')

pole = [1,2,3,4,5]
#  ukázka kombinací o delce 2
print(list(itertools.combinations(pole, 2)))

#  ukázka kombinací o delce 3
print(list(itertools.combinations(pole, 3)))

[(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
[(1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5), (2, 3, 4), (2, 3, 5), (2, 4, 5), (3, 4, 5)]

with open('data/inventory.csv', 'r') as file:
    print(file.read())

#name,amount,price
Kýbl,5,85
Pytel cementu,10,120
Cihla,65,25
Kladivo,3,150
Vrtačka,2,2000
Hřebík,560,0.5
Míchačka,1,5600
Hmoždinka,120,3

import csv

with open('data/inventory.csv', 'r') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)  # Vytiskne každý řádek ze souboru CSV

['#name', 'amount', 'price']
['Kýbl', '5', '85']
['Pytel cementu', '10', '120']
['Cihla', '65', '25']
['Kladivo', '3', '150']
['Vrtačka', '2', '2000']
['Hřebík', '560', '0.5']
['Míchačka', '1', '5600']
['Hmoždinka', '120', '3']

# ukázka navíc: zápis csv:
import csv

# Otevření souboru pro zápis CSV
with open('data/example.csv', 'w') as csvfile:
    # Vytvoření objektu csv.writer
    csv_writer = csv.writer(csvfile)

    # Zápis prvního řádku - hlavičky
    csv_writer.writerow(['#Jméno', 'Příjmení', 'Věk'])

    # Zápis dat
    csv_writer.writerow(['Jan', 'Novák', 25])
    csv_writer.writerow(['Eva', 'Svobodová', 30])
    csv_writer.writerow(['Petr', 'Dvořák', 22])
    
with open('data/example.csv', 'r') as file:
    print(file.read())

#Jméno,Příjmení,Věk
Jan,Novák,25
Eva,Svobodová,30
Petr,Dvořák,22

import json

json_str = '{"name": "John", "age": 30, "city": "New York"}'  # vyzaduje dvojite uvozovky
loaded_data = json.loads(json_str)  # nacteme string JSON a udelame z nej python objekt
print(type(loaded_data))
print(loaded_data)  # vytiskne python objekt odpovidajici strukture JSON (dict)

data = [5, 7, 8]
json_str = json.dumps(data)  # vytvori json retezec z python objektu

print(json_str)  # Vytiskne JSON řetězec

<class 'dict'>
{'name': 'John', 'age': 30, 'city': 'New York'}
[5, 7, 8]

# ukázka navíc: zápis a načítání JSON do/ze souboru
import json

d = {"name": "John", "age": 30, "city": "New York"}

# Otevření souboru pro zápis JSON
with open('data/example.json', 'w') as json_file:
    json.dump(d, json_file)

# Otevření souboru pro čtení JSON
with open('data/example.json', 'r') as json_file:
    new_d = json.load(json_file)

print(new_d)

{'name': 'John', 'age': 30, 'city': 'New York'}

import argparse

parser = argparse.ArgumentParser(
                    description='What the program does',
                    epilog='Text at the bottom of help')

# volné místo na program
import random
import itertools
import collections


p = (1, 2)  # body jako ntice
print(p)
print(p[0], p[1]) # přístup ke složkám

print(random.uniform(0, 100))  # náhodné číslo

p = (random.uniform(0, 100), random.uniform(0, 100)) # náhodný bod
print(p)

(1, 2)
1 2
59.31837303800576
(39.3599686377914, 17.034919685568127)

# body jako ntice
p = (1, 4)
print(p[0], p[1])

n = 3
points = [(random.uniform(0, 100), random.uniform(0, 100)) for i in range(n)]
print(points, "\n")

1 4
[(38.12042376882124, 21.659939713061338), (42.21165755827173, 2.9040787574867943), (22.169166627303504, 43.7887593650572)]

# body jako pojmenované ntice
from collections import namedtuple
Point = collections.namedtuple('Point', ['x','y'])
p = Point(1, 4)
print(p.x, p.y)

n = 3
points = [Point(random.uniform(0, 100), random.uniform(0, 100)) for i in range(n)]
print(points, "\n")

1 4
77.84426150001458 52.09384176131452
[Point(x=39.325509496422605, y=48.96935204622582), Point(x=2.9574963966907064, y=4.3487290356527435), Point(x=70.3382088603836, y=98.3187717309674)]

# kombinace
print(list(itertools.combinations("abcd", 2)))
#print(list(itertools.combinations(points, 2)))

[('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')]
[(Point(x=39.325509496422605, y=48.96935204622582), Point(x=2.9574963966907064, y=4.3487290356527435)), (Point(x=39.325509496422605, y=48.96935204622582), Point(x=70.3382088603836, y=98.3187717309674)), (Point(x=2.9574963966907064, y=4.3487290356527435), Point(x=70.3382088603836, y=98.3187717309674))]

# Řešení pomocí namedtuple:
import random
import itertools
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])

def distance(point1, point2):
    return ((point1.x-point2.x)**2 + (point1.y-point2.y)**2)**0.5
    # return ((point1[0]-point2[0])**2 + (point1[1]-point2[1])**2)**0.5

def average_distance(points):
    sum_distances = 0
    count_distances = 0
    for point1, point2 in itertools.combinations(points, 2):
        sum_distances += distance(point1, point2)
        count_distances +=  1
    return sum_distances/count_distances
    
def average_distance1(points):
    distances = []
    for point1, point2 in itertools.combinations(points, 2):
        distances.append(distance(point1, point2))
    return sum(distances) / len(distances)
    
def average_distance2(points):
    distances = [distance(point1, point2) for  point1, point2 in itertools.combinations(points, 2)]
    return sum(distances) / len(distances)

def closest_points(points):
    min_points =  (points[0], points[1])
    min_distance = distance(points[0], points[1])
    for point1, point2 in itertools.combinations(points, 2):
        d = distance(point1, point2)
        if d < min_distance:
            min_distance = d
            min_points = (point1, point2)
    return min_points
    
def closest_points(points):
    distances = [(distance(point1, point2), point1, point2) for  point1, point2 in itertools.combinations(points, 2)]
    return min(distances)
    

print(distance(Point(1, 1), Point(-1, 0)))
random.seed(2)
points = [Point(random.uniform(0, 100), random.uniform(0, 100)) for i in range(10)]
print(average_distance(points), average_distance1(points), average_distance2(points))
print(closest_points(points))

2.23606797749979
52.68497366091925 52.68497366091925 52.68497366091925
(12.609145799787424, Point(x=43.066964029126865, y=39.35318202053713), Point(x=44.485418872585356, y=26.82407416493281))

├── 1
│   ├── 1
│   │   ├── 1
│   │   └── 2
│   └── 2
│       ├── 1
│       └── 2
└── 2
    ├── 1
    │   ├── 1
    │   └── 2
    └── 2
        ├── 1
        └── 2

# volné místo na program
def generate_tree(root_directory, branch_factor, depth):
    assert depth <= 6, 'Structure too deep'
    assert branch_factor <= 6, 'Structure too wide'
    # your code here

# volné místo na program
import turtle
import random

# Nastavení želvy
drunk_turtle = turtle.Turtle()
drunk_turtle.shape("turtle")
drunk_turtle.speed(2)  # Rychlost pohybu želvy

# Funkce pro náhodný pohyb želvy
def drunk_walk(turtle, steps=50, step_length=20):
    for _ in range(steps):
        # Náhodný úhel
        angle = random.uniform(0, 360)
        turtle.left(angle)

        # Náhodná vzdálenost
        distance = random.uniform(0, step_length)
        turtle.forward(distance)

# Spustit opilou želvu
drunk_walk(drunk_turtle)

# Uzavření okna po kliknutí
turtle.exitonclick()

# Spustime tento soubor bez parametru parametry
import os
os.system("python3 data/argparse_test.py")

usage: argparse_test.py [-h] [-s] [-r] cislo1 cislo2
argparse_test.py: error: the following arguments are required: cislo1, cislo2

512

# výpis nápovědy
os.system("python3 data/argparse_test.py --help")

usage: argparse_test.py [-h] [-s] [-r] cislo1 cislo2

Program pro výpočet součtu a rozdílu.

positional arguments:
  cislo1        První číslo pro výpočty
  cislo2        Druhé číslo pro výpočty

options:
  -h, --help    show this help message and exit
  -s, --soucet  Spočítat součet čísel
  -r, --rozdil  Spočítat rozdíl čísel

0

os.system("python3 data/argparse_test.py 1 2")

Není vybrána žádná operace.

0

os.system("python3 data/argparse_test.py 1 2 --soucet")

Součet: 3

0

os.system("python3 data/argparse_test.py 1 2 -r -s")

Součet: 3
Rozdíl: -1

0

# volné místo na program

# volné místo na program

# volné místo na program

Funkce	Krátký popis
cmath.phase(x)	Fáze komplexního čísla
cmath.polar(x)	Konverze komplexního čísla do polárních souřadnic
cmath.rect(r, phi)	Konverze komplexního čísla z polárních do kartézských souřadnic

Funkce	Krátký popis
random.randrange(stop)	Vrátí náhodný prvek z množiny hodnot, které by vygenerovala funkce range se stejnými parametry. Používá stejné parametry.
random.randint(a, b)	Vrátí náhodný integer `I` tak, že `a <= I <=b`

Funkce	Krátký popis
random.choice(seq)	Vybere náhodný prvek ze sekvence
random.shuffle(x)	Náhodně zamíchá (inplace) prvky modifikovatelné sekvence

Funkce	Krátký popis
random.random()	Vrátí náhodné číslo v `r` rozmezí `0.0 <= r < 1.0`
random.uniform(a, b)	Vrátí náhodné číslo v `r` rozmezí `a <= r <= b`

Funkce	Krátký popis
sys.exit([arg])	Ukončí běh skriptu s daným návratovým kódem
sys.modules	Slovník obsahující aktuálně načtené moduly. Slouží jako cache pro jejich načítání
sys.version_info	Poskytuje informace o aktuální verzi interpreteru Python
sys.argv	Seznam argumentů, předaných skriptu při spuštění

Funkce	Krátký popis
os.environ	Slovník obsahující proměnné prostředí a jejich hodnoty. Může být využit pro konfiguraci našeho skriptu
os.getenv(key, default=None)	Funkce schopna vrátit hodnoty proměnnných prostřed (s možností definovat defaultní hodnoty v případě nenalezení daného klíče). Operuje nad `os.environ`
os.system(command)	Spustí příkaz v `command` v terminálu

Funkce	Krátký popis
os.getcwd()	Zjistí aktuální adresář
os.chdir(path)	Změní aktuální adresář na `path`
os.mkdir(path)	Vytvoří nový adresář `path`. Neumí vytvořit více úrovní složek najednou
os.makedirs(path)	Vytvoří nové adresáře. Umí vytvořit celou cestu adresářů.
os.rmdir(path)	Smaže adresář `path`
os.listdir(path='.')	Vrátí seznam adresářů a souborů v `path`, ve výchozím stavu v aktuálním adresáři
os.replace(src, dst)	Přejmenuje/přesune soubor nebo složku `src` na `dst`
os.remove(path)	Odstraní soubor `path`

Funkce	Krátký popis
collections.Counter([iterable-or-mapping])	Struktura typu slovník. Prvky původní posloupnosti jsou uloženy jako klíče, hodnoty značí počet výskyt§
collections.defaultdict()	Je to slovník s výchozí hodnotou pro neexistující prvky
collections.namedtuple(typename, field_names)	Alternativa k tuple. Umožní pojmenovat jednotlivé pozice pro jednodušší a přehlednější použití

Funkce	Krátký popis
itertools.count(start=0, step=1)	Iterator určený k očíslování. Užitečný například u ZIPu nebo map funkci
itertools.cycle(iterable)	Umožňuje nekonečnou iteraci přes nějakou posloupnost
itertools.chain(*iterables)	Vytvoří iterátor, který postupně iteruje přes všechny posloupnosti
itertools.product(*iterables, repeat=1)	Vygeneruje prvky kartézského součinu všech vstupních posloupností
itertools.permutations(iterable, r=None)	Vygeneruje permutace o délce r
itertools.combinations(iterable, r)	Vygeneruje kombinace o délce r
itertools.combinations_with_replacement(iterable, r)	Vygeneruje kombinace s opakováním o délce r

Funkce	Krátký popis
csv.reader(csvfile, dialect='excel', **fmtparams)	Vytvoří objekt pro čtení dat ze souboru CSV
csv.writer(csvfile, dialect='excel', **fmtparams)	Vytvoří objekt pro zápis dat do souboru CSV.

Funkce	Krátký popis
json.dumps(obj)	Převede objekt na string ve formátu JSON (serializace).
json.loads(json_str)	Převede JSON řetězec zpět na objekt (deserializace).

Cvičení č. 22 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2024/25)¶

Práce se základními moduly standardní knihovny¶

Příkaz import¶

Základní Import¶

Import konkrétních prvků¶

Alternativní způsoby importu¶

- Alternativní pojmenování - alias¶

- Import všech prvků z modulu (❗❗NEDOPORUČOVÁNO❗❗)¶

Co se děje na pozadí příkazu import¶

sys.modules¶

Ukázka sys.modules¶

Výběr modulů standardní knihovny¶

math¶

cmath¶

random¶

Sekce pro integery¶

Sekce pro sekvence¶

Sekce pro reálná čísla¶

Seed¶

sys¶

Důležité funkce a hodnoty¶

os¶

Důležité funkce a hodnoty - práce s proměnnými prostředí a systémem¶

Důležité funkce a hodnoty - práce se soubory¶

pprint¶

Důležité funkce a hodnoty¶

collections¶

Důležité funkce a hodnoty¶

itertools¶

Důležité funkce a hodnoty¶

csv¶

Důležité funkce a hodnoty¶

json¶

Důležité funkce a hodnoty¶

argparse¶

Hlavní vlastnosti argparse¶

Stručné použití¶

Externí (nestandardní) balíčky a moduly¶

Příklady¶

1) Vzdálenost bodů v rovině¶

2) Hluboká adresářová struktura¶

3) Opilá želva¶

4) Argparse testování¶

5) Argparse - program na modifikaci souborů¶

6) Argparse - program na modifikaci souborů #2¶

Příkaz `import`¶

Co se děje na pozadí příkazu `import`¶

`sys.modules`¶

Ukázka `sys.modules`¶

`math`¶

`random`¶

`sys`¶

`os`¶

`pprint`¶

`collections`¶

`itertools`¶

`csv`¶

`json`¶

`argparse`¶