Forstå funktionsoverbelastning i Python

Funktionsoverbelastning er en funktion i nogle programmeringssprog, der lader dig definere variationer af den samme funktion. Hver variant har det samme navn, men forskellige implementeringer, med unikke funktionssignaturer.

Denne teknik lader dig udføre forskellige operationer baseret på typen og antallet af argumenter, der sendes til en funktion.

I modsætning til sprog som C++ og Java, understøtter Python ikke funktionsoverbelastning som standard, men der er måder at opnå lignende funktionalitet på.

Hvordan håndterer Python funktionsoverbelastning?

I Python kan du definere den samme funktion mere end én gang med forskellige parametre, datatyper eller begge dele i hver definition. Python vil dog kun genkende den sidste definition af funktionen, når du kalder 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

Objektorienterede sprog, som Java, understøtter ofte funktions- og metodeoverbelastning. En metode er simpelthen en funktion, som du definerer inde i en klasse.

I ovenstående kode genkender Python kun den anden definition af aritmetik() funktion, når du forsøger at kalde det i dit projekt. Hvis du forsøger at kalde funktionen med to argumenter som først defineret, får du en fejl, der siger "mangler påkrævede positionsargumenter".

Du får ikke en fejl, når du kalder funktionen med fire argumenter. Det betyder, at Python har overskrevet funktionen med sin seneste instans. Dette er ikke overbelastningsadfærd, så du skal tackle det.

Så Python håndterer ikke funktionsoverbelastning som standard, men der er nogle tricks, du kan bruge til at simulere dens adfærd i dine programmer.

Metode 1: Brug af valgfrie parametre eller standardargumenter

Du kan opnå overbelastning ved at definere en funktion 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 funktion har tre parametre, men to af dem har standardværdier. Det betyder, at du kan kalde det med mellem et og tre argumenter:

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

Selvom denne tilgang giver dig mulighed for at kalde funktionen på flere forskellige måder, er den ikke særlig effektiv i det lange løb. Her er nogle af dens begrænsninger:

• Du kan kun sende argumenter, der enten er heltal eller flydende.
• Der er ingen væsentlig ændring i funktionens adfærd. For eksempel kan du ikke ændre dens adfærd for at beregne arealet af en form eller endda udskrive Hej Verden.

Metode 2: Brug af variable argumenter

For at bruge variable argumenter til funktionsoverbelastning i Python, bør du medtag parameteren args, når du definerer din funktion. Det args parameter giver dig mulighed for at sende flere positionelle argumenter, når du kalder din funktion. 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

Funktionen ovenfor tager to argumenter: et obligatorisk argument kaldet -en og args argument, som giver dig mulighed for at indtaste så mange argumenter, som du har brug for.

Selvom det kan tage flere argumenter, kan funktionen ovenfor kun udføre multiplikationsoperationen på de variable argumenter, dvs. argumenterne repræsenteret af args søgeord.

Hvis du vil udføre flere operationer, skal du introducere betingede udsagn til din kode, og det kan hurtigt blive kompliceret.

Metode 3: Brug af Multiple Dispatch Decorator

Multiple dispatch decorator er et Python-bibliotek, der giver dig mulighed for at definere flere implementeringer eller forekomster af en enkelt funktion, baseret på typen af ​​dens argumenter. Det betyder, at du kan definere den samme funktion med forskellige datatyper og ændre dens adfærd fuldstændigt.

Følg disse trin for at bruge dekoratoren til flere afsendelser:

1. Installere multipledispath i dit Python-miljø:

   pip install multipledispatch
   

2. Dekorer din funktion(er) med @afsendelse dekoratør. Det @afsendelse dekoratør er en Python dekoratør der giver dig mulighed for at implementere flere forsendelser. Den sender automatisk den relevante funktion baseret på de argumenter, du sender til den. Du kan bruge @afsendelse dekoratør ved at følge dette mønster:

   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, der bruger multiple dispatch-dekoratoren til funktionsoverbelastning 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']))

Kodestykket ovenfor definerer to forekomster af tilføje() fungere. Den første instans tager to heltal som sine argumenter og returnerer deres sum.

I mellemtiden tager den anden version af denne funktion et heltal og en liste. Det føjer hele tallet til listen og returnerer den nye liste.

Denne tilgang til funktionsoverbelastning i Python giver dig en masse fleksibilitet, især hvis du har brug for at ændre adfærden for din metode. Du kan lære mere af dokumentation for flere afsendelser.

Den bedste tilgang til funktionsoverbelastning i Python

Den tilgang, du tager til funktionsoverbelastning, bør afhænge af, hvad du forsøger at opnå. Hvis du kan fuldføre din opgave ved hjælp af standard- eller variable argumenter, kan dekoratoren med flere afsendelser være overkill. Imidlertid er dekoratøren med flere afsendelser normalt den bedste mulighed for dens effektivitet og nøjagtighed.

Denne dekorator giver en ren og fleksibel måde at implementere funktionsoverbelastning i Python. Det lader dig definere flere implementeringer af en enkelt funktion baseret på typen af ​​dens argumenter.

Med denne tilgang kan du oprette fleksible funktioner, der kan acceptere forskellige parametertyper uden behov for komplekse betingede udsagn.