a = 5
print('a =', a)
print('type(a) =', type(a))

# vytvořte proměnnou, uložte do ní desetinné číslo a ověřte typ
a = 5.87687
print('a =', a)
print('type(a) =', type(a))

# zde je vidět, že všechna čísla nelze pomocí tohoto formátu uložit absolutně přesně
b = 1.4 + 1.2
print(b)

# informace o formátu float
import sys
sys.float_info

from decimal import Decimal
a = Decimal(1.4)
b = Decimal(1.2)
a + b

a = Decimal('1.4')
b = Decimal('1.2')
a + b

from fractions import Fraction
a = Fraction(1, 5)
b = Fraction(4, 8)
a + b

c = 2 + 4j
print('c =', c)
print('type(c) =', type(c))
c.real

c.imag

print('real part =', c.real, 'a imag part =', c.imag)

# komplexně sdružené číslo - konjugace
c.conjugate()

2e2 + 5 * 6 - (13 / 3)**2 + 11%4

print("5/3 =", 5 // 3, "a zbytek", 5 % 3)

# absolutní hodnota
abs(-5)

# zaokrouhlování
# celé číslo,   na stovky,         na setiny
round(3.4895), round(245.876, -2), round(245.876, 2)

#### Pozor na přejmenovávání pythonovských proměnných a funkcí!!

# předefinujeme funkci abs a vložíme do ní celé číslo 5
abs = 5
# nyní se pokusím zavolat funkci abs, ale dostaneme chybu, protože abs už není funkce, ale celé číslo, které nelze volat jako dunkci
abs(-4)

# konverze desetinného čísla na celé
print(int(1.765))
# konverze řetězce obsahujícího číslo, abychom k němu mohli přičíst číslo 2
print(int('12') + 2)

# konverze celého čísla na desetinné
print(float(6))
# konverze řetězce
print(float('3.1322'))

# octal, binary, hex
0o23, 0b1111, 0xFF

# nelze sčítat řetězec a číslo
'12' + 2

# ani naopak to nejde - číslo a řetězec
2 + '12'

a = 5
a += 4
a **= 2
a

q = True
print('q =', q)
print('type(q) =', type(q))

q = (5 == 100)
q

x = 1
(x > 0) and (x < 3), (x > 0) & (x < 3)

(x > 0) or (x < 3), (x > 0) | (x < 3)

a = 5
4 < a <6

not (x < 20)

# dvojité uvozovky
s = "hello world"
print('s =', s)
print('type(s) =', type(s))

# jednoduché uvozovky
s = 'hello world'
print('s =', s)
print('type(s) =', type(s))

# tisk řetězce s uvozovkami - s výhodou využijeme oba typy uvozovek
text = 'text "text v uvozovkách"'
print(text)

# jinak bysme museli před vnitřní uvozovky \, což z nich udělá obyčejné uvozovky
text = "text \"text v uvozovkách\""
print(text)

# \ v řetězci, který vytvoří speciální znak
text = 'v latexu se řecké písmeno beta sází jako \beta'
print(text)
# buď přidáme lomítko
text = 'v latexu se řecké písmeno beta sází jako \\beta'
print(text)
# nebo z řetězce uděláme raw string (přidáním **r** před začátek řetězce), který se vysází tak jak je napsán - bez provedení zpeciálních znaků
text = r'v latexu se řecké písmeno beta sází jako \beta'
print(text)

s[2] = 'O'

s = s[:2] + 'O' + s[2:]
print(s)

'hello' + ' ' + 'world'

print('ok ok' * 5)
print('_' * 40)

w = 'hello world'
print('délka řetězce =', len(w))

s = 'slova  oddělená \t mezerou'
s.split() # bez parametru rozdělí řetězec podle všech bílých znaků " \t\n" a vrátí list slov

s = 'slova-oddělená-pomlčkou'
word_list = s.split('-') # rozdělí řetězec v místě pomlček
word_list

# spojit seznam slov s oddělovačem "; "
'; '.join(word_list)

# seznam možných funkcí a parametrů, které lze získat z řetězce
print([i for i in dir(s) if not i.startswith('_')])

# nahraď znaků za jiný/é
s = 'slova-oddělená-pomlčkou'
s.replace('-', '--')

# všechny znaky převeď na velká písmena
s.upper()

# ořízni bíle znaky z obou stran řetězce
s = '    \t   slovo xxx    \n'
s.strip()

# víceřádkový řetězec včetně konců řádků (''' také fungují, ale doporučené jsou dvojité)
a = """více
řádků"""
print(a)
repr(a) # řetězec, který reprezentuje objekt

# zalomení v kódu
a = ('více '
     'řádků')
a

a = 'více ' \
    'řádků'
a

import time
for i in range(5):
    print(i + 1, end='\r', flush=True)
    time.sleep(.5)

# objekty mají definovanou metory __str__(), která vrátí řetězec pro tisk
# při použití print se toto provede automaticky a není nutné volat "str()"
print(str(3.2))
print(3.2)

# konverze řetězce na číslo int/float
int('3'), float('3.33')

int('FF', 16) # převeď čísla z šesnáctkové soustavy do desítkové

int('1111', 2) # převeď čísla z binární soustavy do desítkové

s = 'hello world'
# první znak, pátý znak, poslení znak
s[0], s[4], s[-1]

# druhý až čtvrtý znak
s[1:4]

# 1. - 5. znak
s[0:5], s[:5] # 0 můžeme vynechat

# od začátku po 5. znak vypiš každý druhý
s[:5:2]

# na pozici složených uvozovek se postupně doplní objekty ze seznamu
print('{} {} {}'.format('a', 'b', 'c'))

# do závorek lze umístit index objektu ze seznamu, který lze umístit i vícekrát
print('{2} {1} {0} {1}'.format('a', 'b', 'c'))

# seznam může obsahovat jakékoliv objekty
# můžou být zadány i pomocí klíčových proměnných - pomocí názvu klíče se lze v {} na tento objekt odkazovat
print('{color} {0} {x} {1}'.format(10, 'cosi', x=1.5, color='zelená'))

# uvnitř {} lze za : umístit informace o formátování objektu
# {0:10} - vysázej objekt na pozici 0 na šířku 10 znaků (chybějící znaky jsou doplněny mezerami)
# {1:^10d} - ^ zarovnej na střed, "d" celé číslo, do oblasti široké 10 znaků
# {c:10.3f} - do oblasti široké 10 znaků umísti desetinné číslo "f" zaokrouhlené za desetinnou čárkou na 3 místa ".3"
print('{0:10} {1:^10d} {c:10.3f}'.format('text', 50, c=3.7659876))

# jak by to dopadlo bez 10
print('{0} {1:d} {c:.3f}'.format('text', 50, c=3.7659876))

x = 5.876e-6
s = 'hello'
f'{s} {x:.6g}' # g - general format

'%s %.3f a %03d' % ('text', 4.8475, 6)

a = [1, 2, 3, 4]
a, type(a)

# pomocí operátoru sčítání lze listy spojovat
[1, 2] + [3, 4]

# pomocí operátoru * lze hodnoty opakovat
[1, 2] * 3

range(5)

# pomocí funkce **list()** získáme seznam hodnot
# seznam hodnot od 0 do 4 po 1
list(range(5))

# seznam hodnot od 2 do 10 po 2
list(range(2, 11, 2))

a = [1, 2, 3, 4]
# nahraď 2. až 3. hodnotu
a[1:3] = [20, 30]
a

# hodnoty na pozici 2. až 3. nahraď čtyřmi novými
a[1:3] = [20, 30, 40 ,50]
a

# odstraň 2. až 3. hodnotu
a[1:3] = []
a

# vrať počet hodnot v seznamu
len(a)

# odstraň hodnotu na indexu 2
del a[2]
a

# zjisti jestli seznam obsahuje hodnotu 40
40 in a

# ověř, že hodnota 20 není v seznamu
20 not in a

# seznam může obsahovat různé typy objektů
a = ['text', 30, [1,2,3]]
a[0], a[2][1]

[i for i in dir(a) if not i.startswith('_')]

a = []
a.append(4) # přidej do seznamu číslo 4
a

a.append(40) # přidej do seznamu číslo 40
a

# rozšiř seznam o více hodnot najednou
a.extend([3,4,5])
a

a.append([400, 500]) # append vloží do seznamu čísla v listu
a

# počet hodnot 4
a.count(4)

# vrátí první index, na kterém se nachází číslo 4
a.index(4)

# na index 3 vlož hodnotu 50
a.insert(3, 50)
a

# odstraň číslo z listu, pokud není v seznamu vrátí error
a.remove(44)
a

# vyjmy poslední hodnotu z listu
val = a.pop()
print(val)

# vyjmy číslo na indexu 2
val = a.pop(2)
print(val)
a

# setřiď seznam
a = [3,5,1,2,1]
b = sorted(a) # funkce sorted() vrátí setřízený seznam a uložíme ho do proměnné "b"
a, b

print(a)
a.sort() # na seznamu můžeme zavolat metodu sort(), která setřídí seznam uvnitř proměnné "a" (o nesetříděný seznam přijdeme)
print(a)

# seznam v proměnné "a" zapíše v opačném pořadí
a.reverse()
a

# pokud si chceme otočený seznam uložit do proměnné, můžeme využít slicing
print(a)
b = a[::-1]
print(a)
print(b)

# mutable and immutable
# pokud lze objekt měnit "mutable" např. list
a = [1,2,3,4]
b = a
b[0] = 100
a, b, id(a), id(b) # což můžeme vidět když si vypíšeme adresu objektu (hodnoty jsou stejné)

# pokud tomu chceme zabránit musíme provést kopii objektu
a = [1,2,3,4]
b = a[:] # provede kopii listu
# b = a.copy() # nebo pomocí metody copy
b[0] = 100
a, b, id(a), id(b) # nyní jsou adresy různé

# příklad "immutable"
a = 'text'
b = a
b[0] = 'T'
a, b

# n-tici vytvoříme vložením seznamu objektů do kulatých závorek
a = (1, 2, 3, 4)
a, type(a)

# funguje to i bez závorek
a = 1, 2, 3, 4
a, type(a)

# pro vytvožení n-tice s jednou hodnotou je nutné vložit za číslo čárku
a = (10, )
b = (10)
a, type(a), b, type(b)

# přetypovat list na tuple lze pomocí funkce "tuple()"
a = [1, 2, 3]
a = tuple(a)
a, type(a)

# jedná se o immutable objekt a hodnoty nelze měnit - je nutné vytvořit nový objekt
a[0] = 5

# pojmenované ntice
from collections import namedtuple
Person = namedtuple('Person', ['first', 'last', 'age'])
person = Person('Václav', 'Sadílek', 6)
print(person)
print('věk =', person[-1])
print('věk =', person.age)
# přidejte výšku

# vytvoření {key: value}
# key musí být neměnitelný objekt (immutable)
# value může být cokoliv
d = {'škoda': 10, 55: 100}
d['seat'] = 2
d, type(d)

# slovník lze vytvořit pomocí funkce "dict" a klíčových parametrů
# klíče jsou omezeny názvy, které lze použít pro názvy proměnných v klíčových parametrech
d = dict(a=5, text='pokus')
d

# také můžeme funkci dát seznam obsahující dvojice "key, hodnota"
d = dict([('rohlíky', 10), ('mléko', [1,2])])
d

dist = {}
dist[('Praha', 'Ostrava')] = 20
dist[('Praha', 'Brno')] = 30
dist[('Ostrava', 'Brno')] = 50
dist

dist[('Praha', 'Brno')]

dist[('Brno', 'Praha')]

res = dist.get(('Brno', 'Praha'))
print(res, res is None)

print(dist.get(('Brno', 'Praha'), 'unknown'))

#del pop update keys, values, items

dist.keys() # klíče

dist.values() # hodnoty

dist.items() # položky jako seznam dvojit "key, value"

# množinu lze vytvořit pomocí složených závorek a seznamu hodnot
s = {1, 2, 5}
s, type(s)

# pomocí funkce "set()" lze vytvořit množinu z tuplu nebo listu
s = set((1,2))
s, type(s)

# do setu se ukládají pouze unikátní hodnotu
s = set([1,2,3,1,4,2,1])
s

# může obsahovat různé datové typy
s = {1, 2, 30., 'd', 2, 'd'}
s, type(s)

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# sjednocení
c = a.union(b)
c

c = a | b
c

# průnik
c = a.intersection(b)
c

a & c

# rozdíl
c = a.difference(b)
c

a - b

c = a.symmetric_difference(b)
c

a ^ b # xor

# zjištění jestli je podmnožinou
b.issubset(a), b <= a

a.issuperset(b), a >= b

# přidávání prvků do množiny
t = {1, 2, 3}
t.add(5)
t

# rozšíření množiny o více prvků
t.update([2, 6, 3])
t

# remove, pop, discard

# set() nelze použít jako key ve slovníku, protože je mutable
# můžeme použit frozenset
dist = {}
dist[frozenset(('Praha', 'Ostrava'))] = 20
dist[frozenset(('Praha', 'Brno'))] = 30
dist[frozenset(('Ostrava', 'Brno'))] = 50
dist

# v frozenset nezáleží na pořadí
dist[frozenset(('Praha', 'Brno'))], dist[frozenset(('Brno', 'Praha'))]

x = -10
if x > 0:
    print('x > 0')
elif x == 0:
    print('x == 0')
else:
    print('x < 0')

# prázdné objekty list, set, tuple vrací False
x = []
if x:
    print('jsem plný')
else:
    print('jsem prázdný')

val_list = list(range(1000)) 
val_set = set(val_list)

%timeit 1 in val_list

%timeit 1 in val_set

# zkuste zjistit zda se tam nachází 100 (je) a 1000 (není)

lst = list(range(3))
print(lst)
while lst: # dokud není list prázdný, while len(lst) != 0
    print(lst)
    lst = lst[1:] # v každém cyklu odstraň z listu 1. hodnotu

lst = list(range(3))
while lst:
    val = lst.pop() # vyjmi poslední hodnotu
    print(val) # konec bloku zyklu while
    
print('konec') # zrušeno odsazení - provede se až po dokončení cyklu

i = 0
while True: # nekonečný cyklus
    if i < 3:
        print(i, end=' ')
    else:
        break # přerušení cyklu po splnění podmínky
    i += 1

# stejný cyklu, pouze podmínka se přesunula k "while"
i = 0
while i<3:
    print(i, end=' ')
    i += 1

# vytiskni každou položku v iterátoru range(3)
for item in range(3):
    print(item, end=' ')

# vytiskni každý znak v řetězci a za každý vlož mezeru
for item in 'abcdef':
    print(item, end=' ')
print('\nkonec')

# spojení seznamu slov v jeden řetězec pomocí cyklu
animals = ['pes', 'kočka', 'slepice']
accum = ''
for animal in animals:
    accum += animal + ' '
accum

while animals:
    animal = animals.pop()
    print('animal =', animal)

a = 'abc'
for i in range(len(a)): # iterátor přes délku řetězce, který generuje indexy jednotlivých znaků
    print(i, a[i]) # vytiskne index a přes index vytáhne znak z proměnné "a"

# stejného výsledku dosáhneme zabalením řetězce do "enumerate", který oindexuje jednotlivé položky a vrací dvojice (index, hodnota), které si uložíme do proměnné "i" a "item"
for i, item in enumerate(a):
    print(i, item)

values = [1, 2, 3, 4, 5, 6, 7, 8]
for val in values:
    if val % 2 == 0: # pokud je číslo sudé, tak ho vytiskni
        print(val, end=' ')
    elif val>5: # pokud je číslo větší jak 5, tak přeruš cyklus
        break
    else: # jinak pokračuj
        continue

# do listu squares ulož druhé mocniny hodnot z listu values pomocí cyklu for
values = [1, 2, 3, 4, 5, 6, 7, 8]
squares = []
for x in values:
    squares.append(x**2)
squares

# pomocí comprihension
squares = [x**2 for x in values]
squares

# comprehension s podmínkou
squares = [x**2 for x in values if x<=4]
squares

# funguje stejně se set, dict
# vytvoř slovní, kde key je hodnota a value je hodnota**2
d = {x: x**2 for x in values}
d

def power_comprehension(x):
    return [i**2 for i in x]

def power_cycle(x):
    res = []
    for i in x:
        res.append(i**2)
    return res
data = list(range(100))

%timeit power_comprehension(data)

%timeit power_cycle(data)

# jednoduchá funkce, která bere 2 povinné parametry a vrací jejich součet
def func(a, b):
    """Add two values"""
    return a + b

# zavoláme funkci s dvěma parametry a výsledek uložíme do res
res = func(3, 5)
print(res)

# v ipythonu, jupyter lab, jupyter notebook můžeme vytisknout nápovědu pomocí "?"
func?

# v souboru .py můžeme vytisknout nápovědu
print(help(func))

# zavoláním funkce s jedním parametrem dostaneme error
func(3)

# i obyčejné parametry lze volat jako klíčové
# za parametr "b" pošleme 5 a opět dostaneme error
func(b=5)

# funkci lze poslat jakékoli 2 parametry, které lze sčítat/spojovat pomocí operátoru +
# např. řetězce
func('abc', 'def')

# pokud zadáme objekty, které to neumí, tak dostaneme opět error
func('abc', 5)

# funkce pro kvadratickou rovnici
# 1 povinný parametr "x"
# ostatní parametry klíčové parametry mají výchozí hodnoty
def quad(x, a=1, b=0, c=0):
    return a * x**2 + b*x + c

# zavoláním funkce s jedním parametrem dostaneme 1 * x **2 + 0 * x + 0
quad(2)

# první 2 se dosadí za "x"
# 4.2 se dosadí za "a"
# b zůstane výchozí 0
# a c=3
quad(2, 4.2, c=3)

# pro vytvoření funkce, která přijímá libovolný počet parametrů můžeme použít "*args" (běžně používaný název)
def add(x, *args):
    total = x
    for arg in args:
        total += arg
    return total
add(1, 2, 3, 4)

# pro vytvoření funkce, která přijímá libovolný počet klíčových parametrů můžeme použít "**kwargs" (běžně používaný název)
def add(x, **kwargs):
    total = x
    for key, value in kwargs.items():
        print('adding', key)
        total += value
    return total
add(1, g=2, b=3, w=4)

def func(*args, **kwargs):
    print(args, kwargs)
func(1, 2, x=5, b=6)

l = [4, 5]
d = {'a': 10, 'k': 8}
# pokud chceme použít všechny hodnoty z listu/slovníku, tak abychom je nemuseli postupně vypisovat
# func(l[0], l[1], a=d['a'], k=d['k'])
# můžeme je rozbalit - * rozbalí list, a ** rozbalí slovník
func(*l, **d)

def func(a, b):
    """Add two values"""
    return a + b
func(l[0], l[1]), func(*l)

# funkce, která převání souřadnice do polárních
from math import atan2
def to_polar(x, y):
    r = (x**2 + y**2)**0.5
    theta = atan2(y, x)
    return r, theta
r, theta = to_polar(1, 1)
r, theta

# příprava testovacího souboru
# otevři textový soubor pro zápis a zapiš do něj hodnoty
with open('text.txt', 'w') as f:
    f.write('''x\ty
1\t2
3\t4.5
4\t10.2''')

f = open('text.txt', 'r') # otevři soubor pro čtení "r"
text = f.read() # načti obsah soboru do proměnné text
f.close() # pokud už soubor nebudu potřebovat, je dobré ho zavřít (pokud dojde k chybě přičtení, tak k zavření nedojde)
print(text)

# použití "with" zajistí automatické zavření soboru i pokud dojde k chybě uvnitř bloku
with open('text.txt', 'r') as f:
    text = f.read()
print(text)

f = open('text.txt', 'r')
lines = f.readlines() # načti řádky, vrátí list řádků
f.close()

print(lines)

# zápis do soubotu "w"
# pokud soubor neexistuje, tak se vytvoří
# pokud soubor existuje, tak smaže jeho obsah
with open('output.txt', 'w') as f:
    f.write('První řádek\n')

# zápis do souboru v režimu append "a"
# nová data přidává na konec souboru
with open('output.txt', 'a') as f:
    f.write('Druhý řádek\n')

!cat output.txt # linux terminal vypiš obsah souboru

!type output.txt # windows cmd vypiš obsah souboru

# další režimy
# w+ read-write
# rU - universal newline mode
# wb, rb - write/read binary

class Rectangle():
    """Dokumentační řetězec
    Parameters:
        width
        height
        
    Example:
        >>> rectangle = Rectange(2, 5)
        >>> rectangle.get_area()
            10
    """
    
    def __init__(self, w, h):
        """init doc"""
        self.width = w
        self.height = h
    
    def get_area(self):
        """Return rectangle area"""
        return self.width * self.height
    
    def __str__(self):
        return f'{self.__class__.__name__}({self.width}, {self.height})'

x = Rectangle(4, 3.5)
x, x.get_area()

Rectangle?

print(help(Rectangle))

print(x) # volá naši upravenou funkci __str__

class Person():
    """height: meters
    """
    counter = 0 # parametr třídy
    
    def __init__(self, name, surname, height):
        # self.name jsou parametry, které se liší v každé instanci
        self.name = name
        self.surname = surname
        self._height = height
        print('jsem tu')
        Person.counter += 1 # při vytvoření nové instance se zvýší počítadlo
        
    def __del__(self):
        Person.counter -= 1 # zániku třídy se počítadlo sníží
        
    def return_fullname(self):
        return f'{self.name} {self.surname}'
    
    @property # dekorátor
    def fullname(self):
        return self.return_fullname()
    
    @property
    def height(self):
        return self._height
    
    @property
    def height_in_cm(self):
        return self._height * 100
    
    @height_in_cm.setter
    def height_in_cm(self, height):
        self._height = height / 100
        
    def get_height_in_mm(self):
        return self._height * 1000
    
    def set_height_in_mm(self, height):
        self._height = height / 1000

    height_in_mm = property(get_height_in_mm, set_height_in_mm) # alternativní způsob vytvoření bez dekorátoru

person1 = Person('Václav', 'Sadílek', 1.8)
print(person1.return_fullname()) # metoda, která vrací fullname
print(person1.fullname) # použitím property se funkce chová jako parametr a volá se bez ()
print(person1.height)
print(person1.height_in_cm)
person1.height_in_cm = 168
print(person1.height)
print(person1.height_in_mm)

person1.fullname = "Nové jméno" # property nelze upravovat bez vytvoření property.setter

print('Počet osob', Person.counter)

person2 = Person('Karel', 'Novák', 2)
person3 = Person('Pavel', 'Novák', 1.65)
print('Počet osob', Person.counter)

del person1 # smaž person1
print('Počet osob', Person.counter)

import os

fname = 'obrazek.jpg'
# spojování cest pomocí os.path zajistí správná lomítka podle operačního systému
os.path.join('figures', fname)

fname = 'text.txt'
os.path.abspath(fname) # vypíše absolutní cestu

os.path.splitext(fname) # oddělení přípony z názvu souboru

os.path.abspath(os.path.curdir) # absolutní cesta k aktuální složce

os.path.exists(fname) # test zda soubor existuje

# novější způsob práce s cestami pomocí knihovny pathlib\
import pathlib

path = pathlib.Path('.') # nastavení cesty na aktuální složku - current dir = "."
path

path.absolute() # absolutní cesta

# řetězit názvy složek a souborů lze přes operátor děleno "/"
fname = 'text.txt'
text_file_path = path / fname
text_file_path, text_file_path.absolute()

text_file_path.exists() # kontrola zda soubor existuje

text_file_path.suffix # vrátí příponu

text_file_path.name # název souboru

text_file_path.stem # jméno bez přípony

text_file_path.parent # složka, ve které se soubor nachází

a = 5
a / 0

try:
    b = a / 0
except ZeroDivisionError:
    print('pokoušíš se dělit 0')

try:
    b = a / 0
except ZeroDivisionError as exc:
    print('Exception message:', exc)

try:
    b = a / 0
except ZeroDivisionError as exc:
    print('Exception message:', exc)
finally:
    print('finally')

class MojeVyjimka(ValueError):
    """Moje důležitá vyjímka"""
    pass
raise MojeVyjimka('zpráva vyjímky')

import warnings

warnings.warn('text varování', RuntimeWarning)

import math
# použití funkcí a proměnných se pak provádí
math.sin(3), math.pi # zde je hned jasné odkud se ta funkce bere

from math import sin, pi # můžu si naimportovat pouze vybrané objekty
sin(3), pi

# NEPOUŽÍVAT !!!
from math import * # naimportruje vše
# pokud se v nějakém balíčku vyskytují stejně pojmenované funkce/proměnné, tak dojde ke konfliktu
# potom se může použít funkce z jiného balíčku než očekáváme

# pokud je název dlouhý nebo by došlo ke konfliktu, tak ho při importu můžeme přejmenovat
import numpy as np
np.sin(3) # zde je také snadno identifikovatelné, ze kterého balíku sin pochází

# sin už mám naimportovaný z math
from numpy import sin as np_sin
sin, np_sin