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:

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

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() funksjon 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:

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

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

Selv om denne tilnærmingen lar deg kalle funksjonen på flere forskjellige måter, er den ikke veldig 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 Hei Verden.

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. De args parameter lar deg sende flere posisjonelle argumenter når du kaller funksjonen din. Her er et eksempel:

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

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

Selv om det kan ta flere argumenter, kan funksjonen ovenfor bare utføre multiplikasjonsoperasjonen på de variable argumentene, dvs. argumentene representert av args nøkkelord.

Hvis du vil utføre flere operasjoner, må du introduser betingede utsagn 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:

1. Installere multipledispath i Python-miljøet ditt:

   pip install multipledispatch
   

2. Dekorer funksjonen(e) med @utsendelse dekoratør. De @utsendelse dekoratør er en Python dekoratør som lar deg implementere flere utsendelser. Den vil automatisk sende riktig funksjon basert på argumentene du sender til den. Du kan bruke @utsendelse dekoratør ved å følge dette mønsteret:

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

Her er et eksempel som bruker multiple dispatch-dekoratoren for funksjonsoverbelastning i Python:

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

Kodebiten ovenfor definerer to forekomster av Legg til() funksjon. 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 funksjonsoverbelastning 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 ulike parametertyper uten behov for komplekse betingede utsagn.