Počet argumentů funkce v Pythonu. Interaktivní výuka Pythonu

Připomenutí používání parametrů funkcí (argumentů) v Pythonu.

Polohové parametry

Poznámky:

• Všechno je jako obvykle.
• Při volání nezapomeňte zadat všechny poziční argumenty.

Libovolný počet argumentů

Poznámky:

• Označeno hvězdičkou před argumentem - *args
• Uvnitř funkce vypadá jako n-tice, prvky n-tice jsou uspořádány ve stejném pořadí jako argumenty funkce zadané při volání.
• Seznam můžete předat jako sadu argumentů při volání funkce přidáním hvězdičky k označení seznamu před

Příklad 1. Definování funkce s proměnným počtem argumentů:

Příklad 2. Předání seznamu funkci jako sady argumentů:

Komentáře například 2:

• Řádek 8: Proměnný počet argumentů
• Řádek 9: Seznam (předán jako jeden argument)
• Řádek 10: Seznam s hvězdičkou (předán jako proměnný počet argumentů)

Pojmenované argumenty

Poznámky:

• Při volání není nutné specifikovat. Pokud není zadáno, jsou jim přiřazeny výchozí hodnoty.

Poznámky:

• Při spuštění programu jsou hodnoty přiřazeny k pojmenovaným parametrům jednou, v místě, kde je funkce definována. Pokud je přiřazený objekt proměnlivý, pak se změnil během operace funkce, v následujících voláních nebude mít hodnotu, která je uvedena jako hodnota v definici funkce, ale tu, která byla přiřazena během předchozího volání.

Příklad k poznámce:

Libovolný počet pojmenovaných argumentů

Poznámky:

• Označeno dvěma hvězdičkami před argumentem - **kwargs
• Uvnitř funkce vypadá jako slovník s klávesami odpovídajícími názvům argumentů zadaných při volání funkce.
• Při volání funkce můžete předat slovník jako sadu pojmenovaných argumentů přidáním dvou hvězdiček před označení slovníku. Například takto: **kwargs

Příklad 1. Definování funkce s libovolným počtem pojmenovaných argumentů:

Příklad 2. Předání slovníku funkci jako libovolný počet pojmenovaných argumentů:

Komentáře například 2:

• Řádek 9: Slovník je předán jako jeden pojmenovaný argument.
• Řádek 10: Slovník je předán jako libovolný počet pojmenovaných argumentů.

Všechny druhy parametrů dohromady

Předání parametru odkazem (změna parametru uvnitř funkce)

Pokud při volání funkce dosadíme za hodnotu argumentu proměnnou a v těle funkce změníme hodnotu argumentu, pak to, co se stane, závisí na tom, s jakou hodnotou je naše proměnná spojena. Pokud je proměnná spojena s neměnnou hodnotou, například int, str, tulpe, pak se tato hodnota přirozeně nezmění. Pokud je však proměnná spojena se seznamem, slovníkem nebo třídou, změní se hodnota objektu spojeného s proměnnou.

Nemění se:

změny:

Důsledek 1: pokud potřebujeme „předat parametr odkazem“, jako v C, neměli bychom to dělat, výsledek nemusí být takový, jaký chceme. Účelem předávání parametru odkazem v C je vrátit více hodnot z funkce změnou hodnot odkazem ve funkci. Python umožňuje vrátit n-tici, takže pokud potřebujete vrátit více hodnot, musíte vrátit n-tici a přiřadit její hodnoty proměnným.

Důsledek 2: abyste se vyhnuli „vedlejším účinkům“, je lepší použít neměnné typy jako výchozí hodnoty (None, int, str, tulpe)

komentáře:

Jméno: Igore

Děkuji, bylo to užitečné

Jméno: Doupě

Zvláštní poděkování za (**d).

Jméno: test

Jméno: alex

Jméno: Serg

Díky za jasná vysvětlení!

Jméno: Vlad2030

def fprintf(*args,**kwargs):
tisknout kwargy...
tisknout argumenty...

KP=2
N_elem =
c="privet"

KP = 2
N_elem =
c = "ahoj"

fprintf(KP, N_elem, c)

výsledek:
KP = 2
N_elem =
c = ptačí zob

Jméno: seyalek

>>Jak napsat funkci tak, aby tiskla jména a hodnoty svých proměnných??

def fprintf(**kwargs):
pro k, v v kwargs.items():
tisknout "%s = %s" % (k, v)

a zvráceně volat:
fprintf(KP=KP, N_elem=N_elem, c=c)

Jméno: Alexandr

Je škoda, že takové množství příkladů nelze použít v CPP, protože fytonky neznám. Ale téma je to zajímavé a fakt by mě zajímalo, jak ho aplikovat v praxi a ne jen 1,2,3. Například, pokud existuje úkol převést nápad do atmega8 On srr [toto je index pole] = (Ahoj světe) =)
index++ a výstup každého cyklu písmenem.

Jméno: Denis

Při spuštění programu jsou hodnoty přiřazeny k pojmenovaným parametrům jednou, v místě, kde je funkce definována. Pokud je přiřazený objekt proměnlivý, pak se změnil během operace funkce, v následujících voláních nebude mít hodnotu, která je uvedena jako hodnota v definici funkce, ale tu, která byla přiřazena během předchozího volání.

To, co jste zmínil, platí pouze pro seznamy.
Protože přiřazením seznamu k parametru se parametr i seznam vytvoří ve stejné buňce a mají stejné id. Když změníte parametr, seznam se změní a vše se uloží do stejné buňky.

Obecně něco takového!

Jméno: Asya

def sudé(x):
if x%2==0:
tisknout ("Ano")
____?
tisknout ("Ne")

Co dát do předposledního

Jméno: Asya

def sudé(x):
if x%2==0:
tisknout ("Ano")
____?
tisknout ("Ne")

Co dát do předposledního řádku???

Jméno: kurva

Jméno: aaa

Jméno: Aljoša

Asyo, hlupáku!

Jméno: Pavlo

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 k funkcím přistupovat neomezeně mnohokrát odkudkoli ve skriptu.

Proč potřebujeme funkce?

Funkce jsou pro programátora nepostradatelným nástrojem. 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.

Toto je nejjednodušší způsob, jak zabalit logiku provádění jednotlivých částí programu. Zároveň se snižuje objem a čas, který specialista stráví tvorbou skriptu.

Jak napsat svou první funkci

V Pythonu 3 je pro ty, kteří začínají s programováním, nejjednodušší funkce print(). 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 stránek a nainstalujte Python do počítače.

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 raději pracují 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 zahájí implementaci, 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 jiném textovém editoru 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 spouštěn pokaždé, když je volán.

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

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

Return ukončí funkci a předá výsledný objekt volajícímu. 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 interpretu Pythonu vrátil příkaz print() proměnné x a y z globálního rozsahu.

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 před závěrečnou uvozovku mezeru
• 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ě E_2 provedl zřetězení a ve druhém aritmetickou operaci sčítá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 ke globálním názvům na nejvyšší úrovni modulu ak těm, která jsou označena 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 lze funkce vytvářet v Pythonu pomocí speciálních výrazů, z nichž jeden je lambda. Svůj původní název získal 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

Vzhledově připomínají výrazy lambda def instrukce. Nejprve napište klíčové slovo lambda, poté argumenty, dvojtečku 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. Může implementovat pouze logiku bez smyček while nebo for.

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. Díky své malé velikosti 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.

V tomto článku plánuji mluvit o funkcích, pojmenovaných a anonymních, instrukcích def, return a lambda, povinných a volitelných argumentech funkcí, funkcích s libovolným počtem argumentů.

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:

def add (x, y): návrat x + y

Instrukce návratříká, že potřebuje vrátit hodnotu. V našem případě funkce vrací součet x a y.

Nyní to můžeme nazvat:

>>> přidat (1, 10) 11 >>> přidat ("abc" , "def" ) "abcdef"

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): ... return x + n ... return myfunc ... >>> new = newfunc (100) # new je funkce >>> nové (200) 300

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

>>> def func (): ... pass ... >>> print (func ()) Žádné

Funkční argumenty

Funkce může mít libovolný počet argumentů nebo vůbec žá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... return a + b + c ... >>> func (1 , 2 ) # a = 1, b = 2, c = 2 (výchozí) 5 >>> func (1 , 2 , 3 ) # a = 1, b = 2, c = 3 6 >>> func (a = 1 , b = 3 ) # a = 1, b = 3, c = 2 6 >>> func (a = 3 , c = 6 ) # a = 3, c = 6, b nedefinováno Zpětné sledování (poslední poslední hovor):Soubor "", řádek 1, ve funkci func(a=3, c=6) TypeError: func() bere alespoň 2 argumenty (2 dané)

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

>>> def func (* args): ... return args ... >>> func (1, 2, 3, "abc") (1, 2, 3, "abc") >>> func () () >>> func (1 ) (1,)

Jak můžete vidět z příkladu, args jsou všechny argumenty předané funkci a s proměnnou můžete 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): ... return kwargs ... >>> func (a = 1, b = 2, c = 3) ("a": 1, "c": 3, " b": 2) >>> func () () >>> func (a = "python" ) ("a": "python")

Ukládáme do proměnné kwargs, se kterou 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í příkazu 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 ) 3 >>> func ("a" , "b" ) "ab" >>> (lambda x , y : x + y )(1 , 2 ) 3 >>> (lambda x , y : x + y )("a" , "b" ) "ab"

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

>>> func = lambda * args : args >>> func (1, 2, 3, 4) (1, 2, 3, 4) 27. ledna 2009 v 14:49

Základy Pythonu – stručně. Část 6. Rozšířená definice funkcí.

• Krajta

V této části budeme hovořit podrobněji o definování funkcí a odhalíme některé rysy tohoto procesu specifické pro Python. Vzhledem k tomu, že informací je hodně, pokusím se vše představit poměrně stručně.

Výchozí nastavení

Pro všechny parametry funkce můžete zadat výchozí hodnoty, což umožňuje volat funkci s menším počtem parametrů. Máme například funkci pro autorizaci uživatele na webu:
def login(username="anonymous", password=None): """Tady jsou nějaké akce""" pass # tuto funkci můžeme zavolat pomocí # jedné z následujících metod login("root", "ujdyzysqgfhjkm") přihlášení (" guest") login() # můžeme specifikovat, který parametr předáváme # explicitně specifikovat jeho jméno login(password=" [e-mail chráněný]")

Obecně platí, že ty parametry, které existují, jsou porovnávány zleva doprava (pokud není konkrétně specifikován název), ostatní jsou nahrazeny výchozími hodnotami (pokud jsou samozřejmě zadány).
Důležitou vlastností v tomto případě je, že výchozí hodnoty se počítají a přiřazují pouze jednou - v okamžiku deklarace funkce. Všechny výsledné nedostatky budou názorně demonstrovány na příkladu:
def_val = 2 def our_func(val = def_val): print val our_func(4) # vytiskne 4 our_func() # vytiskne 2 - výchozí hodnota def_val = 12 our_func() # stále 2, protože def_val byl v době reklamy 2
Nepříjemnější důsledek toho. Řekněme, že chceme deklarovat funkci, která vezme seznam jako vstup, něco s ním udělá a vytiskne ho. Navíc, pokud není seznam zadán, je ve výchozím nastavení prázdný.
Pokus o to „čelem“ nebude fungovat tak, jak bychom chtěli:
In : def lister(lst = ): ...: lst.append() ...: print lst ...: In : lister() [] In : lister() [, ] In : lister() [, , ]
Ve skutečnosti je zde problém v tom, že proměnná lst bude jednou spojena s prázdným seznamem a mezi voláními si zachová svou hodnotu.
V tomto případě by bylo správné popsat naši funkci následovně (jak doporučují všechny učebnice):
In : def lister2(lst=None): ...: if lst je None: ...: lst= ...: lst.append() ...: print lst ...: In : lister2() [ ] In : lister2() [] In : lister2() ]
Tato funkce bude fungovat přesně tak, jak bychom původně chtěli.

Argumenty pozice a klíčových slov.

Často je potřeba vytvořit funkci, která zpracovává neurčité množství parametrů. Například funkce pro výpočet součtu prvků seznamu.
Všechny argumenty samozřejmě můžeme předat jako jeden parametr typu seznam, ale vypadá to ošklivě. Proto Python vytvořil speciální mechanismus zvaný position-arguments. Zde je příklad demonstrující použití.
In : def list_sum(*args): ...: smm = 0 ...: for arg in args: ...: smm += arg ...: return smm ...: In : list_sum(1, 2 , 3) Out: 6 In : list_sum(1) Out: 1 In : list_sum() Out: 0
V tomto případě jsou všechny naše parametry „zabaleny“ do seznamu argumentů v souladu s jejich „sekvenčním číslem“ při přenosu.
Opačná operace je také možná, řekněme, že máme seznam hodnot a chceme je předat jako seznam parametrů funkce:
In : lst = In : list(range(*lst)) Out:
V tomto příkladu byl seznam lst „rozbalen“ a nahrazen místo parametrů funkce range, to znamená, že volání bylo podobné:
In : list(range(1, 10, 2)) Out:
Kromě polohy můžete využít i tzv. argumenty klíčových slov. Liší se tím, že musí být výslovně pojmenovány. Zde je příklad - funkce, která generuje vkládací výraz pro databázi (pozn.: maximální optimalizace nebyla v tomto případě nastavena jako samoúčelná).
def enquote1(in_str): """Uvozuje vstupní řetězec jednou uvozovkou""" in_str = in_str.replace(""", r"\"") return ""%s"" % in_str def enquote2(in_str): """Uvozuje vstupní řetězec dvojitými uvozovkami""" in_str = in_str.replace(""", r"\"") return ""%s"" % in_str def gen_insert(table, **kwargs): "" "Generuje příkaz DB insert""" cols = vals = for col, hodnota v kwargs.items(): cols.append(enquote2(col)) vals.append(enquote1(str(val))) cols = ", ". join(cols) vals = ", ".join(vals) return "INSERT INTO "%s"(%s) VALUES(%s);" % (table, cols, vals) print gen_insert("workers", name="John", age=21, plat=1500.0) params = ("name": "Mary", "age": 19, "plat": 1200.0) print gen_insert("pracovníci", **params)
Na výstupu dostaneme to, co jsme očekávali:
INSERT INTO "pracovníci"("plat", "věk", "jméno") VALUES("1500.0", "21", "Jan"); INSERT INTO "pracovníci"("plat", "věk", "jméno") VALUES("1200.0", "19", "Mary");
Pozor na druhé volání funkce gen_insert - takto můžeme funkci volat pouze se slovníkem parametrů. To platí pro jakoukoli funkci. Možné jsou také různé kombinace pozičních argumentů a argumentů klíčových slov.

Jako poslední příklad zvažte tuto funkci:
def logging(func, *args, **kwargs): res = func(*args, **kwargs) print "volání %s, vráceno %r" % (func.__name__, res) return res def double(x): "Zdvojnásobení čísla" vrátí 2*x protokolování tisku (dvojité, 155)
Toto je nejjednodušší způsob, jak ladit funkci, jakoby „zabalíme“ volání jedné funkce do druhé, abychom zobrazili mezilehlé informace.
Když se podívám do budoucna, řeknu, že Python má velmi výkonný nástroj pro pohodlnější použití tohoto druhu „zabalovacích“ funkcí, nazývaných dekorátory, ale o tom později.

To je pro dnešek vše. Pokračování (buď moje nebo respektované

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, mohou být tyto parametry v následujících voláních funkce vynechány. 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.

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