Függvények meghívása Pythonban: Az Ultimate Guide

A függvények a programozás alapvető fogalmai, amelyek lehetővé teszik a kódblokkok kezelését és újrafelhasználását. A függvények Pythonban való meghívásának ismerete kulcsfontosságú megtanulandó készség.

Ebben az oktatóanyagban megismerheti a függvények hívásának alapjait, valamint néhány tippet a hatékony, könnyebben érthető kód írásához.

A funkciók elsajátítása nemcsak sokoldalúbb kód létrehozásában segít, hanem leegyszerűsíti a programozási folyamatot, és javítja általános hatékonyságát fejlesztőként.

A függvényeknek ugyanazok az alapelvei, és miután elsajátította a függvényeket a Pythonban, kibővítheti a funkciók megértését más programozási nyelvekhez képest, mint például a Java, R, JavaScript, PHP stb.

Tartalomjegyzék

• Mi az a függvény?
• Függvény meghatározása Pythonban
  • Függvény szintaxis
  • Paraméterek és érvek
    • A kwargs érv
• Funkció hívása
  • Alapfunkciók hívása
  • Pozíciós érvek
  • Kulcsszóérvek
• Visszatérési értékek
  • Egyetlen hozamérték
  • Több visszatérési érték
• Python-függvények átadása argumentumként
• Beágyazott függvények
• Lambda funkciók
• Rekurzió
• Gyakori hibák és hibaelhárítás
• Következtetés

Mi az a függvény?

A Python egyik funkciója lehetővé teszi, hogy újrafelhasználható kódrészleteket hozzon létre, amelyek az egész programban meghívhatók, leegyszerűsítve a kódot és javítva az olvashatóságot. Egy adott feladatot vagy feladatsort hajt végre, és egy programon belül többször is meghívható. 

Függvény meghatározása Pythonban

A Pythonban két fő függvénykategória létezik:

• Felhasználó által definiált funkciók: A programozó által meghatározott funkciók a kód ismétlődésének elkerülése érdekében
• Beépített függvények : olyan funkciók, amelyeket valaki más definiál, és a szükséges csomagok telepítése után a kódodban használható

Ez a rész a felhasználó által definiált funkciókra összpontosít. Megtanulod:

• Hogyan definiáljunk függvényt Pythonban
• A függvény szintaxisa
• A paraméterek és argumentumok használata

Függvény szintaxis

A def kulcsszó, majd a függvény neve és a zárójelek lehetővé teszik függvény definiálását Pythonban. A függvény törzse behúzott, és tartalmazza a függvény meghívásakor végrehajtandó kódot. Az alábbiakban látható egy példa a Python egyik alapfunkciójára:

def greet(): print("Hello, World!") greet()

A def kulcsszó egy új függvényt határoz meg a greet névvel. A harmadik kódsor meghívja a függvényt, amely végrehajtja a kódot a függvényen belül.

A printfenti kód sora is egy függvény. Ha azonban Python 2 környezetben dolgozik, akkor az utasításként van meghatározva. Később a Python 3-ban utasításról függvényre változott.

Paraméterek és érvek

A paraméterek a függvénydefiníció helyőrzői, míg az argumentumok a függvény meghívásakor átadott értékek.

A paraméterek megadásához adja meg azokat a függvénydefiníció zárójelében, vesszővel elválasztva, ha több paraméter van. Amikor meghív egy függvényt, megadja az argumentumoknak nevezett bemeneti értékeket. A következő példa egy olyan függvény meghatározását mutatja be, amely két paramétert vesz fel:

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

A return függvény törzsében lévő utasítás a benne átadott két argumentum hozzáadását adja vissza. Gondolhatja úgy, mint egy számológépet, ahol értékeket ad meg, és cserébe megkapja a kívánt eredményt.

A függvény meghatározása után tetszőleges argumentumokkal hívhatjuk meg.

add_numbers(3, 5)

A kwargs érv

kwargs a Pythonban a „kulcsszó argumentumok” rövidítése. Lehetővé teszi a függvények rugalmasságának kiterjesztését azáltal, hogy a hívónak tetszőleges számú kulcsszó-argumentumot megadhat a függvény meghívásakor. A kulcsszó argumentumok szótárként kerülnek átadásra a függvénynek.

Egy függvénydefinícióban használhatja a kettős csillagot **a paraméter neve előtt a kulcsszóargumentumok elfogadásához.

def my_function(**kwargs): kulcs esetén a kwargs.items(): print(f"{key} = {value}") my_function(a=1, b=2, c=3)

Ebben a példában kwargs egy szótár lesz, amely a függvénynek átadott kulcsszó-argumentumokat tartalmazza. A kimenet az alábbi képen látható:

Funkció hívása

Egy függvény meghívása azt jelenti, hogy a kódot a függvény törzsében hajtjuk végre. A Pythonban négyféle függvényhívás létezik:

• Alapfunkciók hívása
• Hívás pozíciói érvekkel
• Hívás kulcsszóargumentumokkal

Alapfunkciók hívása

Az alap függvényhívás meghívja a függvényt anélkül, hogy argumentumot adna át a függvénynek. A függvény definiálása után a nevével, majd zárójelekkel hívhatja meg.

Ha a függvény nem vesz fel argumentumot, a zárójelek üresek lesznek. Az alábbi kód egy példa egy alapfunkcióra.

def welcome_message(): print("Üdvözlünk a LuckyTemplatesben!") welcome_message()

A fenti kód futtatása a következő kimenetet adja:

Pozíciós érvek

A pozíciós argumentumok a leggyakoribb típusú argumentumok, és a megadott sorrendben kerülnek át a függvénynek. A következő példa egy függvényhívásra pozicionális argumentumokkal:

def welcome_message(name): print(f"Üdvözlünk a LuckyTemplatesben, {name}!") welcome_message("János")

A fenti példában a welcome_message()függvény egy argumentumot vesz fel, name. Ha ezt a függvényt az argumentummal hívja meg John, az üzenetet a név mellé írja ki.

A fenti kód a következő kimenetet adja:

Kulcsszóérvek

Az argumentumok függvénynek való átadásának másik módja a kulcsszó argumentumok használata. A kulcsszóargumentumok lehetővé teszik a paraméter nevének és értékének megadását, így a kód olvashatóbbá válik, és csökkenti az argumentumok rossz sorrendben történő átadásának esélyét. 

Az alábbi példa kulcsszó argumentumokat használ a welcome_messagefüggvény meghívására:

def welcome_message(name, message='Üdvözöljük a LuckyTemplates-ben!'): print(üzenet, név) welcome_message(name='Alice', message='Jó reggelt')

Ebben a példában definiáltunk egy függvényt welcome_message(), amelynek két paramétere van: name, és message. Az üzenet paraméter alapértelmezett argumentuma: Welcome to LuckyTemplates!A függvény meghívásakor kulcsszó argumentumokat használunk az érték átadására John, ami a kimenetet eredményezi.Welcome to LuckyTemplates! John.

Visszatérési értékek

Amikor függvényekkel dolgozik, gyakran vissza akarja adni a függvény törzsében végzett műveletek eredményét. A visszatérési értékek lehetővé teszik, hogy egy függvény visszaküldje az eredményt a hívónak. Ha megérti, hogyan kell dolgozni egy és több visszatérési értékkel, javíthatja Python-programjainak funkcionalitását.

Egyetlen hozamérték

Az egyetlen visszatérési érték függvény egy értéket ad vissza a függvény műveleteiből.

Az alábbiakban látható egy példa egyetlen visszatérési érték függvényére:

def get_greeting(name): return "Hello, " + name + "!" greeting = get_greeting("Alice") print(üdv)

A fenti példában a függvény get_greetingnevet vesz fel, ahogy a függvény argumentuma lefordítja azt, és személyre szabott üdvözlést ad vissza. A visszatérési értéket ezután a rendszer az üdvözlő változóban tárolja , és kinyomtatja a konzolra.

Több visszatérési érték

Időnként egynél több értéket kell visszaadnia egy Python függvényből. Ennek eléréséhez használhat egy tuple-t vagy egy listát a visszatérési értékek tördeléséhez.

Az alábbiakban egy példa látható a Python programozási nyelv többszörös visszatérési értékére.

def get_name_and_age(): return ("János", 30) név, kor = get_name_and_age() print(name) print(age)

Ebben a példában get_name_and_ageegy függvény, amely két értékkel tér vissza: a name és an age.

Vissza is küldhet egy . Az alábbi függvény egy függvényből származó lista visszatérési értéket mutat be.

def számítási_területek(magasság, szélesség): return [magasság * szélesség, (magasság * szélesség) / 2] terület, háromszög_terület = kiszámított_területek(10, 5) print(area) print(háromszög_terület)

Ebben az esetben a függvény calculate_areaskét argumentumot vesz fel, height, és width, és egy listát ad vissza, amely egy téglalap és egy háromszög területét tartalmazza.

Python-függvények átadása argumentumként

A Python lehetővé teszi, hogy függvényeket argumentumként adjon át más függvényeknek. Ha egy függvény elfogad egy másik függvényt argumentumként, akkor magasabb rendű függvénynek nevezzük.

Az alábbi kód egy példa egy függvény átadására egy másik Python függvénynek:

def square(x): return x * x def double(x): return x * 2 def apply_func(func, x): return func(x) result = apply_func(négyzet, 5)

Beágyazott függvények

A beágyazott függvények egy másik függvényen belül meghatározott függvények, más néven belső függvények. Ezek hasznosak lehetnek lezárások és moduláris kód létrehozásakor. 

Beágyazott függvény létrehozásához egyszerűen definiáljon egy függvényt egy másik függvényen belül:

def outer_function(x, y): def inner_function(z): return x + y + z result = inner_function(3) return result # A külső függvény meghívása print(outer_function(1, 2))

A fenti példában az inner_function a külső_függvényen belül van definiálva. A belső függvény hozzáfér a külső függvény változóihoz, lehetővé téve, hogy műveleteket hajtson végre azokon.

Lambda funkciók

A lambda-függvények, más néven névtelen függvények, kis, egyszer használatos függvények létrehozásának módjai a Pythonban. Az adattudományi projektekben gyakran Lambda-függvényekkel dolgozik hatékony adatstruktúrák és folyamatok létrehozása érdekében.

Lambda függvény létrehozásához használhatja a lambda kulcsszót, amelyet argumentumok listája, kettőspont, majd egy kifejezés követ. A kifejezés az, amit a lambda függvény visszaad, miután meghívták. A következő egy példa a lambda függvényre a Pythonban:

add = lambda a, b: a + b eredmény = add(3, 4) print(eredmény) # Kimenet: 7

A fenti példában létrehoztunk egy lambda függvényt, amely két argumentumot ( a és b) vesz fel, és ezek összegét adja vissza. Ezt a lambda függvényt egy változóhoz rendeltük hozzá add.

A lambda a következő esetekben lehet hasznos:

• Argumentumaként magasabb rendű függvényekhez, mint a map(), filter() és sorted().
• Kulcsfunkcióként listák vagy szótárak rendezésekor.

A következő példa bemutatja a filter() magasabb rendű függvény használatát lambdával:

számok = [1, 2, 3, 4, 5, 6, 7, 8, 9] páros_számok = lista(szűrő(lambda x: x % 2 == 0, számok)) print(páros_számok) # Kimenet: [2, 4, 6, 8]

Ebben a példában lambda függvényt használtunk a filter() függvény szűrési feltételeinek meghatározására. A lambda függvény ellenőrzi, hogy egy szám páros-e, és a filter() függvény egy új listát ad vissza, amely csak a páros számokat tartalmazza.

Ha egy példát szeretne látni arra, hogy a függvények hogyan lehetnek hasznosak különböző adattudományi forgatókönyvekben, tekintse meg az alábbi videót:

Rekurzió

A rekurzió olyan programozási technika, ahol egy függvény meghívja magát. Ez hasznos módja lehet az összetett problémák megoldásának, ha azokat kisebb, azonos részproblémákra bontja.

Rekurzív függvény létrehozásakor két dolgot kell szem előtt tartani: az alapesetet és a rekurzív esetet. 

• Az alapeset az a feltétel, amely leállítja a rekurziót
• A rekurzív eset az, amikor a függvény meghívja magát. A rekurzív eset a függvény iterátoraként működik

A következő példa a Python rekurzív függvényeit mutatja be:

def faktoriális(n): ha n == 1: return 1 return n * factorial(n - 1) factorial(5)

Ebben a példában az alapeset az, amikor n == 1, és a függvény a következőt adja vissza 1. A rekurzív eset akkor fordul elő, ha n nem egyenlő 1-gyel, és a függvény -val hívja meg magát n - 1.

Gyakori hibák és hibaelhárítás

Ha Ön kezdő programozó, akkor gyakran ütközik hibákba olyan függvények implementálásakor, mint a rekurzív és a lambda függvények. A következő szakaszok néhány gyakori hibát és hibaelhárítási tippeket mutatnak be, amelyek segítenek hatékonyan megoldani őket.

1. TypeError: hiányzik egy kötelező argumentum : Ez a hiba akkor fordul elő, ha nem ad meg megfelelő számú argumentumot, mint amit a függvény vár.

def my_function(fname, lname): print(fname, lname) # A my_function("János", "Doe") helyes hívása # Hibát jelez my_function("János")

A hiba kijavításához győződjön meg arról, hogy megfelelő számú argumentumot ad át a függvénynek.

2. TypeError: nem támogatott operandustípus . Ez a hiba akkor fordulhat elő, ha nem kompatibilis típusú operátort próbál használni.

def add_number(a, b): return a + b # Helyes hívás eredménye = add_number(5, 3) print(eredmény) # Hibát ad a helytelen args miatt eredmény = add_number("5", 3) print(eredmény)

A hiba kijavításához ellenőrizze, hogy a funkciók a megfelelő adattípusokkal foglalkoznak-e, és fontolja meg a típusöntést, ha szükséges

3. NameError: a 'függvény_neve' név nincs megadva : Ez a hiba arra utal, hogy a függvény még nem lett definiálva a meghívása előtt. 

# Helyes sorrend def greet(): print("Szervusz!") greet() # Helytelen sorrend goodbye() def goodbye(): print("Viszlát!")

A hiba kijavításához győződjön meg arról, hogy a függvény megfelelően van definiálva, és a definíciója után hívja meg.

Következtetés

A megértés összefoglalása és megszilárdítása érdekében a következő pontok összefoglalják a Python függvények hívásának fő szempontjait:

• Egy függvény meghívásához használja a függvény nevét, majd zárójeleket (pl. function_name()).
• Ha a függvény argumentumokat vesz fel, azokat zárójelek közé kell tenni (pl. function_name(arg1, arg2)).
• Létrehozhatja saját függvényeit a def kulcsszó használatával, meghatározva a függvény hatókörét és a szükséges argumentumokat.
• Egy értéket visszaadó függvény meghívásakor az eredményt hozzárendelheti egy változóhoz későbbi felhasználás céljából (pl. result = function_name(args)).