
def print_value(value):
    if value is None:
        return # pre prázdnu hodnotu príkaz ‘return’ ukončí funkciu a nasledujúci print sa už nevykoná
    print(value)
    
# zavoláme definovanú funkciu a predáme jej parameter value = 123
print_value(123)


def sum_squares(data):
    """Computes sum of squares of values for the specified sequence."""
    if len(data) == 0:  # pre prázdny zoznam vrátime None
        return None     # ‘return’ ukončí funkciu a ako návratovú hodnotu vráti hodnotu výrazu za slovom ‘return’
    sumsq = 0
    for x in data:
        sumsq += x * x
    return sumsq        # na konci vrátime sumu štvorcov prvkov zoznamu

# zavoláme funkciu s parametrom data = [1, 2, 3] a jej návratovú hodnotu priradíme premennej x
x = sum_squares([1, 2, 3])  # x = 14
x


help(sum_squares)


def print_operation(x, y, opr="+", none_value="?"):
    val_x = none_value if x is None else str(x)     # do val_x sa priradí none_value ak je x None, inak sa priradí str(x)
    val_y = none_value if y is None else str(y)     # podobne pre y
    print(val_x + " " + opr + " " + val_y)


print_operation(1, None, "*", "[none]")     # vypíše ‘1 * [none]’
print_operation(1, None, "*")               # vypíše ‘1 * ?’ - vynechali sme none_value
print_operation(1, None)                    # vypíše ‘1 + ?’ - vynechali sme opr a none_value

print_operation(x=1, opr="+", y=2)          # nemusíte dodržiavať poradie parametrov a nepovinné parametre môžete vynechať
# spôsoby môžete kombinovať, pričom najprv sú uvedené parametre podľa poradia a potom podľa mena
print_operation(1, 2, none_value="[none]")


print_operation(x=1, opr="+", y=2)          # nemusíte dodržiavať poradie parametrov a nepovinné parametre môžete vynechať
# spôsoby môžete kombinovať, pričom najprv sú uvedené parametre podľa poradia a potom podľa mena
print_operation(1, 2, none_value="[none]")


def print_list(name, *args):                     # všetky parametre za prvým budú funkcii predané ako n-tica args
    print(name + ": [" + ", ".join(args) + "]")  # prvky args spojíme oddeľovačom ‘, ’
    
# funkciu potom možno volať s ľubovoľným počtom parametrov uvedeným za name, napr.
print_list("basket")                            # vypíše ‘basket: []’
print_list("basket", "apple", "orange")         # vypíše ‘basket: [apple, orange]’


def filter(items, f):
    filtered = []
    for x in items:
        if f(x):                    # pre každý prvok x zoznamu items zavoláme funkciu na ktorú sa odkazuje parameter f
            filtered.append(x)      # ak f vráti True, pridáme x do výsledného zoznamu
    return filtered                 # vrátime zoznam hodnôt, ktoré splnili testovanie funkciou f


def non_zero(x):
    return x != 0       # vráti sa True ak x != 0, inak False

# funkciu non_zero potom môžeme predať ako parameter f funkcii filter
a = [-1, 0, 1, 2, -3]
b = filter(a, non_zero) # = [-1, 1, 2, -3]
b


test = lambda x: x != 0
# test je premenná do ktorej sa uloží funkcia definovaná lambda výrazom
# volanie funkcie priradenej do premennej test je rovnaké ako keby sme definovali funkciu s menom test
test(10)                # = True
b = filter(a, test)     # = [-1, 1, 2, -3]

# skrátený zápis lambda výrazu je vhodný napr. ak chcete definovať funkciu priamo na mieste, kde sa predá ako parameter:
b = filter(a, lambda x: x != 0)
b


def test_interval(min, max):
    return lambda x: min < x and x < max    # ‘return’ vracia funkciu definovanú lambda výrazom

# vždy keď zavoláme funkciu test_interval(min, max) s rôznymi parametrami min, max vytvorí sa nová testovacia funkcia ktorú
# môžeme samostatne použiť, napr.:
test_interval(0, 10)(5)                # = True - vytvorili sme novú testovaciu funkciu, ktorú sme rovno zavolali s parametrom 5
b = filter(a, test_interval(0, 3))     # = [1, 2]
b = filter(a, test_interval(-2, 2))    # = [-1, 0, 1]


# map vráti zoznam, ktorého hodnoty sú vypočítané aplikovaním funkcie f na jednotlivé prvky zoznamu items
def map(items, f):
    mapped = []
    for x in items:
        mapped.append(f(x))     # do výsledného zoznamu pridáme transformovanú hodnotu
    return mapped

# vráti zoznam čísiel umocnených na 2
b = map(a, lambda x: x * x)     # = [1, 0, 1, 4, 9]
b


def reduce(items, opr, init=None):
    result = init
    for x in items:
        result = opr(result, x)
    return result


# pomocou reduce môžete vypočítať napr. sumu prvkov zoznamu (pre operáciu sčítania je init = 0)
sum = reduce(a, lambda x, y: x + y, 0)  # výpočet pre [-1, 0, 1, 2, -3] zodpovedá (((((0 + -1) + 0) + 1) + 2) + -3) = -1

# funkcie filter, map a reduce môžete kombinovať pre výpočet zložitejších funkcií
# napr. pre výpočet sumy štvorcov kladných prvkov a:
b = filter(a, lambda x: x > 0)          # najprv odfiltrujeme iba kladné prvky
b = map(b, lambda x: x * x)             # vypočítame mocniny
sum = reduce(b, lambda x, y: x + y, 0)  # a spočítame ich sumu

# pomocou kombinácie map a reduce môžete vypočítať aj viacero štatistík naraz
# napr. ak chceme vypočítať počet a sumu prvkov zoznamu a:
# najprv transformujeme a na zoznam dvojíc, kde prvá zložka dvojice bude vždy 1 a druhá prvok z a
b = map(a, lambda x: (1, x))            # = [(1, -1), (1, 0), (1, 1), (1, 2), (1, -3)]

# parametre x a y funkcie opr budú dvojice, v prvej zložke budeme postupne pripočítavať jednotky a v druhej prvky zoznamu a
# ako počiatočnú hodnotu nastavíme dvojicu (0, 0)
count_sum = reduce(b, lambda x, y: (x[0] + y[0], x[1] + y[1]), (0, 0))    # vypíše sa dvojica (počet prvkov, suma)
count_sum


# naimportujeme modul, ktorý je uložený v súbore ‘example_module.py’
import example_module

# ak interpreter nenájde súbor s názvom modulu, príkaz skončí chybou ImportError

# pri prvom importovaní modulu do vášho skriptu interpreter vykoná všetky príkazy modulu (tzn. napr., že pre ‘example_module.py’ sa na obrazovke
# vypíše výpis z volania funkcie print na poslednom riadku)

# na všetky názvy definované v module sa musíte odkazovať cez meno modulu, napr. pre volanie funkcie non_zero(x) musíte zadať:
example_module.non_zero(5)

# ak chcete importovať funkciu non_zero pod lokálnym menom, v skripte použite príkaz:
from example_module import non_zero
# ak ste už vo vašom skripte definovali funkciu s menom non_zero, jej definícia sa prepíše verziou zo skriptu
# (týmto spôsobom môžete predefinovať aj štandardné funkcie poskytované jazykom Python!)

# príkazom import môžete naimportovať aj viacero funkcií naraz, napr.:
from example_module import non_zero, is_positive

# pod lokálnym menom sme importovali funkcie non_zero, filter, map a reduce
print("10 is non zero:", non_zero(10))

Pravidlá pre formátovanie¶

Funkcie¶

Funkcionálne programovanie - Lambda výrazy¶

Moduly¶

Úlohy¶

Úloha 5.1¶

Úloha 5.2¶

Úloha 5.3¶

Úloha 5.4¶

Úloha 5.5¶