Förståelse av funktionsöverladdning i Python

Funktionsöverladdning är en funktion i vissa programmeringsspråk som gör det möjligt att definiera olika varianter av samma funktion. Varje variant har samma namn, men olika implementeringar, med unika funktionssignaturer.

Denna metod gör det möjligt att utföra olika åtgärder beroende på vilken typ och mängd av parametrar som överförs till en funktion, vilket ger större flexibilitet i programmeringen.

Python skiljer sig från programmeringsspråk som C\+\+ och Java genom att det inte har något inbyggt stöd för funktionsöverladdning. Man kan dock emulera denna funktionalitet på alternativa sätt.

Hur hanterar Python funktionsöverbelastning?

I Python kan en funktion definieras flera gånger med varierande parameterspecifikationer och/eller datatyper. Ändå, när Python anropar funktionen, kommer Python uteslutande att erkänna den sista instansen av dess definition. Ett exempel på detta presenteras nedan:

 def arithmetics(a, b):
    return a - b

def arithmetics(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

Objektorienterade programmeringsspråk som Java innehåller ofta mekanismer för överbelastning av funktioner och metoder. I huvudsak är metoder funktioner som avgränsas inom ramen för en klass.

I det ovan nämnda kodavsnittet kommer Python-tolken endast att erkänna den senare deklarerade definitionen av funktionen arithmetic() när man försöker anropa den inom ett projekt. Om man försöker anropa funktionen med två parametrar som överensstämmer med dess ursprungliga deklaration, kommer ett undantag att utfärdas som anger att argument saknas och är nödvändiga för exekvering.

Ett funktionsfel uppstår inte när fyra parametrar anges under anropet, vilket indikerar att funktionen har ersatts av den senaste versionen i minnet. Detta är dock inte ett tecken på metodöverbelastning och kräver ett annat tillvägagångssätt för att lösa problemet.

Python har inget inbyggt stöd för funktionsöverbelastning, men man kan använda vissa tekniker i sin kod för att emulera denna funktionalitet.

Metod 1: Använda valfria parametrar eller standardargument

Man kan åstadkomma överbelastning genom att implementera funktioner med standardparametrar. Ett exempel på detta är följande:

 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

Den givna funktionen omfattar totalt tre ingångsvariabler, men två av dessa har fördefinierade värden. Följaktligen kan funktionen anropas med en matris bestående av ett till tre argumentativa element.

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

Även om denna metod ger olika möjligheter att anropa funktionen, visar den sig i slutändan vara en ohållbar lösning på grund av flera inneboende begränsningar.

Argumentet som skickas måste vara av en typ som antingen är ett heltal eller en float.

Det verkar inte finnas någon märkbar variation i funktionaliteten för just denna funktion. Följaktligen kan den inte utföra uppgifter som att beräkna arean av en given form eller skriva ut texten “Hello World”.

Metod 2: Använda variabelargument

För att använda överbelastning av variabelargument i Python är det viktigt att införliva parametern “args” när man definierar en funktion. Detta attribut gör det möjligt att skicka flera positionsargument under anropet av funktionen. Ett demonstrationsexempel finns nedan:

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

Den ovan nämnda funktionen kräver två parametrar; en obligatorisk parameter som kallas “a” och en valfri parameter som kallas “args”, vilket gör det möjligt att inkludera valfritt antal ytterligare argument efter behov.

Trots sin förmåga att acceptera många inmatningar är denna funktion begränsad i sin förmåga att utföra aritmetiska operationer utöver enkel multiplikation, eftersom den endast tillämpar multiplikationsprocessen på de variabler som representeras av nyckelordet args .

För att utföra en serie åtgärder i ett programmatiskt sammanhang är det ofta nödvändigt att införliva villkorliga uttalanden i sin kod. Men när antalet villkor som ska beaktas ökar, ökar också komplexiteten i den aktuella programmeringsuppgiften.

Metod 3: Använda Multiple Dispatch Decorator

Multiple Dispatch Decorator är ett Python-bibliotek som gör det möjligt att skapa olika implementeringar eller instanser av en ensam funktion beroende på vilken typ av indata den får. På så sätt kan man skapa identiska funktioner med olika datastrukturer och ändra deras beteende helt och hållet.

Följ dessa protokoll för att använda utsmyckningen multi-method dispatch:

⭐ Installera multipledispath i din Python-miljö:

 pip install multipledispatch

⭐ Dekorera dina funktioner med @dispatch-dekoratorn. @dispatch-dekoratorn är en Python-dekorator som låter dig implementera flera dispatch. Den kommer automatiskt att skicka den lämpliga funktionen baserat på de argument du skickar till den. Du kan använda @dispatch-dekoratorn genom att följa detta mönster:

 from multipledispatch import dispatch

@dispatch(data type1, data type2, data typeX)
def your_function(a, b, c, x):
    pass
    # perform your operations here

Tänk på ett scenario där vi använder multiple dispatch-dekoratorn för att underlätta konceptet med funktionsöverbelastning inom Python-programmeringsspråket:

 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

# returns 3
print(add(1, 2))

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

Det ovannämnda kodsegmentet instansierar två separata förekomster av funktionen add(), där varje respektive förekomst accepterar och bearbetar distinkta parametrar. Specifikt tar en sådan inkarnation emot och beräknar aggregatet av två numeriska värden representerade som heltalsdatatyper, vilket i slutändan ger den resulterande summan i form av en aritmetisk operations resultat.

I den efterföljande iterationen av denna operation accepteras växelvis två parametrar: ett heltal och en sekventiell samling. Därefter läggs den nämnda parametern till i slutet av serien och returneras som den ändrade ackumuleringen.

Denna metod för funktionsöverladdning i Python ger dig mycket flexibilitet, särskilt om du behöver ändra beteendet hos din metod. Du kan läsa mer i dokumentationen för multiple dispatch .

Den bästa metoden för funktionell överbelastning i Python

Valet av en lämplig metod för funktionell överbelastning bör anpassas till de mål man har för avsikt att uppnå. I de fall där det önskade resultatet kan uppnås genom användning av standard- eller variabelargument, kanske det inte är nödvändigt att använda multi-dispatch dekoratorn. I de flesta fall är dock den senare en mer effektiv och korrekt lösning eftersom den kan hantera olika typer av argument och samtidigt bibehålla optimal prestanda.

Den medföljande dekoratorn erbjuder en elegant och mångsidig metod för att implementera funktionsöverbelastning inom Python-programmeringsspråket. Den gör det möjligt att skapa olika implementeringar av en enda funktion, beroende på egenskaperna hos dess parametrar.

Genom att använda denna metod kan man utveckla mångsidiga funktioner som kan hantera en mängd olika parametertyper, vilket eliminerar kravet på komplicerade villkorssatser för att uppnå sådan anpassningsförmåga.