Förstå funktionsöverbelastning i Python

Funktionsöverbelastning är en funktion i vissa programmeringsspråk som låter dig definiera varianter av samma funktion. Varje variant har samma namn, men olika implementeringar, med unika funktionssignaturer.

Den här tekniken låter dig utföra olika operationer baserat på typen och antalet argument som skickas till en funktion.

Till skillnad från språk som C++ och Java stöder Python inte funktionsöverbelastning som standard, men det finns sätt att uppnå liknande funktionalitet.

Hur hanterar Python funktionsöverbelastning?

I Python kan du definiera samma funktion mer än en gång med olika parametrar, datatyper eller båda i varje definition. Python kommer dock bara att känna igen den sista definitionen av funktionen när du anropar den. Här är ett exempel:

 def arithmetics(a, b):
    return a - b
def arithmetics(a, b, c, d):
    return a + b - c * d
print(arithmetics(1, 2, 3, 5)) 
print(arithmetics(1, 2)) 
 

Objektorienterade språk, som Java, stöder ofta funktions- och metodöverbelastning. En metod är helt enkelt en funktion som du definierar i en klass.

I ovanstående kod kommer Python bara att känna igen den andra definitionen av funktionen aritmetics() när du försöker anropa den i ditt projekt. Om du försöker anropa funktionen med två argument som först definierades, kommer du att få ett felmeddelande som säger ”saknade nödvändiga positionsargument”.

Du får inget fel när du anropar funktionen med fyra argument. Det betyder att Python har skrivit över funktionen med sin senaste instans. Detta är inte beteendet för överbelastning, så du måste ta itu med det.

Så, Python hanterar inte funktionsöverbelastning som standard, men det finns några knep du kan använda för att simulera dess beteende i dina program.

Metod 1: Använda valfria parametrar eller standardargument

Du kan uppnå överbelastning genom att definiera en funktion med standardargument. Här är ett exempel:

 def arithmetics(a, b=0, c=0):
    """
    Arguments:
    a: The first number.
    b: The second number (optional).
    c: The third number (optional).
    """
    return a - b + c

Denna funktion har tre parametrar, men två av dem har standardvärden. Det betyder att du kan kalla det med mellan ett och tre argument:

 print(arithmetics(1)) 
print(arithmetics(2, 5)) 
print(arithmetics(10, 3, 4)) 

Även om detta tillvägagångssätt låter dig anropa funktionen på flera olika sätt, är det inte särskilt effektivt i längden. Här är några av dess begränsningar:

• Du kan bara skicka argument som är antingen heltal eller flytande.
• Det finns ingen signifikant förändring i funktionens beteende. Du kan till exempel inte ändra dess beteende för att beräkna arean av en form eller ens skriva ut Hello World.

Metod 2: Använda variabelargument

För att använda variabla argument för funktionsöverbelastning i Python bör du inkludera parametern args när du definierar din funktion. Parametern args låter dig skicka flera positionsargument när du anropar din funktion. Här är ett exempel:

 def arithmetics(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)) 
print(arithmetics(2, 5)) 
print(arithmetics(10, 3, 4, 2, 4, 6)) 
 

Funktionen ovan tar två argument: ett obligatoriskt argument som kallas a och argumentet args, som låter dig ange så många argument som du behöver.

Även om det kan ta flera argument, kan funktionen ovan endast utföra multiplikationsoperationen på de variabla argumenten, dvs de argument som representeras av nyckelordet args.

Om du vill utföra flera operationer måste du introducera villkorssatser i din kod, och detta kan snabbt bli komplicerat.

Metod 3: Använda Multiple Dispatch Decorator

Multiple dispatch decorator är ett Python-bibliotek som låter dig definiera flera implementeringar eller instanser av en enda funktion, baserat på typen av dess argument. Det betyder att du kan definiera samma funktion med olika datatyper och ändra dess beteende helt.

Följ dessa steg för att använda dekoratorn för flera utskick:

 pip install multipledispatch

 from multipledispatch import dispatch
@dispatch(data type1, data type2, data typeX)
def your_function(a, b, c, x):
    pass
    
 

Här är ett exempel som använder multiple dispatch decorator för funktionsöverbelastning i Python:

 from multipledispatch import dispatch
@dispatch(int, int)
def add(a, b):
    """
    Arguments:
    a: Any integer.
    b: Any integer.
    """
    return a + b
@dispatch(int, list)
def add(a, b):
    """
    Arguments:
    a: Any integer.
    b: Any Python list.
    """
    b.append(a)
    return b

print(add(1, 2))

print(add(1, [2, 3, 4, 5, 'w', 'done']))
 

Kodavsnittet ovan definierar två instanser av add()-funktionen. Den första instansen tar två heltal som sina argument och returnerar deras summa.

Samtidigt tar den andra versionen av denna funktion ett heltal och en lista. Den lägger till heltal till listan och returnerar den nya listan.

Detta tillvägagångssätt för funktionsöverbelastning i Python ger dig mycket flexibilitet, speciellt om du behöver ändra beteendet hos din metod. Du kan lära dig mer av dokumentation för flera sändningar.

Det bästa tillvägagångssättet för funktionsöverbelastning i Python

Tillvägagångssättet du tar för att fungera överbelastning bör bero på vad du försöker uppnå. Om du kan slutföra din uppgift med standardargument eller variabla argument, kan dekoratorn för flera utskick vara överdriven. Men dekoratören med flera utskick är vanligtvis det bästa alternativet för dess effektivitet och noggrannhet.

Denna dekoratör ger ett rent och flexibelt sätt att implementera funktionsöverbelastning i Python. Det låter dig definiera flera implementeringar av en enda funktion baserat på typen av dess argument.

Med detta tillvägagångssätt kan du skapa flexibla funktioner som kan acceptera olika parametertyper utan behov av komplexa villkorssatser.