Python Jiří Znamenáček Funkce čtené podruhé 2017-05-10

Funkce v Python'u jsou – spolu s n-ticemi – bez diskuse jedním z jeho nejdůležitějších prvků. Komu něco říká pojem first class citizen, dokáže si představit proč ^_~

Nicméně nic není nikdy tak růžové, jak to na první (a někdy i na druhý) pohled vypadá, takže tuto přehledovou přednášku by si měli přečíst – a vyzkoušet! – všichni bez rozdílu.

Funkce v Python'u se zavádí pomocí klíčového slova def a za dvojtečkou následuje odsazený blok kódu (vlastní tělo funkce):

def fn(): pass

Návratovou hodnotu není potřeba výslovně uvádět, pokud žádná není potřeba. Python pak automaticky vrátí hodnotu None:

>>> def fn(): ... pass >>> a = fn() >>> print(a) None

Na druhou stranu z funkce můžeme kdykoliv vrátit naprosto libovolně, co nás zrovna napadne:

>>> def fn(): ... return 'Ahoj!', 123, {'xyz': 666} >>> fn() ('Ahoj!', 123, {'xyz': 666}) Celý „trik“ spočívá v datovém typu n-tice – potřebujeme-li vrátit víc než jeden prvek, prostě napíšeme čárku, čímž zavedeme n-tici, a vesele přidáváme tolik prvků, kolik zrovna potřebujeme.

Funkce v Python'u samozřejmě dokážou přejímat vstupní parametry:

>>> def fn(a, b, c): ... print(a, b, c) >>> fn(1, 'abc', [1, None, ('1', 'b')]) 1 abc [1, None, ('1', 'b')]

A to dokonce libovolný počet:

>>> def fn(*args): ... print(args) >>> fn() () >>> fn(1) (1,) >>> fn(1, 'a', {'zzz': 333}) (1, 'a', {'zzz': 333}) Zde se o „trik“ prozměnu postaraĺ operátor *, který provedl převod libovolného počtu vstupních parametrů funkce do jedné jediné proměnné typu n-tice (já jsem říkal, že bez n-tic by Python nebyl Python!).

Python však také obsahuje jednu velmi příjemnou „vychytávku“ – parametry s výchozí hodnotou (a tudíž také jménem). Když je nevyplníte při volání, použije se přednastavená hodnota:

>>> def fn(y=3): ... print(2**y) >>> fn() 8 >>> fn(2) 4

Nepřekvapivě i jich může být libovolný počet:

>>> def fn(**kwargs): ... print(kwargs) >>> fn() {} >>> fn(a=1, xyz='666') {'a': 1, 'xyz': '666'} Zde se o „kouzlo“ překladu na datový typ slovník stará prozměnu operátor **.

Oba druhy parametrů – poziční i pojmenované – je samozřejmě možno míchat dohromady. Dokud budou pojmenované použity jako poslední, vše bude krásně fungovat (a dokonce je můžete i volat jako poziční):

>>> def fn(x, y=3): ... print(x**y) ... >>> fn() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: fn() missing 1 required positional argument: 'x' >>> fn(2) 8 >>> fn(2, 4) 16 >>> fn(2, y=4) 16 >>> fn(x=2, y=4) 16 >>> fn(x=2, 4) File "<stdin>", line 1 SyntaxError: positional argument follows keyword argument

Přidáním * do definice funkce si můžete vynutit závazné použití jména u – vybraných! – parametrů s výchozí hodnotou:

>>> def fn(a, b, x=2, *, y=3): ... print(a, b, x, y) >>> fn() Traceback (most recent call last): File "<pyshell#128>", line 1, in <module> fn() TypeError: fn() missing 2 required positional arguments: 'a' and 'b' >>> fn(7, 8) 7 8 2 3 >>> fn(7, 8, 'x') 7 8 x 3 >>> fn(7, 8, 'x', 'y') Traceback (most recent call last): File "<pyshell#131>", line 1, in <module> fn(7, 8, 'x', 'y') TypeError: fn() takes from 2 to 3 positional arguments but 4 were given >>> fn(7, 8, 'x', y='y') 7 8 x y PS: Kdo by přemýšlel, k čemu je to dobré, vzpomeň si na funkci print() – jak jinak řídit její chování, když vstupních objektů k vytištění může být libovolný počet?

Od verze Python'u 3.8 si už můžete pomocí / vynutit i zadávání parametrů pouze pozicí:

def fn(x, y, /, t, u, v=3, *, z='basta fidli'): ...

Parametry x a y je nyní možné zadat jen a pouze jako první a druhý (to jest fn(1, 2, ...)) a nikoli pomocí jejich interního implementačního jména (tedy jako fn(x=1, y=2, ...)).

Ne vždy se ale všechno chová očekávaným způsobem, jako zde při odkazu na globální proměnnou:

>>> x = 3 ... ... def fn(y=x): ... print(y) >>> fn(5) 5 >>> fn() 3 >>> x = 2 >>> fn() 3 >>> fn(4) 4

Python totiž hlavičku funkce zpracuje pouze při jejím prvním čtení, a v tu chvíli měla proměnná x hodnotu 3, která jí tak poněkud neintuitivně zůstane i nadále.

Pokud je výchozí hodnota parametru proměnného datového typu, čeká nás podobné překvapení:

>>> def fn(x, y=[]): ... y.append(x) ... print(y) >>> fn(1, []) [1] >>> fn(1, []) [1] >>> fn(1) [1] >>> fn(1) [1, 1] >>> fn(1, []) [1] >>> fn(1) [1, 1, 1]

Nezvyklé, není-liž pravda? Nicméně dá se to využít třebas pro jednoduchou memoizaci bez potřeby zavádět na zapamatování vstupních parametrů a spočítaných výsledků vlastní globální proměnnou.

Jelikož funkce v Python'u je „jenom další objekt“, asi už nepřekvapí, že ji můžeme předat na vstupu:

>>> def fn(x, f): ... print(f(x)) >>> fn('abc', len) 3 A samozřejmě nejen funkce vestavěné můžeme předávat. To jsem jenom nechtěl zaneřádit příklad definicí další vlastní funkce.

Stejně dobře můžeme funkci z funkce také vrátit:

>>> def fn(): ... def f(): ... print('Ahoj!') ... return f >>> fn() <function fn.<locals>.f at 0x7fa1cf9ce730> >>> fn()() Ahoj!

Na funkcích vrácených z funkcí je krásné to, že si drží okolní kontext ze chvíle svého vrácení (tedy vytvoření):

>>> def fn(x): ... def f(): ... print('Ahoj,', x, '!') ... return f >>> fn('brachu')() Ahoj, brachu ! Tomuto chování se odborně říká uzávěr aneb closure. Python nepodporuje uzávěry v celé jejich šíři (například funkce zavolané z funkcí do kontextu volající funkce přístup nemají), nicméně na většinu použití to stačí i tak.

Spoustu věcí o funkcích jsem v této přednášce samozřejmě vůbec nezmínil, namátkou:

Nicméně je snad jasné, že funkce v Python'u jsou velmi mocné (spousta vlastností jazyka na nich závisí; podobně jako na n-ticích ;-), ale také na nás mají připraveno pár velmi překvapivých a ne úplně očekávaných vlastností, které si při práci s nimi musíme dobře hlídat, aby nám nepodrazily nohy.