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?
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:
Ez a rész a felhasználó által definiált funkciókra összpontosít. Megtanulod:
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
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:
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.
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:
function_name()).function_name(arg1, arg2)).result = function_name(args)).Ebből a blogból megtudhatja, hogyan mentheti automatikusan az e-mail mellékleteket a SharePointba, majd törölheti az e-maileket a Power Automate segítségével.
A Microsoft LuckyTemplates irányítópult 18 legjobb példája 2023
Ismerje meg, hogyan hozhat létre <strong>Power Automate</strong> folyamatokat a semmiből. Sablon használata helyett mi magunk hozzuk létre a kiváltó okokat és a műveleteket.
4 módszer a Pi használatára a Pythonban példákkal
Ebben az útmutatóban bemutatom, hogyan lehet Pénzügyi információk mátrixát létrehozni a Profit és veszteség (P&L) kimutatással a LuckyTemplates alkalmazásban.
Fedezze fel, hogyan lehet dinamikusan egyesíteni oszlopokat a Power Query Table.CombineColumns függvény segítségével.
Ismerje meg, hogyan adhatjuk hozzá és szinkronizálhatjuk SharePoint-fájljainkat az asztalon és a OneDrive-on.
Tudja meg, miért fontos egy dedikált dátumtáblázat a LuckyTemplatesben, és ismerje meg ennek leggyorsabb és leghatékonyabb módját.
Ez a rövid oktatóanyag kiemeli a LuckyTemplates mobil jelentési funkcióját. Megmutatom, hogyan készíthet hatékony jelentéseket mobileszközökön.
Ebben a LuckyTemplates bemutatóban olyan jelentéseket tekintünk át, amelyek professzionális szolgáltatáselemzést mutatnak be egy olyan cégtől, amely több szerződéssel és ügyfél-elkötelezettséggel rendelkezik.
