Forstå funksjonsoverbelastning i Python

Funksjonsoverbelastning er en funksjon i noen programmeringsspråk som lar deg definere varianter av samme funksjon. Hver variant har samme navn, men forskjellige implementeringer, med unike funksjonssignaturer.

Denne teknikken lar deg utføre forskjellige operasjoner basert på typen og antallet argumenter som sendes til en funksjon.

I motsetning til språk som C++ og Java, støtter ikke Python funksjonsoverbelastning som standard, men det finnes måter å oppnå lignende funksjonalitet på.

Hvordan håndterer Python funksjonsoverbelastning?

I Python kan du definere den samme funksjonen mer enn én gang med forskjellige parametere, datatyper eller begge deler i hver definisjon. Python vil imidlertid bare gjenkjenne den siste definisjonen av funksjonen når du kaller den. Her er et eksempel:

 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)) 
 

Objektorienterte språk, som Java, støtter ofte funksjons- og metodeoverbelastning. En metode er ganske enkelt en funksjon som du definerer inne i en klasse.

I koden ovenfor vil Python bare gjenkjenne den andre definisjonen av aritmetikk()-funksjonen når du prøver å kalle den i prosjektet ditt. Hvis du prøver å kalle funksjonen med to argumenter som først definert, får du en feilmelding som sier «mangler nødvendige posisjonsargumenter».

Du får ingen feil når du kaller funksjonen med fire argumenter. Dette betyr at Python har overskrevet funksjonen med sin siste forekomst. Dette er ikke oppførselen til overbelastning, så du må takle det.

Så Python håndterer ikke funksjonsoverbelastning som standard, men det er noen triks du kan bruke for å simulere oppførselen i programmene dine.

Metode 1: Bruke valgfrie parametere eller standardargumenter

Du kan oppnå overbelastning ved å definere en funksjon med standardargumenter. Her er et eksempel:

 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

Denne funksjonen har tre parametere, men to av dem har standardverdier. Dette betyr at du kan kalle det med mellom ett og tre argumenter:

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

Selv om denne tilnærmingen lar deg kalle funksjonen på flere forskjellige måter, er den ikke særlig effektiv i det lange løp. Her er noen av begrensningene:

• Du kan bare sende argumenter som enten er heltall eller flyter.
• Det er ingen vesentlig endring i funksjonens oppførsel. Du kan for eksempel ikke endre oppførselen for å beregne arealet til en form eller til og med skrive ut Hello World.

Metode 2: Bruke variable argumenter

For å bruke variable argumenter for funksjonsoverbelastning i Python, bør du inkludere args-parameteren når du definerer funksjonen din. Args-parameteren lar deg sende flere posisjonsargumenter når du kaller funksjonen din. Her er et eksempel:

 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)) 
 

Funksjonen ovenfor tar to argumenter: et obligatorisk argument kalt a og argumentet args, som lar deg legge inn så mange argumenter du trenger.

Selv om den kan ta flere argumenter, kan funksjonen ovenfor bare utføre multiplikasjonsoperasjonen på variabelargumentene, dvs. argumentene som er representert av nøkkelordet args.

Hvis du vil utføre flere operasjoner, må du introdusere betingede setninger til koden din, og dette kan fort bli komplisert.

Metode 3: Bruke Multiple Dispatch Decorator

Multiple dispatch-dekoratoren er et Python-bibliotek som lar deg definere flere implementeringer eller forekomster av en enkelt funksjon, basert på typen argumenter. Dette betyr at du kan definere den samme funksjonen med forskjellige datatyper og endre oppførselen fullstendig.

Følg disse trinnene for å bruke dekoratoren for flere forsendelser:

 pip install multipledispatch

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

Her er et eksempel som bruker multiple dispatch-dekoratoren for funksjonsoverbelastning 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']))
 

Kodebiten ovenfor definerer to forekomster av add()-funksjonen. Den første instansen tar to heltall som argumenter og returnerer summen deres.

I mellomtiden tar den andre versjonen av denne funksjonen inn et heltall og en liste. Den legger til hele tallet til listen og returnerer den nye listen.

Denne tilnærmingen til funksjonsoverbelastning i Python gir deg mye fleksibilitet, spesielt hvis du trenger å endre oppførselen til metoden din. Du kan lære mer fra dokumentasjon for flere utsendelser.

Den beste tilnærmingen til funksjonsoverbelastning i Python

Tilnærmingen du tar for å overbelaste funksjonen bør avhenge av hva du prøver å oppnå. Hvis du kan fullføre oppgaven din ved å bruke standard eller variable argumenter, kan dekoratoren for flere utsendelser være overkill. Imidlertid er dekoratøren med flere forsendelser vanligvis det beste alternativet for sin effektivitet og nøyaktighet.

Denne dekoratoren gir en ren og fleksibel måte å implementere funksjonsoverbelastning i Python. Den lar deg definere flere implementeringer av en enkelt funksjon basert på typen argumenter.

Med denne tilnærmingen kan du lage fleksible funksjoner som kan akseptere forskjellige parametertyper uten behov for komplekse betingede utsagn.