Funkce v pythonu 3. Definice funkce. Operátor Def Argumenty pozice a klíčových slov

Pojmenované funkce, instrukce def

Funkce v pythonu je objekt, který přebírá argumenty a vrací hodnotu. Funkce je obvykle definována pomocí příkazu def.

Pojďme definovat nejjednodušší funkci:

Příkaz return říká, že má vrátit hodnotu. V našem případě funkce vrací součet x a y.

Nyní to můžeme nazvat:

>>> přidat (1, 10)

>>> add("abc", "def")

Funkce může být libovolně složitá a může vracet libovolné objekty (seznamy, n-tice a dokonce i funkce!):

>>> def newfunc(n):

Def myfunc(x):

Návrat x + n

Return myfunk

>>> new = newfunc(100) # new je funkce

>>> nové (200)

Funkce nemusí končit příkazem return, ale funkce vrátí hodnotuNone:

>>> def func():

>>> tisk (func())

Funkční argumenty

Funkce může mít libovolný počet argumentů nebo žádný. Časté jsou také funkce s libovolným počtem argumentů, funkce s pozičními a pojmenovanými argumenty, povinné a nepovinné.

>>> def func(a, b, c=2): # c - volitelný argument

Vraťte a + b + c

>>> func(1, 2) # a = 1, b = 2, c = 2 (výchozí)

>>> func(1, 2, 3) # a = 1, b = 2, c = 3

>>> func(a=1, b=3) # a = 1, b = 3, c = 2

>>> func(a=3, c=6) # a = 3, c = 6, b nedefinováno

Traceback (poslední poslední hovor):

Soubor "", řádek 1, in

TypeError: func() vyžaduje alespoň 2 argumenty (2 dané)

Funkce může mít také proměnný počet pozičních argumentů, pak se před název umístí *:

>>> def func(*args):

>>> func(1, 2, 3, "abc")

(1, 2, 3, "abc")

>>> func(1)

Jak můžete vidět z příkladu, args je n-tice všech argumentů předávaných funkci a s proměnnou lze pracovat stejným způsobem jako s n-ticí.

Funkce může mít libovolný počet pojmenovaných argumentů, pak se před název umístí **:

>>> def func(**kwargs):

Vraťte kwargy

>>> func(a=1, b=2, c=3)

("a": 1, "c": 3, "b": 2)

>>> func(a="python")

V proměnné kwargs ukládáme slovník, se kterým si opět můžeme dělat, co chceme.

Anonymní funkce, instrukce lambda

Anonymní funkce mohou obsahovat pouze jeden výraz, ale také se provádějí rychleji. Anonymní funkce se vytvářejí pomocí instrukce lambda. Navíc nemusí být přiřazeny k proměnné, jak jsme to udělali s instrukcí def func():

>>> func = lambda x, y: x + y

>>> func(1, 2)

>>> func("a", "b")

>>> (lambda x, y: x + y) (1, 2)

>>> (lambda x, y: x + y)("a", "b")

Funkce lambda, na rozdíl od běžných, nevyžadují příkaz return, ale jinak se chovají úplně stejně:

>>> func = lambda *args: args

>>> func(1, 2, 3, 4)

19. Pojem rekurze, implementace v Pythonu

V programování je rekurze voláním funkce (procedury) ze sebe samé, přímo (jednoduchá rekurze) nebo prostřednictvím jiných funkcí (komplexní nebo nepřímá rekurze), například funkce volá funkci a funkce funkci. Počet vnořených volání funkce nebo procedury se nazývá hloubka rekurze.

Jednodušší to říct nemůže. Existuje známé rčení o rekurzi:

Chcete-li porozumět rekurzi, musíte nejprve porozumět rekurzi

Díky Pythonu je práce s rekurzí snadná a uvolněná. Úplně prvním příkladem rekurze, se kterým se většina programátorů setkává, je nalezení faktoriálu. Kód by mohl být takto:

def factorial(n):

pokud n<= 1: return 1

else: return n * faktoriál (n - 1)

Jak vidíte, příkaz if else jsme napsali pro Python trochu neobvyklým způsobem, ale to je v tomto případě povoleno, protože zde není narušena čitelnost, ale tento styl by neměl být zneužíván. A vůbec, PEP8 bude soudit každého. :)

Nyní si ujasněme pár důležitých funkcí, které byste měli mít při práci s rekurzemi vždy na paměti.

Hloubka rekurze je omezena. Ve výchozím nastavení je to 1000.

Chcete-li tento limit změnit, musíte zavolat funkci sys.setrecursionlimit() a zobrazit aktuální limit sys.getrecursionlimit().

Navzdory tomu existuje omezení velikosti zásobníku, který je instalován operačním systémem.

Rekurzi v Pythonu nelze použít ve funkcích generátoru a rutinách.

Toto chování však můžete napravit, ale je lepší ne.

Poslední věc – použití dekorátorů na rekurzivní funkce může vést k neočekávaným výsledkům, takže buďte velmi opatrní při zdobení rekurzivních funkcí.

Rekurze se dobře hodí tam, kde výkon není příliš důležitý, ale důležitější je čitelnost a udržovatelnost kódu. Například napište dvě funkce pro procházení stromem adresářů, jednu rekurzivní a jednu se smyčkami.

Rychlá navigace:
1.31 Seznamy - pole. První seznámení. 1.30 Funkce vracející výsledek - návrat 1.29 Podprogramy: funkce a procedury v Pythonu 1.28 Konverze datových typů - int() 1.27 Zadávání dat z klávesnice - input() 1.26 Datové typy a velikosti 1.25 Smyčka s podmínkou - while. Fibonacciho čísla 1.24 Měření délky řádku, seznamy 1.23 Řádkové řezy - výstup určitého počtu znaků z existujícího textu 1.22 Řetězce a řídicí znaky 1.21 Systémové chyby při ladění programu 1.20 Operátor větvení - if, komentáře 1.19 Tisk - print(), rychlé zadávání dat , zaokrouhlování, komentáře 1.18 Typy programování. Část 2. Objektově orientované programování 1.17 Typy programování. Část 1. Strukturované programování. Smyčky 1.16 Reprezentace symbolické informace - ASCII 1.15 Dělení binárních čísel 1.14 Matematické operace s binárními čísly 1.13 Jak jsou informace ukládány a zaznamenávány. Bity a bajty 1.12 Převod celých čísel z desítkové soustavy čísel do jiné soustavy 1.11 Převod celých čísel z šestnáctkové do desítkové 1.10 Převod celých binárních čísel na šestnáctkovou 1.9 Převod celých dvojkových čísel do jiné číselné soustavy 1.8 Číselné soustavy 1.7 Logické výrazy 1.6 Základní pojmy. Část 3 - Čísla, výrazy, operandy, operační znaky 1.5 Základní pojmy. Část 2 - Program, data 1.4 Základní pojmy. Část 1 - Problém a algoritmus 1.3 Vývojové prostředí SI 1.2 Historie programovacích jazyků 1.1 Úvod

Při psaní programů v jakémkoli programovacím jazyce se musíte snažit psát kompaktní kódy, abyste se mohli snadno orientovat v samotném kódu.
Stává se, že není možné implementovat váš kód tímto způsobem a programový kód často vypadá jako nekonečně dlouhý svitek prastarého dokumentu, který zabírá 10 - 15 obrazovek monitoru vertikálně...
Pochopení takového programu může být pro autora takového výtvoru samozřejmě nesmírně obtížné.

V tomto případě může programátor pomoci rozdělit programový kód na podprogramy.

Podprogram- toto je druh kompletního programu, ale ne nezávislý.
Je volán z nějakého vyššího programu pouze k provedení té či oné akce.

Jak to vypadá v praxi?
Například v nějakém velmi velkém programu, který potřebujete vyrobit (již jsme se podívali na algoritmus jeho fungování).
A místo toho, abychom pokaždé psali kód pro výpočet Fibonacciho čísel v tomto velkém programovém kódu, jednoduše jej vložíme do samostatného souboru. Toto bude podprogram.
Poté do místa, kde by se měl provést potřebný výpočet těchto čísel, vložíme pouze nějakou indikaci, že se má na tomto místě volat náš podprogram.

V tomto případě je objem programového kódu výrazně snížen a bude mnohem snazší pochopit fungování programu.

V různých programovacích jazycích se takové podprogramy nazývají:

Postupy popř
- funkce

V jazyce SI se takové podprogramy nazývají funkce.

Mimochodem, funkce jsme již použili v praxi!
V interpretu jsme například použili BUILT-IN funkce:

Print() - pro tisk dat určitých parametrů, které byly uzavřeny v závorkách
- str() - pro převod dat na typ řetězce. To je předběžně spuštěno funkce tisku()
- int() - pro převod dat na celé číslo
- float() - pro převod celých čísel na zlomkový typ
- round() - pro zaokrouhlení určité hodnoty
atd.

Tak.
Pro volání funkce stačí napsat její název a v závorce uvést požadované parametry (argumenty), které chceme této funkci předat.

Bylo by ale zcela nezajímavé, kdybychom neměli možnost vytvořit si vlastní funkce pro plnění určitých úkolů.
Pokud jde o Python, má speciální operátor definice funkce s následující syntaxí:

def FUNCTION_NAME (PARAMETER_LIST):
SEKVENCE VÝRAZŮ

Názvy funkcí by měly být vybírány stejným způsobem jako názvy proměnných – podle stejných pravidel: název musí začínat latinkou.
- Seznam parametrů obsahuje určité hodnoty, které jsou předány funkci. Tyto parametry jsou uvedeny oddělené čárkami.

V Pythonu je pro definování funkce prvním parametrem funkční slovo def(název funkce) (od definovat- definovat) - tím označíme, že funkci budeme volat.
Záhlaví funkce za uzavírací závorkou končí dvojtečkou (v Pythonu) a za ní následují potřebné výrazy začínající odsazením vzhledem k začátku řádku (obvykle se používá klávesa TAB).

Vrátíme-li se k výpočtu Fibonacciho čísel, podívejme se na jeho příkladu, jak funguje volání funkce.
Vezmeme další možnost pro výpočet Fibonacciho čísel, o které jsme dříve neuvažovali.
Je založen na paralelním přiřazování hodnot k proměnným.

Def fib(n): a, b = 0, 1, zatímco a< n: print(a, end = " ") a, b = b, a + b print()

Stručně řečeno, řádek:
a, b = 0, 1
znamená (ale není zcela ekvivalentní):
a = 0 b = 1

A linka
a, b = b, a + b
znamená záznam:
a = b b = a + b

Podívejme se na kód řádek po řádku:

1
def fib(n):
- definovat ( def) funkce podle jména fib s parametry (argumenty) uvedenými v závorkách, které chceme předat právě této funkci jménem fib.
Tito. jako parametr n předáme hodnotu, pro kterou bude výpočet proveden. Toto číslo bude předáno naší funkci jako argument.

Za dvojtečkou je vstup v interpretu Pythonu odsazen. To naznačuje, že tato data přímo souvisí s touto funkcí.

2
a, b = 0, 1
Inicializujeme proměnné s příslušnými hodnotami:
a = 0 b = 1

3
zatímco a< n:
Operátor smyčky zatímco- bude prováděno, dokud je splněna podmínka smyčky A
I zde se za dvojtečkou otevře nový blok, který přímo souvisí pouze s cyklem.
Tento blok bude vytištěn po posunu řádku s dalším odsazením.

4
print(a, end = "")
Po každé iteraci cyklu tiskneme data proměnné a a mezeru

5
a, b = b, a + b
Proměnným přiřadíme příslušné hodnoty:
a = b b = a + b
Chcete-li změnit počáteční data a pokračovat v práci na výpočtu Fibonacciho čísel

6
vytisknout()

Vezměte prosím na vědomí, že toto vytisknout() potřeba vytisknout pod zatímco... tj. již nepatří do těla smyčky zatímco a do těla funkce fib
Proč však potřebujeme to druhé? vytisknout() a dokonce i s prázdnými závorkami?

V tomto případě se jedná o výstup prázdného řádku – udělejte „break“ – zalomení řádku. Nebo spíše tato funkce vytiskne znak odřádkování.
V našem případě ji používat nemusíme.

Takže jsme definovali funkci fib pro výpočet Fibonacciho čísel a jak jste si všimli, nefunguje to.

Aby fungoval, je potřeba jej ZAVOLAT a předat mu určitý parametr pro výpočty.
Zavoláme naši funkci a předáme hodnotu jako argument 40 .
Ve výsledku bychom měli dostat výpočet Fibonacciho čísel pro všechna čísla až do 40 :

Tiskneme v interpretu Pythonu:
fib (40)
Dostáváme:

0 1 1 2 3 5 8 13 21 34

Funkci můžete volat znovu fib() s jiným parametrem a získat stejný výstup potřebných dat.
Například pojďme vstoupit
fib(400)
A dostáváme:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Naše funkce tak může být spuštěna požadovaný počet opakování.

V mnoha programovacích jazycích nejsou procedura a funkce synonyma a navzájem se liší.
Jak se od sebe v takových programovacích jazycích liší?

Funkce - vrací hodnotu
- Procedura - nevrací hodnotu

Vysvětlíme na příkladu:

Pokud bychom mohli použít takovýto zápis (jen jako příklad):
x = fib(n)- pak je to funkce, ta přiřadí výslednou hodnotu proměnné x(v tomto případě se do proměnné x nic nezapíše)

Pokud je možný pouze záznam fib(n)- pak je to postup.

Můžeme tedy říci, že náš příklad je POSTUP.

Na to, jak použít náš kód v Pythonu k výpočtu Fibonacciho čísel jako funkce, se podíváme o něco později...

Funkce jsou skvělým pomocníkem ve všech programovacích jazycích. Pomáhají zlepšovat kód prováděním opakovaných úkolů bez nutnosti duplikovat kód, abyste získali výsledek bez použití funkce. Kód funkce by měl být co nejkompaktnější. Funkce by měla fungovat pouze jedna operace. Musí to dělat dobře a nesmí dělat nic jiného. Chcete-li vytvořit čitelný kód pro vás a ostatní programátory, musíte jej sledovat. Pracujete s čistým kódem, pokud každá funkce v podstatě dělá to, co od ní očekáváte. Polovina úsilí při implementaci tohoto principu spočívá ve výběru dobrých názvů pro kompaktní funkce, které provádějí jedinou operaci.

Čím menší a specializovanější je funkční kód, tím Je snazší vybrat pro to jasný název. Nebojte se používat dlouhá jména. Dlouhé, smysluplné jméno je lepší než krátké, nesrozumitelné. Při výběru jména buďte důslední. V názvu funkce použijte stejné fráze, slovesa a podstatná jména, které se používají ve vašich modulech. Funkce se vytvoří pomocí příkazu def, jak ukazuje následující příklad. Už jsme se poučili, využijme znalosti zde.

# -*- coding: utf-8 -*- Phones = ["Nokia", "Samsung", "LG", "Sony"] def show_as_text(user_list): words = "" pro hodnotu v user_list: words += str (hodnota) + " " návratová slova tisk "Telefony: ", show_as_text(Telefony) # Návrat: Telefony: Nokia Samsung LG Sony

Poměrně jednoduchá struktura funkcí. Název funkce show_as_text, je důležité, aby se neshodoval s názvem samotné funkce Pythonu. Název funkce musí být jedinečný ve srovnání s proměnnými. Pokud se funkce nazývá get_values ​​a za ní je ve skriptu vytvořena proměnná se stejným názvem, pak volání get_values(args) vyvolá chybu.

# -*- kódování: utf-8 -*- def get_value(): return True a = 1 b = 3 get_value = "nějaký text..." is_true = get_value() !}

Dostaneme chybu:

TypeError: objekt "str" ​​není volatelný Pokud potřebujete z funkce vrátit více hodnot, můžete použít n-tici. Pojďme vytvořit malou analogii hry Bingo! získat různá čísla.

# -*- kódování: utf-8 -*- import random def bingo(): return (random.randint(0, 30), random.randint(0, 30), random.randint(0, 30)) Numbers = bingo() tisk "První: ", tisk čísel "Druhý: ", tisk čísel "Třetí: ", Čísla

Pomocí operátoru přiřazení můžete argumentu funkce přiřadit výchozí hodnotu.

Def connect(ip, port=8080): return str(ip) + " " + str(port) print connect("127.0.0.1") # Dostaneme: 127.0.0.1 8080

Pokud definice funkce určuje výchozí hodnoty pro jakékoli parametry, následná volání funkce mohou tyto parametry vynechat. Pokud některý z nich není při volání specifikován, obdrží výchozí hodnotu. Například:

Connect("site", 80)

Je také možné předávat funkcím pojmenované argumenty, které mohou být uvedeny v libovolném pořadí. V tomto případě však musíte vědět, jaké názvy argumentů jsou uvedeny v definici funkce.

Connect(port=80, host="site")

Když jsou v rámci funkce vytvořeny nové proměnné, mají místní rozsah. To znamená, že takové proměnné jsou definovány pouze v těle funkce a jsou zničeny, když funkce vrátí řízení programu. Aby bylo možné měnit globální proměnné v rámci funkce, musí být tyto proměnné definovány v těle funkce pomocí globálního příkazu.

Num = 1 # Globální proměnná def next_number(): globální num personal_num = 999 num += 1 return num print next_number() # result 2 # Zkusme získat hodnotu lokální proměnné personal_num print personal_num # Chyba NameError: name "personal_num “ není definováno

Když jsem začal psát kapitolu o OOP, uvědomil jsem si, že jsem úplně zapomněl pokrýt tak velkou a potřebnou část Pythonu, jako jsou funkce. Toto téma je rozsáhlé a obsáhlé, takže abych příliš nenatahoval pauzy mezi lekcemi, rozhodl jsem se jej rozdělit na 2 části. Nejprve vám řeknu základy a poté podrobné funkce inženýrství funkcí Pythonu.

Funkce v Pythonu nejsou deklarovány jednoduše, ale velmi jednoduše. Zde je příklad toho nejjednoduššího:
Deklarace začíná klíčovým slovem def, což, jak asi tušíte, je zkratka pro definovat. Za ním následuje název funkce. Za jménem je v závorce uveden seznam parametrů, které v tomto případě chybí.
Tělo funkce je odsazeno od dalšího řádku. Vezměte prosím na vědomí, že funkce s prázdným tělem jsou v Pythonu zakázány, takže jako tělo výše uvedené funkce se používá průchod „prázdný operátor“.
Nyní se podívejme na vážnější příklad.

Def safe_div(x, y): """Udělejte bezpečné rozdělení:-) pro zábavu a zisk""" pokud y != 0: z = x / y tisk z return z else: tisk "Yippie-kay-yay, matkaf___er!"
V tomto příkladu je několik inovací. První věc, která vás upoutá, je dokumentační řádek (docstring), který následuje bezprostředně za tělem funkce.
Obvykle tento řádek zabírá více než jeden řádek zdrojového textu (promiňte, slovní hříčka), a proto je uveden v trojitých uvozovkách. Je určen k popisu funkce, jejího účelu, parametrů atd. S touto linkou mohou pracovat všechna dobrá IDE. Můžete k němu také přistupovat ze samotného programu pomocí vlastnosti __doc__:

Vytisknout safe_div.__doc__
Tuto vlastnost (ano, ano, přesně vlastnost, v Pythonu jsou dokonce funkce vlastně třídy) je vhodné používat během relací interaktivní konzole.
>>> z ftplib import FTP >>> tisk FTP.__doc__ An FTP klient třída. Chcete-li vytvořit připojení, zavolejte třídu pomocí těchto argumentů: host, user, passwd, acct Toto jsou všechny řetězce a mají výchozí hodnotu "".
Poté použijte self.connect() s volitelným argumentem hostitele a portu. # zbytek udělám já :-) Vraťme se k naší původní funkci. Jeho podstata je velmi jednoduchá, vyžaduje 2 parametry: x a y. Pokud y není 0, vydělí x y, vytiskne výsledek na obrazovku a jako výsledek vrátí svůj podíl. Výsledek funkce je vrácen pomocí návratové příkazy
. Díky mechanismu n-tice popsanému v minulé lekci mohou funkce v Pythonu vracet mnoho objektů současně. Pokud je dělitel stále nula, funkce zobrazí chybové hlášení. Bylo by chybou předpokládat, že v tomto případě funkce nic nevrátí. Správnější by bylo říci, že funkce vrátí „nic“ :) Jinými slovy, pokud funkce neobsahuje návratový výpis

, nebo je volána bez parametrů, pak funkce vrátí speciální hodnotu None. Můžete to snadno ověřit voláním něčeho jako print safe_div(10, 0).

Def gcd(a, b): "Hledání GCD" zatímco a != 0: a,b = b%a,a # paralelní definice return b
Tato funkce najde největšího společného dělitele dvou čísel.

Obecně mějte na paměti, že parametry ve funkcích Pythonu jsou předávány odkazem. Dalším, možná netriviálním faktem, na který si budete muset zvyknout, je fakt, že samotné funkce jsou hodnotou, kterou lze přiřadit. Pokud použijeme naši funkci safe_div pro další experimenty, můžeme napsat následující kód.

Mystic_function = safe_div print mystic_function(10, 4)
To je prozatím vše, stále zbývá mnoho aspektů definování funkcí v Pythonu „přes palubu“, kterým se budeme věnovat příště.

Cvičení pro testování.
1. Na základě stávající funkce Chcete-li najít GCD, napište funkci pro nalezení LCM dvou čísel.
2. Napište tabelační rutinu pro funkci předávanou jako argument. Argumenty také určují počáteční, konečnou hodnotu a tabulkový krok.

PS mimochodem, jaká je optimální délka „lekce“? Co je lepší – velké kapitoly vydávané méně často nebo „méně je lépe, častěji?

V programovacích jazycích jsou funkce pojmenovanou částí kódu. Jedná se o samostatné bloky v textu programu. Definováno pomocí vyhrazeného slova def. V Pythonu lze přistupovat k funkcím neomezené množstvíčasy z jakékoli části scénáře.

Proč potřebujeme funkce?

Funkce jsou nepostradatelný nástroj programátor S jejich pomocí vývojář strukturuje program, takže je přehlednější a kompaktnější. Pomocí funkcí můžete dosáhnout opětovného použití samostatné části kódu, aniž byste jej museli přepisovat.

Tento nejjednodušší způsob logika provádění balíčku jednotlivé díly programy. Zároveň se snižuje objem a čas, který specialista stráví tvorbou skriptu.

Jak napsat svou první funkci

Python 3 nabízí nejzákladnější úvod do programování pro začátečníky. jednoduchá funkce vytisknout(). Abyste to viděli v akci, budete potřebovat vývojové prostředí. Chcete-li to provést, stáhněte si sadu pro distribuci jazyků z oficiálních webových stránek a nainstalujte si do počítače Python.

Otevřete nabídku Start a v seznamu programů najděte Python 3. Rozbalte jej kliknutím levým tlačítkem myši. V seznamu, který se otevře, najděte prostředí IDLE a spusťte jej. Napište print("Hello, World!") a stiskněte Enter. Interpret vrátí výsledek vaší první funkce.

Někteří programátoři dávají přednost práci v konzoli. Pokud jste jedním z nich, stiskněte win+R a zadejte příkaz python.exe. Otevře se běžný interpret, pouze s rozhraním cmd. Napište program, jak je popsáno výše, a na konci stiskněte Enter, abyste viděli výsledek.

Jak používat def

Nové funkce se vytvářejí pomocí příkazu def. Jsou stejně účinné jako vestavěné print() nebo open(), ale liší se od funkcí v kompilačních jazycích. Python def odkazuje na spustitelné instrukce. To znamená, že funkce neexistuje, dokud ji interpret neuvidí a nezačne ji provádět.

Příkaz def vytvoří nový objekt a dá mu jméno. To znamená, že když interpret začne implementovat, vytvoří nový objekt a přiřadí jej ke jménu zadanému po def. Chcete-li ukládat data, můžete k funkcím připojit různé atributy.

Nyní napíšeme funkci, která vrátí frázi "Ahoj, světe!", pouze pomocí def:

• >>> def hello_world():
• tisk ("Ahoj, světe!")
• >>> hello_world() volání #funkce
• Ahoj světe!

Syntaxe a návrat funkce

Příkaz def v Pythonu se skládá z hlavičky a je zapsán podle následujících pravidel:

• >>>def<имя>

Za hlavičkou následuje blok instrukcí, který začíná povinným odsazením. V IDLE to tlumočník udělá automaticky. Ale v poznámkovém bloku nebo jinde textový editor můžete zapomenout stisknout Tab. Potom se funkce nespustí. Programový kód v instrukčním bloku se nazývá tělo funkce a je vykonáno pokaždé, když je voláno.

Také v těle někdy dochází k návratu:

• def<имя>(argument 1, argument 2, argument N):
• návrat<значение>

Return ukončí funkci a projde volací program výsledný objekt. Pokyny jsou volitelné. Funkce poběží bez návratu a ukončí se, když řídicí tok dosáhne konce svého těla.

Parametry a argumenty

Každé funkci lze předat parametry, které jsou uvedeny v závorkách za def. V Pythonu se zapisují jako proměnné oddělené čárkami. Hodnoty nebo odkazy na objekty jsou těmto názvům přiřazeny v bloku za dvojtečkou. Po operaci přiřazení se obvykle nazývají argumenty spíše než parametry.

Argumenty uvnitř funkce nemají žádnou souvislost s objekty mimo ni, takže v programování jsou klasifikovány jako lokální proměnné. Rozsah je omezen na funkční blok, který začíná def a končí return. Aby to bylo jasnější, uveďme příklad:

• x = 12 #přiřadit proměnné k odkazům na celočíselné objekty
• y=34
• >>>def example(x,y): #vytvoření funkce s názvem example
• x = "Ahoj" #přiřadit hodnoty argumentům x, y
• y = "Python"
• print(x, y, sep= ", ")
• návrat Žádné
• >>>example(x, y) #zavolejte funkci, nezapomeňte zadat parametry
• Ahoj Pythone
• >>>tisk (x, y)
• 12 34

Věnujte pozornost předposlednímu řádku kódu. V tlumočníku Příkaz Pythonu print() vrátila proměnné x a y z globální oblast viditelnost.

Hodnoty argumentů nemusí být zadány uvnitř funkce, můžete je zadat ručně při jejím volání:

• >>>def E_2(x, y):
• vrátit x + y
• >>>E_2("Dobrý den, " "Python!") #pro oddělení slov vložte mezeru před závěrečnou uvozovku
• Ahoj Pythone!
• E_2(5; 4)

Jak je vidět z příkladu s jednoduchou funkcí E_2, výsledek zcela závisí na typu objektů x a y. V prvním případě provedl E_2 zřetězení a ve druhém - aritmetická operace přidání. To je princip polymorfismu a skutečnost, že objekty určují syntaktický význam, určuje flexibilitu a jednoduchost jazyka. Není třeba ztrácet čas samostatným specifikováním datového typu, se kterým funkce pracuje.

Pravidlo LEGB

Toto pravidlo platí pro práci s proměnnými v různém rozsahu. Ve výchozím nastavení jsou všechny názvy, které vytvoříte v těle funkce, považovány za místní. A názvy v modulu jsou globální. V případě potřeby lze názvům přiřadit hodnotu proměnných nejvyšší úrovně pomocí příkazů notlocal a global.

Pravidlo LEGB vysvětluje schéma rozlišení názvů:

1. Jakmile interpret najde proměnnou uvnitř příkazu def, nejprve vyhledá hodnoty v místním rozsahu.
2. Pokud se vyhledávání nezdaří, přeskočí se na rozsah libovolného zastřešujícího příkazu def.
3. Dále se překladač přesune na globální názvy horní úroveň modul a ty označené jako globální.
4. Pokud se vyhledávání nezdaří, interpret hledá jména ve vestavěném rozsahu Pythonu.

Podívejme se na názorný příklad:

• >>>L = 85
• >>>R = 23
• >>>def example_2(K):
• R=10
• C = L + K+R
• vrátit C
• >>>example_2(5)

Proměnné L a R jsou na nejvyšší úrovni a jsou globálními názvy. R, C a K jsou lokální proměnné, protože k přiřazení dochází uvnitř příkazu def.

Interpret nejprve provede operaci sčítání na lokálních R, C a K, přičemž ignoruje proměnnou R mimo příkaz def. Pak hledá L, a nenajde-li ho mezi místními názvy, přejde na nejvyšší úroveň.

Co je lambda

Kromě def, in Funkce Pythonu lze vytvořit pomocí speciálních výrazů, z nichž jeden je lambda. Váš původní název obdržel na počest lambda kalkulu jazyka LISP.

Stejně jako def vytváří lambda funkci, kterou lze volat později, ale nepřidružuje ji k názvu. V praxi se lambda používá, když potřebujete odložit provedení části kódu.

Základy lambda výrazu

Podle vzhled Výrazy lambda se podobají příkazům def. Nejprve je napsáno klíčové slovo lambda, pak argumenty, dvojtečka a samotný výraz:

• >>>f = lambda x, y, z: x + y + z
• >>>f(2; 3; 4)

Tělo lambdy je jediný výraz, nikoli blok instrukcí. Díky tomu má lambda omezené možnosti a není tak univerzální jako def. Lze v něm implementovat pouze logiku, bez zatímco smyčky nebo pro.

Pro lambda jsou pravidla pro vyhledávání proměnných podobná jako u def. Jména uvedená vně výrazu jsou globální, jména uvnitř jsou lokální a vzájemně se nijak neovlivňují.

Lambda výrazy je velmi vhodné vložit do programu. Kvůli malá velikost minimalizují a zjednodušují kód. Ale použití lambdy není zásadní. V Pythonu 3 budou začátečníci potřebovat pouze příkaz def, aby mohli začít.