Претоварването на функции може да не е вградено в Python, но има начини да го имитирате.

Претоварването на функции е функция в някои езици за програмиране, която ви позволява да дефинирате варианти на една и съща функция. Всеки вариант има едно и също име, но различни реализации, с уникални функционални подписи.

Тази техника ви позволява да извършвате различни операции въз основа на типа и броя на аргументите, предадени на функция.

За разлика от езици като C++ и Java, Python не поддържа претоварване на функции по подразбиране, но има начини за постигане на подобна функционалност.

Как Python се справя с претоварването на функции?

В Python можете да дефинирате една и съща функция повече от веднъж с различни параметри, типове данни или и двете във всяка дефиниция. Python обаче ще разпознае само последната дефиниция на функцията, когато я извикате. Ето един пример:

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
instagram viewer

Обектно-ориентираните езици, като Java, често поддържат претоварване на функции и методи. Методът е просто функция, която дефинирате вътре в клас.

В горния код Python ще разпознае само втората дефиниция на аритметика() функция, когато се опитате да го извикате във вашия проект. Ако се опитате да извикате функцията с два аргумента, както са дефинирани първоначално, ще получите грешка, която гласи „липсват необходимите позиционни аргументи“.

Няма да получите грешка, когато извикате функцията с четири аргумента. Това означава, че Python е презаписал функцията с нейния последен екземпляр. Това не е поведение на претоварване, така че трябва да се справите с него.

Така че Python не обработва претоварването на функции по подразбиране, но има някои трикове, които можете да използвате, за да симулирате поведението му във вашите програми.

Метод 1: Използване на незадължителни параметри или аргументи по подразбиране

Можете да постигнете претоварване, като дефинирате функция с аргументи по подразбиране. Ето един пример:

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

Тази функция има три параметъра, но два от тях имат стойности по подразбиране. Това означава, че можете да го извикате с между един и три аргумента:

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

Въпреки че този подход ви позволява да извиквате функцията по няколко различни начина, той не е много ефективен в дългосрочен план. Ето някои от неговите ограничения:

  • Можете да предавате само аргументи, които са или цели числа, или числа с плаваща единица.
  • Няма съществена промяна в поведението на функцията. Например, не можете да промените поведението му, за да изчислите площта на фигура или дори да отпечатате Здравей свят.

Метод 2: Използване на променливи аргументи

За да използвате променливи аргументи за претоварване на функции в Python, трябва включете параметъра args, когато дефинирате вашата функция. The аргументи параметър ви позволява да предавате множество позиционни аргументи, когато извиквате функцията си. Ето един пример:

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

Функцията по-горе приема два аргумента: извикан задължителен аргумент а и на аргументи аргумент, който ви позволява да въведете толкова аргументи, колкото са ви необходими.

Въпреки че може да приема множество аргументи, функцията по-горе може да извърши операцията по умножение само на променливите аргументи, т.е. аргументите, представени от аргументи ключова дума.

Ако искате да извършите няколко операции, трябва въведете условни изрази към вашия код, и това може бързо да се усложни.

Метод 3: Използване на декоратора за множество изпращания

Декораторът за множество изпращания е библиотека на Python, която ви позволява да дефинирате множество реализации или екземпляри на една функция въз основа на типа на нейните аргументи. Това означава, че можете да дефинирате една и съща функция с различни типове данни и да промените изцяло нейното поведение.

За да използвате декоратора на множество изпращания, изпълнете следните стъпки:

  1. Инсталирай мултидиспат във вашата Python среда:
    pip install multipledispatch
  2. Украсете вашата функция (и) с @изпращане декоратор. The @изпращане декоратор е а Python декоратор което ви позволява да реализирате многократно изпращане. Той автоматично ще изпрати подходящата функция въз основа на аргументите, които му подавате. Можете да използвате @изпращане декоратор, като следвате този модел:
    from multipledispatch import dispatch
    @dispatch(data type1, data type2, data typeX)
    defyour_function(a, b, c, x):
    pass
    # perform your operations here

Ето един пример, който използва декоратора на множество изпращания за претоварване на функции в 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']))

Кодовият фрагмент по-горе дефинира два екземпляра на добави () функция. Първата инстанция приема две цели числа като аргументи и връща тяхната сума.

Междувременно втората версия на тази функция приема цяло число и списък. Той добавя цялото число към списъка и връща новия списък.

Този подход за претоварване на функции в Python ви дава много гъвкавост, особено ако трябва да промените поведението на вашия метод. Можете да научите повече от множество документи за изпращане.

Най-добрият подход към претоварване на функции в Python

Подходът, който приемате за претоварване на функциите, трябва да зависи от това, което се опитвате да постигнете. Ако можете да изпълните задачата си, като използвате аргументи по подразбиране или променливи, тогава декораторът на множество изпращания може да е пресилен. Декораторът за множество изпращания обаче обикновено е най-добрият вариант за своята ефективност и точност.

Този декоратор предоставя чист и гъвкав начин за внедряване на претоварване на функции в Python. Тя ви позволява да дефинирате множество реализации на една функция въз основа на типа на нейните аргументи.

С този подход можете да създавате гъвкави функции, които могат да приемат различни типове параметри, без да са необходими сложни условни изрази.