4. Funkce

1. Definice a použití
2. Parametry a argumenty
   1. Poziční a párové entity
   2. Hvězdička a lomítko ve výčtu parametrů
   3. Parametry a argumenty *args
   4. Parametry a argumenty **kwargs
3. Funkce čisté a nečisté
4. Funkce 1. třídy a funkce vyššího řádu
5. Složené funkce
6. Vnořené funkce, klauzury
7. Anonymní funkce lambda
8. Matematické funkce
9. Cvičení

S pojmem funkce jsme se v předchozí kapitole již několikrát setkali, dokonce jsme některé již používali ( str, int, print, ... ). Jednalo se o takzvané vestavěné (built-in) funkce, které jsou součástí programového jádra Pythonu. Seznam vestavěných funkcí včetně jejich stručných popisů lze nalézt například zde.
Dalším typem funkce jsou funkce uživatelsky definované (user-defined), neboli uživatelské funkce.

S pojmem funkce úzce souvisí pojem metoda, což je funkce, definovaná uvnitř třídy (viz kap. 10) a je volaná pro objekt třídy (instanci) takzvanou tečkovou notací - jako například zde vestavěná metoda upper(), volaná (bez importu) pro objekt proměnné   hi

>>> hi = "nazdar"                  # objekt typu <string>
>>> hi.upper()
'NAZDAR'

4.1  Definice a použití

Funkce je uspořádané pořadí příkazů, které provádějí požadovanou operaci pro zadaný výčet parametrů. Příkazy jsou deklarovány v těle funkce, parametry jsou uvedeny v záhlaví funkce. Syntaxe pro definování funkce je tato:

def jméno_funkce(výčet parametrů):   # záhlaví ukončené dvojtečkou
    """
    docstringg - nepovinný dokumentační řetězec
    """
    příkazy                          # odsazené tělo funkce

Jméno funkce může být libovolné, kromě klíčového slova Pythonu. Výčet parametrů představuje výčet očekávaných hodnot, které je nutné funkci při invokaci (volání) poskytnout. Tento výčet může být i prázdný.

Pod záhlavím lze umístit dokumentační řetězec (docstring), který obsahuje krátkou informaci o funkci.

Uvnitř těla funkce může být libovolný počet příkazů, ale všechny musí být odsazeny od levého okraje. Doporučovány jsou 4 mezery, nedoporučuje se použití tabulátoru. Přechod kurzoru na počátek nového řádku signalizuje konec definování funkce.

Definice funkce se vždy skládá ze dvou částí - a to ze:.

1. záhlaví, které začíná klíčovým slovem a končí dvojtečkou.
2. těla, skládajícího se z jednoho či více stejně či různě odsazených příkazů.

Zde je příklad deklarace či definice funkce bez parametrů (a bez docstringu):

def novy_riadok():        # uživatelská funkce bez parametru
    print()               # invokace vestavěné funkce 'print'

Funkce se jmenuje novy_riadok. Prázdné závorky udávají, že je bez parametru. Její tělo obsahuje jediný příkaz, jímž je volání vestavěné funkce print(), která bez argumentu vrátí prázdný řádek. Deklaraci funkce si v následující ukázce uložíme do souboru s názvem emptyLines.py.

Definování nové funkce ještě nespustí její provádění. K tomu musíme funkci volat (invokovat). Při volání (invokaci) funkce zadáváme její jméno a výčet hodnot, kterým v této situaci říkáme argumenty. Ty jsou přiřazeny k definovaným parametrům funkce. Závorky jsou vždy povinné:

emptyLines.py

def novy_riadok():
    """ vrátí prázdný řádek """       # dokumentační řetězec
    print()                 # volání vestavěné fce uvnitř funkce            
            
print("First Line")         # volání vestavěné funkce print()
novy_riadok()               # volání vlastní uživatelské fce
print("Second Line")        # volání vestavěné funkce print()

 First Line
                # mezera je vytvořena volanou funkcí novy_riadok
 Second Line

Poznámka: Soubor emptyLines.py lze rovněž spustit ze systémové konzoly, pokud se "nacédujeme" do složky, v níž máme soubor uložený. V systémové konzole potom zadáme (například):

F:\Codetest\HowTo\ch-04> python emptyLines.py
First Line

Second Line

Nejjednodušší je funkce, která nic neprovádí:

def cosi():
    pass                      # 'pass' je klíčové slovo

4.2  Parametry a argumenty

Hodnotám, které zadáváme při volání funkce, říkáme argumenty. Tyto hodnoty jsou přiřazeny k parametrům v deklarovaném záhlaví funkce. Parametry jsou (zjednodušeně řečeno) výčtem jmen, argumenty jsou výčtem hodnot. Jednotlivé parametry výčtu představují lokální proměnné funkce.

Parametr s přiřazenou hodnotou (např. b="bim"), uvedený v záhlaví funkce, se označuje jako implicitní parametr, protože s deklarací jména se uvádí rovněž jeho implicitně přiřazená hodnota. Tento parametr je zároveň i implicitním argumentem, neboť při volání funkce stačí uvést jen jeho jméno, nebo tento argument neuvádět vůbec, pokud nepotřebujeme měnit jeho již zadanou (implicitní) hodnotu.
Jméno s přiřazenou hodnotou, uplatněné při volání funkce, se označuje jako pojmenovaný (keyword) argument.
V dalším textu použijeme označení párový parametr pro implicitní parametr a párový argument pro pojmenovaný argument.

Jednotlivé kategorie parametrů a argumentů jsou (podle pořadí zleva doprava) tyto:
poziční, variadické poziční, párové, variadické párové.

Poziční parametry jsou ty, o jejichž hodnotě se rozhoduje na základě pořadí přiřazovaných pozičních argumentů.

Variadické parametry *args a **kwargs jsou hvězdičkami dekorovaná jména kontejnerů předem neurčené délky pro poziční a párové argumenty.

Při zadávání argumentů deklarované funkci jsou kontrolovány tyto aspekty:

• shoda pořadí argumentů s pořadím deklarovaných parametrů
• shoda zadaných argumentů s logikou deklarované funkce - viz:

>>> li = [1,2,3,4]
>>> def mysum(arg):          # funkce s 1 parametrem
        print(sum(arg))
>>> mysum(li)                # 1 argument pro 1 parem. arg		
10
>>> mysum(1,2,3,4)           # 4 argumenty pro 1 param. arg
TypeError ...		

4.2.1  Poziční a párové entity

Mezi pozičními a párovými parametry či argumenty existuje zdánlivě benevolentní vztah, který však respektuje požadavek aby se poziční argument neocitl za párovým.

def mocnina(m, n=2):   # m je poziční, n=2 je párový parametr
    print(m**n)        # pořadí je OK        

>>> mocnina(3)          #1 OK: n=2 - párový parametr
9
>>> mocnina(3,2)        #2 OK: n=2 - potvrzené přiřazení
9
>>> mocnina(3,n=2)      #3 OK: n=2 - potvrzené přiřazení
9
>>> mocnina(3,n)        #4 viz poznámka dole
NameError: name 'n' is not defined    
>>> mocnina(2,3)        #5 OK: n=3 - změna přiřazení     
8
>>> mocnina(m=2,n=4)    #6 OK: oba argumenty jsou párové
16
>>> mocnina(m=2,3)      #7 porušení pravidla:      
SyntaxError: positional argument follows keyword argument
             ... poziční argument nesmí přijít za párovým

Poznámka ad #4: Zde nás Python škádlí. Chce, abychom při volání funkce využili již přiřazenou hodnotu (tudíž ji neuváděli) nebo ji opětovně deklarovali (n=2) nebo abychom ji přiřadili hodnotu jinou (např. n=2.0).
Poznámka ad #7: Jak vidno, poziční parametr (m) lze při invokaci změnit na párový, pokud není následován pozičním argumentem.

4.2.2  Hvězdička a lomítko ve výčtu parametrů

Hvězdička * ve výčtu parametrů přikazuje, aby všechny parametry, které za ní následují, přijímaly pouze párové argumenty:

def foo(a, b, *, c, d):          # hvězdička jen organizuje      
    print(a, b, c, d)

>>> foo(2, 4, c="jin", "jan")    # "jan" je poziční argument
SyntaxError: positional argument follows keyword argument
>>> foo(2, 4, c="jin", d="jan")  # c,d jsou párové argumenty     
 2 4 jin jan                     # no comment

Lomítko / ve výčtu parametrů přikazuje, aby všechny předcházející parametry přijímaly pouze poziční argumenty:

def ef(a, b, /, c, d, *, e, f):    # lomítko jen organizuje 
    print(a, b, c, d, e, f)

Mezilehlé argumenty pro parametry c, d mohou být poziční i párové (avšak jen ve správném pořadí).

>>> ef(10, 20, 30, d=40, e=50, f=60)
 10 20 30 40 50 60
>>> f(10, a=20, 30, d=40, e=50, f=60)
SyntaxError: positional argument follows keyword argument
>>> ef(10, b=20, c=30, d=40, e=50, f=60)
TypeError: f() got some positional-only arguments passed as keyword arguments
        # dle definice mají být první dva argumenty poziční

Některé vestavěné funkce, například len(obj), připouštějí jenom poziční argumenty:

>>> len(obj='hello')
TypeError: len() takes no keyword arguments

4.2.3  Parametry a argumenty *args

Variadické argumenty *args mají formát entice (tuple) a setu, jejchž prvky jsou poziční, případně párové argumenty key := value; nebo slovníku s páry 'key' : 'value'.

Invokace funkce s variadickým parametrem typu *args a s vnořenou vestavěnou funkcí print():

>>> def myFun(*argv):
        for arg in argv:
            print(arg)   # tato funkce poskytuje více možností

# Argumenty funkce:		
>>> myt = (a:="Tam za vodou", b:="v rákosí ...")   # entice
>>> mys = {a:="Tam za vodou", b:="v rákosí ..."}   # set
>>> myd = {a:"Tam za vodou", b:"v rákosí ..."}     # slovník

# Různé invokace funkce:
>>> myFun(*myt); myFun(*myd)
>>> myFun(a:="Tam za vodou", b:="v rákosí ...")
>>> myFun(*{a:"Tam za vodou", b:"v rákosí ..."})
>>> myFun(*mys)

num1 = 7,11
 Tam za vodou
 v rákosí ...

# ... porovnejte s invokací (jen tak, pro zajímavost):
>>> myFun(myt); myFun(myd)

# Pozor na způsob přiřazení:
>>> mytt = (a: "Tam za vodou", b: "v rákosí ...")
    mytt = (a: "Tam za vodou", b: "v rákosí ...")
            ^
SyntaxError: invalid syntax   # slovníková forma obsahu vyžaduje složené závorky

Další příklad: Vestavěná funkce max(...) vrátí největší ze zadaných argumentů. V následné ukázce je variadická entice použita jako argument (variadický parametr je zřejmě obsažen v definici funkce).

Při invokaci vestavěné funkce lze pro variadický parametr uplatnit buď výčet hodnot nebo variadický či prostý argument:

>>> num1 = 7,11                       # entice, neboli tuple        
>>> max(7,11), max(num1), max(*num1)
 (11, 11, 11)

>>> num2 = 3*11, 5**3, 512-9, 1024*0; num2
 (33, 125, 503, 0) 
>>> max(3*11, 5**3, 512-9, 1024*0), max(num2), max(*num2)
(503, 503, 503)

>>> str = "abakus"   
>>> max("abakus"), max(str), max(*str)
('u', 'u', 'u')    # pořadí je dáno přiřazenými kódovými čísly

def add(*number):        # entice jako variadický parametr
    result=0
    for i in number:
         result +=i
    print(result)

>>> add(1,2,3,4,5)        # přes poziční argumenty
 15
>>> num = (47,11,12)  
>>> add(*num)             # přes variadickou proměnnou
 70
add(num)                  # přes prostou proměnnou
TypeError: unsupported operand ...

Kombinace parametrů s *args

Pro ilustraci variadického parametru (*b) vytvoříme funkci, ve které použijeme i poziční i párový parametr:

def sum_not_first(a,*b,c=8):   # poziční, variadický, párový parametr 
    temp = sum(b)
    print(f"sum(b)=", temp, " a,b,c =",a,b,c)
    print(f"sum_not_first=sum(b)+c=", temp+c)

Variadický poziční parametr *b posbírá všechny volné poziční argumenty a vloží (zabalí) je do entice:

>>> sum_not_first(1, 2, 3, 4)       # c=8 stále platí!
 sum(b)= 9  a,b,c = 1 (2, 3, 4) 8    # o '1' si řekne par. 'a'
 sum_not_first=sum(b)+c= 17          

Jinak tomu je s variadickým parametrem na prvním místě. Za variadickým pozičním argumentem smějí přijít jen párové argumenty!:

def sum_not_first(*b,c=8,a):      # zatím nic proti ničemu
    temp = sum(b)
    print(f"sum(b)=", temp, " a,b,c =",a,b,c)
    print(f"sum_not_first=sum(b)+c=", temp+c)

>>> sum_not_first(1, 2, 3, 4)     # chyba se projeví až při invokaci        
TypeError: sum_not_first() missing 1 required keyword-only
           argument: 'a'          # chybí 1 párový argument

Argument pro a měl být zadán jako párový, protože za variadickým i párovým (c=8) argumentem nesmí přijít poziční argument, byť je jako poziční parametr uveden (a):

>>> sum_not_first(1, 2, 3, a=4)       # a=4: náprava chyby          
 sum(b)= 6  a,b,c = 4 (1, 2, 3) 8
 sum_not_first=sum(b)+c= 14

Nyní si ukažme pozici *b na konci výčtu:

def sum_not_first(a,c=8,*b):           
    temp = sum(b)
    print(f"sum(b)=", temp, " a,b,c =",a,b,c)
    print(f"sum_not_first =", temp+c)

>>> sum_not_first(1, 2, 3, 4)         # něma problema   
 sum(b)= 7  a,b,c = 1 (3, 4) 2
 sum_not_first = 9          

Podle klobacího pořádku obdržel parametr c hodnotu 2. Jak vidno, párový parametr je pěkný nezdvořák. Sáhne si po nabídnuté hodnotě i když již přiřazenou hodnotu má.

Lze rovněž použít pouze prvky sběrného parametru:

def sum_skip_first(a,*b):
    temp = sum(b)              # sum() je vestavěná funkce               
    print(f"a, b, sum(b) is: ", a, b, temp)

>>> sum_skip_first(1, 2, 3, 4)    
 a, b, sum(b) is:  1 (2, 3, 4) 9          

Variadický formát lze použít i při obsazování pozičních parametrů:

def test_args(a, b, c):
    print("Virbl:", (b + c) * a)  # hvězdička zde značí součin

>>> slova = (" abra", "kadabra")   # argumentem je entice
>>> test_args(2, *slova)           # hvězdička signalizuje entici
 Virbl: abrakadabra abrakadabra

Případně:

>>> pairs = {" hola": "b", "hej": "c"}  # argumentem je slovník
>>> test_args(2, *pairs)                # hvězdička signalizuje entici
 Virbl: holahej holahej
 # Enticové rozbalení slovníku vrací pouze klíče slovníku.

4.2.4  Parametry a argumenty **qwargs

Variadické parametry a argumenty **kwargs mají formát slovníku, jehož prvky jsou slovníkové páry 'key':'value' , případně páry jméno=hodnota.

# kwargs.py
def about(**users):
    for key,val in users.items():
        print(f"{key} => {val}")

a) Invokace funkce pro elementy slovníku:

>>> log={'user':'Tom', 'city':'London', 'pet':['dog','cat','fish']}
>>> about(**log)             # argument má formát slovníku
 user => Tom
 city => London
 pet => ['dog', 'cat', 'fish']

b) Invokace funkce pro párové argumenty (jméno=hodnota):

# zde je argumentem výčet párů (bez rozbalení):
>>> about(user='Tom', city='London',   pet=['dog','cat','fish'])
 user => Tom
 city => London
 pet => ['dog', 'cat', 'fish']

Kombinace parametrů s **qwargs

Sběrné parametry mohou posloužit jako šikovný 'vysavač' pro nadbytečně zadané argumenty:

def eta(a, b, *c, **d):     # a,b jsou poziční parametry
    print((a + b), c)

>>> eta(2, 3, 4, 6)     # parametr *c vyluxoval co zbylo,
 5 (4, 6)                # na parametr **d nezbylo nic

Půvabná je rovněž tato ukázka rozbalení sběrných parametrů u slovníku:

def moje_troje(a, b, c):
    print(a, b, c)

>>> a = {'i': "one", 'j': "two", 'k': "three"}  # slovník
>>> moje_troje(*a)   
 i j k          # "Enticové" rozbalení slovníku vrací  klíče slovníku.
>>> moje_troje(**a)
 TypeError: moje_troje() got an unexpected keyword argument 'i'                

Při luxování argumentů musí mít interpret jasno, co kam může přijít. Základní instrukce obdrží z výčtu parametrů v záhlaví funkce. Při invokaci funkce pro aktuální výčet argumentů provede příkazy z těla funkce:

def foo(a, b, *args, c, d, **kwargs):        
    print(a, b, args, c, d, kwargs)   
td = {"m":109,"n":110}         
kwd = {"q":113,"r":114}        

Proměnné td, kwd mají formát slovníku. Lze je uplatnit jako prosté argumenty td, kwd, variadické argumenty *td, *kwd (entice) a jako slovník **kwd:

>>> foo(1,2,3,4, td, 'oko', c=6, d='nos', kwd)
 SyntaxError: positional argument follows keyword argument

Viníkem je kwd, zadali jsme jej bez hvězdičkového dekorátoru pro slovník (**). Zkusme to znova:

#1 prosté uplatnění 'td' a enticové rozbalení '*kwd':
>>> foo(1,2,3,4, td, 'oko', c=6, d='nos', *kwd)
 1 2 (3, 4, {'m': 109, 'n': 110}, 'oko', 'q', 'r') 6 nos {}
  
#2 'enticové' rozbalení '*td' i '*kwd':
>>> foo(1,2,3,4,*td,'oko',c=6,d='nos',*kwd)
 1 2 (3, 4, 'm', 'n', 'oko', 'q', 'r') 6 nos {}
           
#3 prosté uplatnění 'td' a slovníkové rozbalení '**kwd':
>>> foo(1,2,3,4,td,'oko',c=6,d='nos',**kwd)
 1 2 (3, 4, {'m': 109, 'n': 110}, 'oko') 6 nos {'q': 113, 'r': 114}

#4 enticové rozbalení 'td' a slovníkové rozbalení '**kwd':
>>> foo(1,2,3,4,*td,'oko',c=6,d='nos',**kwd)
 1 2 (3, 4, 'm', 'n', 'oko') 6 nos {'q': 113, 'r': 114}  

Ve shodě s kap. 9.7 (metoda values()) umíme rozbalit i hodnoty slovníků:

>>> foo(1,2,3,4,*td.values(),'oko',c=6,d='nos',*kwd.values())
1 2 (3, 4, 109, 110, 'oko', 113, 114) 6 nos {}

Nepřehlédněme, že se nám rozbalené hodnoty (i klíče) slovníků přiřazují do variadické entice.

4.3  Funkce čisté a nečisté

Vestavěné funkce, které jsme zatím používali, jako abs, pow a max nám vracely konkrétní číselné výsledky. Volání každé z těchto funkcí generuje hodnotu, kterou obvykle přiřadíme k proměnné nebo použijeme jako součást výrazu:

>>> biggest = max(3, 7, 2, 5); biggest          # --> 7
>>> x = abs(3 - 11) + 10; x                     # --> 18

Ve vlastních funkcích jsme vesměs používali vestavěnou funkci print(), která nám vracela různá sdělení, jímž však mohl být i výsledek výpočtu, například:

def area(rad):       # 'rad' je zde poloměr kruhové plochy
    print(3.14*rad**2)           # area(10) -->> 314.0 

To, že funkce area(rad) zajistí výtisk výsledku číselné operace, ještě neznamená, že vrací vždy použitelný výsledek. Pokusíme-li se tento výsledek použít při volání jiné funkce, například:

def suma(rad, b):
   print(area(rad) + b)       

dostáváme chybové hlášení, že se pokoušíme sečíst nesourodé operandy:

>>> suma(10, 100)
314.0                          # výstup z fce area(rad)
 TypeError: unsupported operand type(s) for +: 'NoneType' 
and 'int' 

Nahradíme-li však v první funkci volání print() příkazem return (viz kap. 5.2), budeme moci její výstup v další funkci použít:

def arrea(rad):  
   return  3.14*rad**2        # arrea(10) -->> 314.0

def suma(rad, b):
   print(arrea(rad) + b)       # suma(10,100) -->> 414.0

Příkaz return ukončí provádění funkce v místě svého výskytu a vrací dále použitelnou hodnotu (pokud taková existuje).

Úspěch úspěšné varianty funkce suma() je důsledkem toho, že jsme jako argument funkce print() použili takzvanou čistou variantu funkce area().

Čistá funkce nemění hodnotu vstupu, nemá vedlejší účinky a pro stejný vstup vrací vždy stejný výsledek. Vedlejší účinky produkují funkce print() a input().
Pokusíme-li se tedy použít výstup funkce suma() jako hodnotu pro další výpočet, dostaneme opět chybové hlášení, neboť složená funkce suma() obsahuje funkci print().

Funkce, která mění vstupní hodnoty, má vedlejší účinky a je závislá na stavu vnějšího prostředí (například proměnných mimo funkci), je označována jako funkce nečistá (inpure) neboli modifikátor.

Použití příkazu return samo o sobě čitotu funkce nezaručuje. Ukážeme si to na příkladu dvou funkcí, které přijmou seznam jako argument a vynásobí dvěma každou jeho položku.

Zde je double_stuff_p jako čistá funkce, která nemění zadaný seznam:

def double_stuff_p(a_list):          
    new_list = []              # zárodek nového seznamu 
    for value in a_list:
        new_list += [2*value]      
    return new_list            # nebo: print(new_list)     

Čistotu této funkci zajišťuje nová pomocná proměnná new_list.

>>> lst = ["hi", 22, True]     # True bude při kompilaci redukováno na 1
>>> double_stuff_p (lst)
 ['hihi', 44, 2]
>>> lst
 ['hi', 22, True]               # vstupní seznam nezměněn

Opakovaným voláním funkce čisté pro stejné argumenty dostáváme vždy stejný výstup, a to bez vedlejších účinků, například modifikace vstupních údajů.

Příklad téže funkce jako nečisté. Tato funkce mění každým voláním prvky zadaného argumentu i hodnotu výstupu přesto, že končí příkazem return. Je to způsobeno skladbou samotné funkce:

def double_stuff_m(a_list):         # argumentem bude seznam
    for i in range(len(a_list)):    # postupná změna vstupu
        a_list[i] = a_list[i] * 2
    return a_list                   # nebo: print(a_list)		

Tato funkce mění (modifikuje) hodnotu proměnné lst.

>>> lst = ["hi", 22, True]
>>> double_stuff_m(lst)
 ['hihi', 44, 2]                 # hodnota lst se mění!
>>> double_stuff_m(lst)             
 ['hihihihi', 88, 4]             # mění se i při opakovaném volání 

Jak si lze ověřit, příkaz return je v tomto případě rovnocenný s funcí print().

Co je lepší?

Má se za to, že čisté funkce se snadněji tvoří a jsou méně náchylné k chybám než programy, které používají funkce nečisté. Nicméně, programy s čistými funkcemi jsou někdy méně výkonné.

4.4  Funkce 1. třídy a vyššího řádu

Funkce první třídy

Funkce první třídy má tyto vlastnosti:

1. lze ji přiřadit jako hodnotu k proměnné
2. lze ji zadat jako argument jiné funkce
3. lze ji použít jako výstup jiné funkce

Funkce vyššího řádu

Funkce či metoda, která přijme jinou funkci jako argument nebo která jinou funkci vrací, se nazývá funkce (metoda) vyššího řádu.

Příkladem takové funkce budiž níže uvedená funkce doto():

def f(n):
   return 3*n - 6
def g(n):              #  fce f, g, h jsou funkce 1. třídy
   return 5*n + 2
def h(n):
   return -2*n + 17
def doto(value, fun):
   return fun(value)   # argumentem má být hodnota a funkce       

>>> doto(7, f)
 15           
>>> doto(7, g)
 37           
>>> doto(7, h)
 3          

Funkce vyššího řádu doto je volána třikrát pro stejný číselný argument a pro tři různá jména čistých funkcí 1. třídy.

Jiný příklad funkce vyššího řádu:

def print_haf():               # funkce první třídy 
    print('Haff')

def do_twice(func):            # funkce vyššího řádu
    func(); func()      

>>> do_twice(print_haf)      
 Haff
 Haff

Poznámka: Z textu v těle funkce do_twice(func) vyplývá, že parametr func očekává při invokaci název funkce - zde byl dosazen název funkce print_haf():
Při volání funkce do_twice je parametr func nahrazen argumentem, jímž je název funkce print_haf.

Funkcemi vyššího řádu jsou i dekorátory - viz Kap. 10.7.
V kapitole 5.9,10 jsou popsány vestavěné funkce vyššího řádu   map(), reduce(), filter(), zip().

4.5  Složené funkce

Kromě toho, že můžeme funkci zadat jiné funkci jako argument (jak popsáno v předchozím odstavci u funkce vyššího řádu), můžeme uvnitř funkce volat jinou, případně tutéž funkci. V obou případech hovoříme o složené funkci, ve druhém navíc o rekurzivní (složené) funkci.
Rekurzivní funkci poznáme v Kap. 11.1.

Jako další příklad prosté složené funkce (nikoliv funkce vyššího řádu) si napíšeme funkci, která pro zadané dva body (střed kružnice a bod na obvodu) vypočítá plochu kruhu.

Střed kružnice uložíme do proměnných xc, yc, bod obvodu do xp, yp.
Prvním krokem bude určení poloměru kružnice, což je vzdálenost mezi oběma body. Dalším krokem bude výpočet plochy.

Pro určení vzdálenosti dvou bodů si napíšeme funkci distance, pro určení plochy si napíšeme funkci area, přičemž použijeme importovanou funkci sqrt (square root) a konstantu pi z modulu math :

import math    # potřebujeme funkci 'sqrt' a konstantu 'pi'
def distance(xc,yc, xp,yp):
    return math.sqrt((xp-xc)**2 + (yp-yc)**2)
def area(rad):
    print(math.pi*rad**2)

Pro další výpočet si vytvoříme dočasné proměnné radius, distance, které vložíme do další funkce:

def area2(xc, yc, xp, yp):
    radius = distance(xc, yc, xp, yp)
    result = area(radius)
    return result

Funkci jsme pojmenovali area2, abychom ji odlišili od funkce area, definované dříve. V jednom skriptu můžeme mít jenom jednu funkci daného jména.

Dočasné proměnné radius a result jsou užitečné jenom pro rozvoj programu a vychytání chyb. Jakmile nám program pracuje správně, můžeme jej zestručnit spojením funkcí.

def area2(xc, yc, xp, yp):
    return area(distance(xc, yc, xp, yp))

Výsledkem je funkce s odkazy na funkce, deklarované mimo tělo aktuální funkce. Při volání této funkce musí mít interpret k disposici deklarace zmiňovaných fukcí.

>>> area2(20, 20, 0, 10)
 1570.7963267948967

Funkce, která přijímá jinou funkci jako argument, se řadí mezi funkce vyššího řádu. S tímto typem funkcí jsme se setkali již v odstavci 4.4.

4.6  Vnořené funkce, klauzury

Jak již víme, vnořené (vnitřní) funkce jsou funkce, deklarované uvnitř jiných funkcí. Vnitřní funkce má přístup k proměnným a argumentům vnější funkce i k proměnným globálního prostoru, pokud nejsou zastíněny, to jest, pokud neexistují stejnojmenné proměnné v prostoru vnitřní funkce. Vnější funkce ale nemá přístup k proměnným a argumentům vnitřní funkce.

Název vnější funkce, zapsané v globálním prostoru souboru, tvoří globální proměnnou tohoto prostoru.

y = 8                          # globální proměnná y
def outer_var():               # vnější funkce
    x = 2                      # lokální proměnná vnější fce 
    def inner_var():           # vnitřní funkce
        x = 6                  # lokální proměnná vnitřní fce
        print ("inner =", x + y)     # příkaz vnitřní funkce
    print ("outer =", x + y)   # příkaz vnější funkce 
    inner_var()                # invokace vnitřní funkce

Proměnná vnitřní fce (x=6) stíní proměnnou vnější fce (x=2). Obě funkce mají přístup ke globální proměnné y=8:

>>> outer_var()                # invokace vnější funkce
 outer = 10                     # x,y = 2,8
 inner = 14                     # x,y = 6,8

Pokud bychom potřebovali aby hodnota proměnné vnitřní funkce byla přístupná i z prostoru vnější funkce, deklarujeme ji jako nonlocal:

a = "piroh"                           # globální proměnná
def outer_fce():                      # deklarace vnější fce
    a = 5                             # lokální proměnná vnější fce
    def inner_fce():                  # deklarace vnitřní fce
        nonlocal a                    # deklarace 'nelokálnosti'
        a = 10                        # lokální proměnná vnitřní fce
        print("Vnitřní fce: a = ", a) # příkaz vnitřní fce
    print("Vnější fce1: a = ", a)     # příkaz vnější fce
    inner_fce()                       # volání vnitřní fce 
    print("Vnější fce2: a = ", a)     # příkaz vnější fce
outer_fce()                           # volání vnější fce

 Vnější fce1: a =  5
 Vnitřní fce: a =  10
 Vnější fce2: a =  10                 # původně bylo a = 5

Kdybychom vypustili deklaraci nelokálnosti (nonlocal a), dostali bychom tento výstup:

 Vnější fce1: a =  5
 Vnitřní fce: a =  10
 Vnější fce2: a =  5

Kdybychom zrušili všechny proměnné a uvnitř funkcí, dostali bychom tento výstup:

 Vnější fce1: a =  piroh
 Vnitřní fce: a =  piroh
 Vnější fce2: a =  piroh

Kdybychom místo deklarace nonlocal použili ve vnitřní funkci deklaraci global, dostali bychom tento výstup:

 Vnější fce1: a =  5
 Vnitřní fce: a =  10
 Vnější fce2: a =  5

Kdybychom deklaraci global použili ve vnější funkci, dostali bychom tento výstup:

 Vnější fce1: a =  5
 Vnitřní fce: a =  10
 Vnější fce2: a =  5

Klíčová slova nonlocal a global lze použít v těchto jmenných prostorech:

• Deklaraci nonlocal lze použít pouze uvnitř vnitřní funkce. Hodnota takto dekorované proměnné platí uvnitř vnitřní i vnější funkce; neplatí mimo funkce.
• Deklaraci global lze použít uvnitř vnitřní nebo vnější funkce. Hodnota takto dekorované proměnné platí v prostoru deklarace a v prostoru mimo obě funkce.

Velkým korektorem přístupnosti je chyba typu UnboundLocalError: local variable 's' referenced before assignment, jak lze demonstrovat na následující ukázce:

def ule():
    global s
    print("one: s = ", s)          # první reference 's'
    s = "zlatíčko"
    print("two: s = ", s)          # druhá reference 's'

>>> s = "Hordubal"; ule()
 one: s =  Hordubal
 two: s =  zlatíčko                # výstup z funkce ule()
>>> print("three: s = ", s)        # třetí reference 's'
 three: s =  zlatíčko          

Bez deklarace global s bychom obdrželi výše uvedený UnboundLocalError. Deklarace učiní globální proměnnou s="Hordubal" přístupnou první referenci s uvnitř funkce. Druhá reference s má již k disposici proměnnou s="zlatíčko", pro kterou deklarace globálu neplatí, protože je stíněná zlatíčkem. Třetí reference s mimo funkci musí použít deklarovanou globální hodnotu "zlatíčko", která zakrývá (stíní) skutečnou globální hodnotu "Hordubal".

Klauzury (closures)

Pokud vnořená funkce odkazuje na proměnnou, deklarovanou v rámci vnější funkce a pokud vnější funkce vrací vnitřní funkci, označujeme vnořenou funkci jako klauzuru. Vnitřní funkce může použít parametr (x), deklarovaný vnější funkcí:

def num_outer(x):                # vnější funkce
   def num_inner(y):             # vnitřní funkce
      return x * y               # výstup z vnitřní funkce
   return num_inner              # výstup z vnější funkce

Volání naší vnější funkce vrací vnitřní funkci pro argument vnější funkce:

>>> num_outer(10)              # chybí hodnota parametru y       
<function num_outer.<locals>.num_inner at 0x03DE2028>

Volání klauzury lze provést jedinou invokací:

>>> num_outer(12)(4)
 48

Nebo ji lze volat ve dvou krocích s použitím pomocné proměnné:

>>> huk = num_outer(12)          # x = 12
>>> huk(4)                       # y =  4
 48

Vnitřní funkce je zde vázaná na hodnotu x=12, pročež lze funkci num_outer případně smazat a zadávat argument jen pro vnitřní funkci:

>>> del(num_outer)
huk(5)                           # x = 12, y = 5
 60

Vnější funkce s proměnnou:

def pat():               # vnější funkce
   msg = "Jsem 'pat'"             # proměnná vnější funkce                                        
   def mat():            # vnitřní funkce
      print(msg)                  # příkaz vnitřní funkce
   return mat                     # příkaz vnější funkce

>>> pat()()
 Jsem 'pat'
>>> bat = pat(); bat()
 Jsem 'pat'

4.7  Anonymní funkce lambda

Speciálním druhem funkcí jsou takzvané anonymní funkce, které používají společné označení lambda. Anonymní jsou proto, že nemaji vlastní jméno. Na rozdíl od ostatních funkcí se deklarují přímo v místě použití. Jejich syntaxe je velice prostá:

lambda parametry: výraz [argumenty]

Funkce lambda může mít libovolný počet parametrů ale jen jeden deklarovaný výraz (expression).

>>> (lambda x, y: x * y) (2, 3)    # bezprostředně volané provedení funkce
6
>>> soucin = lambda x, y: x * y    # jméno umožňuje opakované použití 
>>> soucin(2, 3)                   # invokace 
6

Anonymní funkci lze s výhodou použít jako argument pro jinou funkci (připadně ještě s jinou funkcí):

# lambda uvnitř skriptu:
numera = (2, 6, 8, 10, 11, 4, 12, 7, 13, 17, 0, 3, 21)   
selekce = list(filter(lambda num: (num > 7), numera))
print(selekce)               # -->[8, 10, 11, 12, 13, 17, 21]

Ve funkci lambda lze rovněž použít variadický parametr **kwargs:

# parametry funkce jsou hodnoty (values) slovníku 'slov':
>>> slov = {'one':1, 'two':2, 'three':3}   
>>>mean_val = (lambda **slov: sum(slov.values()) / len(slov))
>>> mean_val(**slov)
2.0
# tato funkce pracuje prostřednictvím proměnné **kwargs se 
slovníkem (viz výše) i s enticí pojmenovaných (keyword) hodnot:                
>>> mean_val(one=1, two=2, three=3)        
2.0 

Poznámky:

Funkce list, tuple, set - jsou funkce pro vytvoření seznamu, entice a setu.
Funkce filter - viz odst. 5.9.

4.8  Matematické funkce

Python disponuje obsáhlou řadou vestavěných matematických funkcí a konstant, k nímž získáme přístup importem modulu math (viz např. Python math module):

>>> import math
>>> math.exp(2)                          # --> e**2
7.38905609893065
>>> 3*math.pi
9.42477796076938

4.9  Cvičení