Haladó funkciók a Pythonban. 8. rész Python tanfolyam kezdőtől a haladóig 11 blogbejegyzésben

Ez a cikk segít az olvasónak folytatni az előző Python függvények blogot néhány alapvető alkalmazással a valóságban. A Visual Studio Code-ot fogjuk használni kód szerkesztőként. Ha még nem telepítetted a Visual Studio Code-ot, az utasítások a első blogban találhatók.

Fejlett függvények Pythonban – tartalomjegyzék:

1. Függvények átadása más függvényeknek
2. Függvények használata egy függvényen belül
3. *Args Pythonban
4. “*” operátor Pythonban
5. **kwargs Pythonban

Függvények átadása más függvényeknek

Ahogy az előző blogban is tárgyaltuk, a Pythonban a függvényeket objektumként kezelik. Tehát, mint a Pythonban az objektumok, a függvényeket is át lehet adni egy másik függvénynek argumentumként.

Például:

def mul(x, y):
    return x*y
 
 
def add(mul, y):
    return mul+y
 
 
x = add(mul(9, 10), 10)
print(x)

A fenti kódrészletben látható, hogy a mul függvény argumentumként van átadva az add függvénynek, és az x változóban tárolódik, amelyet ezután kiíratunk az eredmény ellenőrzésére.

100

Függvények használata egy függvényen belül

Pythonban definiálhatunk egy függvényt egy másik függvényen belül. Ezeket a függvényeket beágyazott függvényeknek nevezzük. De ebben az esetben a belső függvény vagy beágyazott függvény nem hívható meg külön. Mindkét példa a következő kódrészletben van illusztrálva.

Írjuk meg az első függvényünket.

def mul(x, y):
 
    m = x*y
 
    def square(m):
        return m*m
 
    return square(m)
 
 
x = mul(9, 10)
 
print(x)

Kimenet:
8100

A fenti kódrészletben a külső függvény a “mul”, amely visszaadja a square függvényt, amely egy “m” argumentumot vesz, amely a “mul” függvénynek adott két argumentum szorzata. A kód végrehajtása először a “mul” függvény hívásával kezdődik, majd az “x” és “y” szorzata tárolódik az “m” változóban. Mivel ez a függvény a square függvényt adja vissza, a “square” függvény hívódik meg, és a végső termék, amely “m” négyzete, visszaadásra kerül.

Tanuljunk meg néhány fontos dolgot Pythonban, amelyek sokkal jobbá teszik a kódolási utadat Pythonnal.

*Args Pythonban

Ezek azok az argumentumok, amelyeket függvényparaméterekként használunk. Írjunk egy szokásos függvényt, amely a mostanáig tanultakat használja. Olyan függvényt fogunk írni, amely megadja nekünk egy téglalap maximális területét, ha 2 téglalap területét adjuk meg paraméterként a függvénynek.

def maxarea(a, b):
    if a > b:
        return f'a téglalapnak nagyobb a területe, ami {a}'
    else:
        return f'a téglalapnak nagyobb a területe, ami {b}'
 
 
x = maxarea(100, 60)
print(x)
 

Kimenet:
a téglalapnak nagyobb a területe, ami 100

Ez a függvény jó 2 paraméter vagy argumentum esetén, de mi van, ha több mint 2 területet kell összehasonlítanunk. Az egyik megközelítés az lenne, hogy egy területek listáját adjuk át a függvénynek.

def maxarea(lis):
 
    max = 0
    for i in lis:
        if i > max:
            max = i
 
    return f"a téglalap, amelynek nagyobb a területe, az {max}"
 
 
x = maxarea([100, 60, 50])
print(x)

Kimenet:
a téglalap, amelynek nagyobb a területe, az 100

Ez a megközelítés jó, de tudnunk kell a paraméterek vagy argumentumok számát előre. A valós idejű kód végrehajtás során ez problémát jelenthet. Ezért, hogy megkönnyítsük a programozók életét, a Python *args és **kwargs-t használ.

“*” operátor Pythonban

Ez az operátor egy kibővítő operátor, amelyet általában egy nem meghatározott számú paraméter vagy argumentum átadására használnak.

Argumentumok kibővítése tuple-be * operátor használatával

Ahogy láttuk, a “*” operátor az értékek kibővítésére szolgál. Az alábbi példa illusztrálja.

x = [1, 2, 3, 4]
y = [5, 6, 7, 8]
 
z = *x, *y
 
print(type(z))
print(z)

Kimenet:
<class 'tuple'>
(1, 2, 3, 4, 5, 6, 7, 8)

Ahogy láthatjuk, a kibővítő operátor kibővítette az x listát és az y listát a z tuple-be. Azt is láthatjuk, hogy az eredmény egy tuple.

Írjuk meg ugyanazt a függvényt *Args használatával.

def maxarea(*lis):
 
    max = 0
    for i in lis:
        if i > max:
            max = i
 
    return f"a téglalap, amelynek nagyobb a területe, az {max}"
 
 
x = maxarea(100, 60, 50, 200)
y = maxarea(100, 60, 50, 200, 9000)
z = maxarea(100, 60, 50, 20, 90)
print(x)
print(y)
print(z)

Kimenet:
a téglalap, amelynek nagyobb a területe, az 200
a téglalap, amelynek nagyobb a területe, az 9000
a téglalap, amelynek nagyobb a területe, az 100

Ebben a kódrészletben láthatjuk, hogy most az argumentumok dinamikusak, bármennyi argumentumot hozzáadhatunk, amelyeket a maxarea függvény kibővít, hogy megadja a kívánt eredményt. Ezen a téren bármennyi területet összehasonlíthatunk.

**kwargs Pythonban

A kwargs hasonló az args-hoz, de elfogadja a pozicionális argumentumokat. A ** operátort használja, amelynek van néhány tulajdonsága, mint például több pozicionális argumentum kibővítése bármilyen hosszúságban, szótárak kibővítése, valamint két szótár egyesítése.

Szótárak egyesítése

a = {"h": 1, "n": 2}
b = {"m": 5, "l": 10}
 
c = {**a, **b}
 
print(type(c))
print(c)

Láthatjuk a fenti kódból, hogy van 2 szótárunk, a és b, amelyeket a ** operátorral egyesítünk, hogy egy másik szótárat kapjunk.

Kimenet:
<class 'dict'>
{'h': 1, 'n': 2, 'm': 5, 'l': 10}

Amikor a * operátort használjuk a ** operátor helyett, az alábbi kód illusztrálja ezt az esetet.

a = {"h": 1, "n": 2}
b = {"m": 5, "l": 10}
 
c = {*a, *b}
 
print(type(c))
print(c)

Kimenet:
<class 'set'>
{'n', 'l', 'm', 'h'}

Tehát, amikor a * operátort használjuk két szótár egyesítésére, az eredmény egy halmaz lesz, amely csak a szótár kulcsait tartalmazza.

A maxarea függvény **kwargs használatával az alábbi kódrészletben van illusztrálva.

def maxarea(**lis):
 
    max = 0
    for i in lis.values():
        if i > max:
            max = i
 
    return f"a téglalap, amelynek nagyobb a területe, az {max}"
 
 
x = maxarea(a=1, b=2, c=3)
y = maxarea(a=1, b=2)
z = maxarea(a=1, b=2, c=3, d=9)
print(x)
print(y)
print(z)

Kimenet:
a téglalap, amelynek nagyobb a területe, az 3
a téglalap, amelynek nagyobb a területe, az 2
a téglalap, amelynek nagyobb a területe, az 9

Ebben a blogban a Python fejlett függvényeiről olyan témákat tárgyaltunk, mint a függvények átadása más függvényeknek, függvények használata egy függvényen belül, *Args Pythonban, “*” operátor Pythonban, **kwargs Pythonban, és még sok más. A további témák, amelyek az osztályokat tartalmazzák, a következő blogbejegyzésben lesznek tárgyalva. A Python fejlett függvényeivel kapcsolatos házi feladat az alábbiakban található.