Функция декоратора позволяет добавлять или изменять существующую функцию, не модифицируя ее структуру.
Это очень базовое объяснение функции декоратора.
Но вопрос вот почему мы должны использовать функцию декоратора, когда мы можем просто изменить функцию по мере необходимости?
Ну, это не всегда у вас одна функция, которую вы можете изменить. Предположим, у вас есть куча функций в вашем проекте, где вы хотите сделать конкретное изменение для всей функции как часть вашего требования.
Теперь было бы очень утомительно найти и модифицировать каждую функцию, а также тестировать каждого из них, чтобы убедиться, что он не нарушает ваше приложение.
Для этого у вас есть функция декоратора, используя, которую вы можете изменить его, не изменив ни один из кода внутри функции. Функция декоратора может иметь много случаев использования, но обычно используется, когда вы хотите внести незначительные изменения в существующем наборе функций.
Давайте посмотрим на простой пример:
def deco_func(val):
def wrapper():
print("Trigger")
print(val)
print("Kill")
print("------------------------------")
return wrapper
holder = deco_func("Hello Python")
print(holder)
holder()
Вывод:
.wrapper at 0x7efcdc4e8550> Trigger Hello Python Kill ------------------------------
Вышеуказанный пример возможен в Python, поскольку функции здесь рассматриваются как объекты первого класса, что означает, что функции могут быть переданы как или используются в качестве параметров/аргументов.
Вот несколько быстрых указателей, чтобы помнить:
- Функция является экземпляром типа объекта.
- Функция может быть сохранена в переменной.
- Функция может быть передана в качестве параметра.
- Функция может вернуть функцию.
Теперь давайте внесем некоторые незначительные изменения в вышеуказанном коде:
def deco_func(func):
def wrapper():
print("Trigger")
func()
print("Kill")
print("------------------------------")
return wrapper
def func1():
print("This is Function 1")
def func2():
print("This is Function 2")
def func3():
print("This is Function 3")
func1 = deco_func(func1)
func2 = deco_func(func2)
func3 = deco_func(func3)
print(func1)
func1()
func2()
func3()
Вывод:
.wrapper at 0x7f6960526820> Trigger This is Function 1 Kill ------------------------------ Trigger This is Function 2 Kill ----------------------------------- Trigger This is Function 3 Kill -----------------------------------
В приведенном выше коде мы обновили deco_func И теперь он принимает функцию как аргумент. Мы также создали три функции, которые просто распечатывают утверждение. Теперь линия func1 (func1) позволяет нам хранить deco_func который принимает параметр func1. , Все это в переменной Func1 Отказ Следовательно, теперь мы можем позвонить func1 () получить желаемые результаты. Проведя вышеуказанный кусок кода, теперь вы можете немного выяснить, как функция декоратора работает за кулисами.
Итак, всякий раз, когда вы создаете функцию декоратора, вы должны создать эту функцию/функцию/функциональность обертки. Внешняя функция принимает саму функцию в качестве аргумента, а функция внутренней обертки вызывает фактическую функцию, на которой вы делаете модификации.
Ниже приведен пример вышеуказанного кода в качестве синтаксиса функций декоратора в Python:
def deco_func(func):
def wrapper():
print("Trigger")
func()
print("Kill")
print("------------------------------")
return wrapper
@deco_func
def func1():
print("This is Function 1")
@deco_func
def func2():
print("This is Function 2")
@deco_func
def func3():
print("This is Function 3")
func1()
func2()
func3()
Теперь это являются глупыми функциями, которые просто распечатывают оператор. Что происходит, когда одна из функций требует, чтобы один или несколько параметров были пропущены и некоторые нет. Или некоторые функции возвращают значение и некоторые не имеют?
Ниже приведен пример, когда одна или несколько функций требуются и аргументы/параметры, которые необходимо пройти или одну или несколько функций, чтобы вернуть некоторое значение, когда их называют. Весь точка функций декоратора состоит в том, чтобы быть в состоянии использовать в любых функциях использования, поэтому мы используем оператор распаковки или SPLAT I.E. * args и ** kwargs :
def deco_func(func):
def wrapper(*args, **kwargs):
print("Trigger")
res = func(*args, **kwargs)
print("Kill")
print("------------------------------")
return res
return wrapper
@deco_func
def func1(val):
print("This is Function 1")
print("Function 1 value: ", val)
@deco_func
def func2(val1, val2):
print("This is Function 2")
return val1 + val2
@deco_func
def func3():
print("This is Function 3")
func1(20)
result2 = func2(45, 40)
func3()
print("Function 2 sum value: ", result2)
Вывод:
Trigger This is Function 1 Function 1 value: 20 Kill ----------------------------------- Trigger This is Function 2 Kill ----------------------------------- Trigger This is Function 3 Kill ----------------------------------- Function 2 sum value: 85
Как вы можете видеть, что оператор SPLAT помогает функции декоратора не принимать ни одного или любого количества параметров и res Переменные хранит возвращенное значение оформленной функции для обслуживания ее цели.
Итак, это все о функции декоратора. Я знаю, что это слишком много, чтобы забрать в одном чтении, но я предлагаю открыть консоль Python или ноутбуку Jupyter и следую за каждой линейкой фрагментов кода, чтобы понять функциональность, и это будет для вас кусок пирога!
Оригинал: “https://dev.to/debojyotichatterjee9/decorator-functions-in-python-1ioa”