Python – Funkce a funkcionální programování

Martin Korbel

Úvod

Funkce = základní stavební prvek v Pythonu.
Umožňují:
- znovupoužití kódu,
- přehlednost programu,
- modularitu.

def pozdrav():
    print("Ahoj světe!")

pozdrav()

Definice a volání funkce

Funkce se definuje pomocí def.
Parametry předáváme v závorkách.
Výsledek se vrací pomocí return.

def soucet(a, b):
    return a + b

print(soucet(3, 5))  # 8

Parametry a návratová hodnota

Parametry mohou mít výchozí hodnotu.
Funkce může vrátit více hodnot (pomocí tuple).

def rozdil(a, b=0):
    return a - b

def info():
    return "Jan", 25

print(rozdil(10))       # 10
jmeno, vek = info()
print(jmeno, vek)       # Jan 25

Typové anotace

Pomáhají zlepšit čitelnost a statickou kontrolu.

def prumer(a: float, b: float) -> float:
    return (a + b) / 2

print(prumer(4, 6))

Dokumentace funkce

Komentář uvnitř trojitých uvozovek = docstring.

def obvod_ctverce(a: float) -> float:
    """Vrátí obvod čtverce podle délky strany a."""
    return 4 * a

print(obvod_ctverce.__doc__)

Lokální a globální proměnné

x = 10  # globální proměnná

def test():
    x = 5  # lokální proměnná
    print("Uvnitř funkce:", x)

test()
print("Mimo funkci:", x)

Anonymní (lambda) funkce

Krátká forma zápisu funkce.
Používá se hlavně jako argument jiné funkce.

dvojnasobek = lambda x: x * 2
print(dvojnasobek(4))  # 8

map(), filter(), reduce()

map – aplikuje funkci na všechny prvky sekvence.
filter – filtruje prvky podle podmínky.
reduce – akumuluje prvky (nutno importovat z functools).

from functools import reduce

cisla = [1, 2, 3, 4, 5]
print(list(map(lambda x: x**2, cisla)))        # [1, 4, 9, 16, 25]
print(list(filter(lambda x: x % 2 == 0, cisla)))  # [2, 4]
print(reduce(lambda x, y: x + y, cisla))       # 15

Funkce jako argument

def vypis(func, hodnota):
    print("Výsledek:", func(hodnota))

def trojnasobek(x):
    return x * 3

vypis(trojnasobek, 4)
vypis(lambda x: x**2, 5)

Funkce vracející funkci

def mocnina(n):
    def vypocet(x):
        return x ** n
    return vypocet

druha = mocnina(2)
treti = mocnina(3)
print(druha(5))  # 25
print(treti(2))  # 8

Closures (uzávěry)

Vnořená funkce si pamatuje proměnné z okolí.

def pozdrav(jmeno):
    def vnitrni():
        print(f"Ahoj, {jmeno}!")
    return vnitrni

f = pozdrav("Jan")
f()  # Ahoj, Jan!

Dekorátory

Funkce, která upravuje chování jiné funkce.
Používá se např. pro logování, měření času, autorizaci.

def logovani(func):
    def wrapper(*args, **kwargs):
        print("Volání funkce:", func.__name__)
        return func(*args, **kwargs)
    return wrapper

@logovani
def vypis(text):
    print(text)

vypis("Ahoj")

Rekurze

Funkce, která volá sama sebe.
Potřebuje zastavovací podmínku!

def faktorial(n):
    if n <= 1:
        return 1
    return n * faktorial(n - 1)

print(faktorial(5))  # 120

Generátory a yield

Generátor = funkce, která vrací hodnoty postupně.
Pamatuje si stav mezi voláními.

def cisla_do(n):
    for i in range(n):
        yield i

for x in cisla_do(5):
    print(x)

List comprehension vs map/filter

cisla = [1, 2, 3, 4, 5]

# comprehension
ctverce = [x**2 for x in cisla]

# map + lambda
ctverce2 = list(map(lambda x: x**2, cisla))
print(ctverce, ctverce2)

Úkoly (1)

Vytvoř funkci obvod_obdelniku(a, b), která vrátí obvod.
Vytvoř lambda funkci, která vrací absolutní hodnotu.
Použij map() pro převod všech prvků [1,2,3,4] na jejich třetí mocninu.

Úkoly (2)

Napiš funkci, která přijme seznam a funkci – vrátí seznam, kde je na každý prvek aplikována daná funkce.
Použij ji s anonymní funkcí pro zdvojnásobení čísel.
Napiš dekorátor, který před a po volání funkce vypíše text "--- začátek ---" a "--- konec ---".

Shrnutí

Funkce zjednodušují kód a umožňují znovupoužití.
Lambda = krátká anonymní funkce.
map, filter, reduce = základ funkcionálního přístupu.
Dekorátory a generátory = pokročilé funkce pro čistý a efektivní kód.