A függvénytúlterhelés megértése Pythonban

A függvénytúlterhelés egyes programozási nyelvek olyan szolgáltatása, amely lehetővé teszi ugyanazon függvény variációinak meghatározását. Mindegyik változatnak ugyanaz a neve, de különböző megvalósításai vannak, egyedi függvényaláírásokkal.

Ez a technika lehetővé teszi különböző műveletek végrehajtását a függvénynek átadott argumentumok típusától és számától függően.

Az olyan nyelvekkel ellentétben, mint a C++ és a Java, a Python alapértelmezés szerint nem támogatja a funkciók túlterhelését, de vannak módok hasonló funkciók elérésére.

Hogyan kezeli a Python a funkciók túlterhelését?

A Pythonban ugyanazt a függvényt többször is megadhatja különböző paraméterekkel, adattípusokkal vagy mindkettővel az egyes definíciókban. A Python azonban csak a függvény utolsó definícióját ismeri fel, amikor meghívja. Íme egy példa:

defarithmetics(a, b):
return a - b
defarithmetics(a, b, c, d):
return a + b - c * d
print(arithmetics(1, 2, 3, 5)) # returns -12
print(arithmetics(1, 2)) # returns missing positional arguments error

Az objektum-orientált nyelvek, mint például a Java, gyakran támogatják a funkciók és módszerek túlterhelését. A metódus egyszerűen egy függvény, amelyet egy osztályon belül határoz meg.

A fenti kódban a Python csak a második definícióját ismeri fel aritmetika() függvényt, amikor megpróbálja meghívni a projektben. Ha megpróbálja meghívni a függvényt két argumentummal az első definíció szerint, akkor hibaüzenetet kap, amely azt mondja, hogy "hiányoznak a szükséges pozíciós argumentumok".

Nem fog hibaüzenetet kapni, ha négy argumentummal hívja meg a függvényt. Ez azt jelenti, hogy a Python felülírta a függvényt a legújabb példányával. Ez nem a túlterhelés viselkedése, ezért foglalkoznia kell vele.

Tehát a Python alapértelmezés szerint nem kezeli a funkciók túlterhelését, de van néhány trükk, amellyel szimulálhatja a viselkedését a programokban.

1. módszer: Opcionális paraméterek vagy alapértelmezett argumentumok használata

A túlterhelést az alapértelmezett argumentumokkal rendelkező függvény definiálásával érheti el. Íme egy példa:

defarithmetics(a, b=0, c=0):

 Arguments:
 a: The first number.
 b: The second number (optional).
 c: The third number (optional).

return a - b + c

Ennek a függvénynek három paramétere van, de ezek közül kettőnek alapértelmezett értéke van. Ez azt jelenti, hogy egy és három argumentum között hívhatja meg:

print(arithmetics(1)) # returns 1
print(arithmetics(2, 5)) # returns -3
print(arithmetics(10, 3, 4)) # returns 11

Bár ez a megközelítés lehetővé teszi a függvény több különböző módon történő meghívását, hosszú távon nem túl hatékony. Íme néhány korlátozása:

• Csak olyan argumentumokat adhat át, amelyek egészek vagy lebegő értékek.
• A függvény viselkedésében nincs jelentős változás. Például nem változtathatja meg a viselkedését az alakzat területének kiszámításához vagy akár a nyomtatáshoz Helló Világ.

2. módszer: Változó argumentumok használata

Ha változó argumentumokat szeretne használni a függvény túlterheléséhez a Pythonban, ezt meg kell tennie a függvény meghatározásakor szerepeljen az args paraméter. A args paraméter lehetővé teszi több pozíciós argumentum átadását a függvény meghívásakor. Íme egy példa:

defarithmetics(a, *args):

 Arguments:
 a: The first number.
 *args: A variable number of arguments (optional).

 args_sum = 0
for num in args:
 args_sum *= num
return a - args_sum
print(arithmetics(1)) # returns 1
print(arithmetics(2, 5)) # returns 2
print(arithmetics(10, 3, 4, 2, 4, 6)) # returns 10

A fenti függvény két argumentumot használ: egy kötelező argumentumot a és a args argumentum, amely lehetővé teszi, hogy annyi argumentumot írjon be, amennyire szüksége van.

Bár több argumentumot is igénybe vehet, a fenti függvény csak a változó argumentumain tudja végrehajtani a szorzási műveletet, azaz azokon az argumentumokon, amelyeket a args kulcsszó.

Ha több műveletet szeretne végrehajtani, akkor muszáj feltételes utasításokat vezessen be a kódjába, és ez gyorsan bonyolulttá válhat.

3. módszer: A többszörös feladású dekorátor használata

A többszörös küldés dekorátor egy Python-könyvtár, amely lehetővé teszi egyetlen függvény több megvalósításának vagy példányának meghatározását az argumentumok típusa alapján. Ez azt jelenti, hogy ugyanazt a funkciót definiálhatja különböző adattípusokkal, és teljesen megváltoztathatja a viselkedését.

A többszörös feladású dekorátor használatához kövesse az alábbi lépéseket:

1. Telepítés többszörös diszpath Python környezetben:

   pip install multipledispatch
   

2. Díszítse a funkció(ka)t a @Elküldés lakberendező. A @Elküldés lakberendező a Python dekorátor amely lehetővé teszi a többszörös feladás megvalósítását. Automatikusan elküldi a megfelelő függvényt a neki átadott argumentumok alapján. Használhatja a @Elküldés díszítő a következő mintát követve:

   from multipledispatch import dispatch
   @dispatch(data type1, data type2, data typeX)
   defyour_function(a, b, c, x):
   pass
   # perform your operations here
   

Íme egy példa, amely a többszörös küldés dekorátort használja a Python funkció túlterhelésére:

from multipledispatch import dispatch
@dispatch(int, int)
defadd(a, b):

 Arguments:
 a: Any integer.
 b: Any integer.

return a + b
@dispatch(int, list)
defadd(a, b):

 Arguments:
 a: Any integer.
 b: Any Python list.

 b.append(a)
return b
# returns 3
print(add(1, 2))
# returns [2, 3, 4, 5, 'w', 'done', 1]
print(add(1, [2, 3, 4, 5, 'w', 'done']))

A fenti kódrészlet két példányát határozza meg a add() funkció. Az első példány két egész számot vesz argumentumként, és ezek összegét adja vissza.

Eközben a függvény második verziója egy egész számot és egy listát vesz fel. Hozzáfűzi az egész számot a listához, és visszaadja az új listát.

A Python funkció túlterhelésének ez a megközelítése nagy rugalmasságot biztosít, különösen, ha módosítania kell a módszer viselkedését. Többet megtudhat a többszörös kiszállítási dokumentáció.

A Python funkció túlterhelésének legjobb megközelítése

A túlterheléshez alkalmazott megközelítés attól függ, hogy mit próbál elérni. Ha a feladatot alapértelmezett vagy változó argumentumokkal tudja végrehajtani, akkor a többszörös kiküldés dekorátora túlzás lehet. Azonban a többszörös kiszállítású dekorátor általában a legjobb megoldás hatékonysága és pontossága szempontjából.

Ez a dekorátor tiszta és rugalmas módot biztosít a funkciók túlterhelésének megvalósítására Pythonban. Lehetővé teszi egyetlen függvény több megvalósításának meghatározását az argumentumok típusa alapján.

Ezzel a megközelítéssel olyan rugalmas függvényeket hozhat létre, amelyek képesek különböző paramétertípusokat elfogadni anélkül, hogy bonyolult feltételes utasításokra lenne szükség.