Что такое декоратор в python

Как вы видите, аргументы декорируемой функции передаются функции-обёртке, после чего с ними можно делать что угодно. Можно изменять аргументы и затем передавать их декорируемой функции, а можно оставить их как есть или вовсе забыть про них и передать что-нибудь совсем другое. То же касается возвращаемого из декорируемой функции значения, с ним тоже можно делать что угодно.

Звёздный Python: где и как используются * и **

Декораторы с аргументами

Мы также можем создавать декораторы, которые принимают аргументы. Посмотрим на пример:

def benchmark(iters): def actual_decorator(func): import time def wrapper(*args, **kwargs): total = 0 for i in range(iters): start = time.time() return_value = func(*args, **kwargs) end = time.time() total = total + (end-start) print('[*] Среднее время выполнения: <> секунд.'.format(total/iters)) return return_value return wrapper return actual_decorator @benchmark(iters=10) def fetch_webpage(url): import requests webpage = requests.get(url) return webpage.text webpage = fetch_webpage('https://google.com') print(webpage) 

Здесь мы модифицировали наш старый декоратор таким образом, чтобы он выполнял декорируемую функцию iters раз, а затем выводил среднее время выполнения. Однако чтобы добиться этого, пришлось воспользоваться природой функций в Python.

Функция benchmark() на первый взгляд может показаться декоратором, но на самом деле таковым не является. Это обычная функция, которая принимает аргумент iters , а затем возвращает декоратор. В свою очередь, он декорирует функцию fetch_webpage() . Поэтому мы использовали не выражение @benchmark , а @benchmark(iters=10) — это означает, что тут вызывается функция benchmark() (функция со скобками после неё обозначает вызов функции), после чего она возвращает сам декоратор.

Да, это может быть действительно сложно уместить в голове, поэтому держите правило:

Декоратор принимает функцию в качестве аргумента и возвращает функцию.

В нашем примере benchmark() не удовлетворяет этому условию, так как она не принимает функцию в качестве аргумента. В то время как функция actual_decorator() , которая возвращается benchmark() , является декоратором.

Объекты-декораторы

Напоследок стоит упомянуть, что не только функции, а любые вызываемые объекты могут быть декоратором. Экземпляры классов/объекты с методом __call__() тоже можно вызывать, поэтому их можно использовать в качестве декораторов. Эту функциональность можно использовать для создания декораторов, хранящих какое-то состояние. Например, вот декоратор для мемоизации:

from collections import deque class Memoized: def __init__(self, cache_size=100): self.cache_size = cache_size self.call_args_queue = deque() self.call_args_to_result = <> def __call__(self, fn): def new_func(*args, **kwargs): memoization_key = self._convert_call_arguments_to_hash(args, kwargs) if memoization_key not in self.call_args_to_result: result = fn(*args, **kwargs) self._update_cache_key_with_value(memoization_key, result) self._evict_cache_if_necessary() return self.call_args_to_result[memoization_key] return new_func def _update_cache_key_with_value(self, key, value): self.call_args_to_result[key] = value self.call_args_queue.append(key) def _evict_cache_if_necessary(self): if len(self.call_args_queue) > self.cache_size: oldest_key = self.call_args_queue.popleft() del self.call_args_to_result[oldest_key] @staticmethod def _convert_call_arguments_to_hash(args, kwargs): return hash(str(args) + str(kwargs)) @Memoized(cache_size=5) def get_not_so_random_number_with_max(max_value): import random return random.random() * max_value 

Само собой, этот декоратор нужен в основном в демонстрационных целях, в реальном приложении для подобного кеширования стоит использовать functools.lru_cache.

P.S.

Тут будут перечислены некоторые важные вещи, которые не были затронуты в статье или были затронуты вскользь. Вам может показаться, что они расходятся с тем, что было написано в статье до этого, но на самом деле это не так.

• Декораторы не обязательно должны быть функциями, это может быть любой вызываемый объект.
• Декораторы не обязаны возвращать функции, они могут возвращать что угодно. Но обычно мы хотим, чтобы декоратор вернул объект того же типа, что и декорируемый объект. Пример:>>> def decorator(func). return 'sumit'. >>> @decorator. def hello_world(). print('hello world'). >>> hello_world'sumit'
• Также декораторы могут принимать в качестве аргументов не только функции. Здесь можно почитать об этом подробнее.
• Необходимость в декораторах может быть неочевидной до написания библиотеки. Поэтому, если декораторы кажутся вам бесполезными, посмотрите на них с точки зрения разработчика библиотеки. Хорошим примером является декоратор представления в Flask.
• Также стоит обратить внимание на functools.wraps() — функцию, которая помогает сделать декорируемую функцию похожей на исходную, делая такие вещи, как сохранение doctstring исходной функции.

Заключение

Надеемся, эта статья помогла вам понять, какая «магия» лежит в основе работы декораторов.

Следите за новыми постами по любимым темам

Подпишитесь на интересующие вас теги, чтобы следить за новыми постами и быть в курсе событий.

Декораторы — Python: Функции

В программировании часто возникают задачи, когда нужно добавить поведение к уже существующим функциям или классам. Например, логирование, проверку входных данных или замер времени выполнения функции. В таких случаях использование декораторов может значительно упростить решение задачи.

В этом уроке мы рассмотрим, что такое декораторы и как их использовать, чтобы добавлять дополнительную функциональность к существующим функциям.

Что такое декораторы

Декораторы позволяют динамически изменять поведение функций и классов с помощью добавления или изменения их функциональности без изменения самого кода.

Декораторы в Python — это функции, которые принимают другую функцию в качестве аргумента, добавляют к ней некоторую дополнительную функциональность и возвращают функцию с измененным поведением.

Декораторы используются, чтобы изменять работу существующих функций или классов, добавлять новые возможности и обеспечивать безопасность.

Предположим, что у нас есть функция, которая выполняет математические операции и возвращает результат:

def add_numbers(x, y): return x + y 

Мы можем создать декоратор, который добавит к этой функции функциональность для отладки:

def debug_decorator(func): def wrapper(*args, **kwargs): print("Вызов функции:", func.__name__) print("Аргументы:", args, kwargs) result = func(*args, **kwargs) print("Результат:", result) return result return wrapper 

Этот декоратор принимает функцию в качестве аргумента и возвращает новую функцию-обертку, которая добавляет отладочные сообщения в процесс выполнения исходной функции. Чтобы применить этот декоратор к функции add_numbers , мы можем вызвать эту функцию с аргументом:

@debug_decorator def add_numbers(x, y): return x + y 

Теперь функция add_numbers будет выполняться с дополнительными отладочными сообщениями:

add_numbers(2, 3) # Вызов функции: add_numbers # Аргументы: (2, 3) <> # Результат: 5 

Также мы можем создавать несколько декораторов для одной функции, которые будут применяться последовательно:

@debug_decorator @time_decorator def add_numbers(x, y): return x + y 

В этом примере сначала применится декоратор времени выполнения, а затем отладочный декоратор.

Как связаны декораторы и замыкания

Внутренняя функция wrapper декоратора обычно ссылается на переменные из внешней функции, что создает замыкание. В примере с декоратором debug_decorator функция wrapper ссылается на func , которая была определена во внешней функции debug_decorator . Это позволяет декоратору использовать и изменять переменные из внешней функции в рамках своей логики работы, что делает декораторы более гибкими инструментами.

Также декораторы могут использовать замыкания, чтобы сохранять состояния между вызовами функции. Например, декоратор может создать замыкание, которое сохраняет информацию о том, сколько раз функция была вызвана, и возвращать это значение при каждом вызове функции.

Вот пример декоратора, который использует замыкание, чтобы отслеживать количество вызовов функции:

def count_calls(func): num_calls = 0 def wrapper(*args, **kwargs): nonlocal num_calls num_calls += 1 print(f"Функция была вызвана num_calls> раз(а)") return func(*args, **kwargs) return wrapper @count_calls def my_func(): print("Hello, world!") my_func() # Функция была вызвана 1 раз(а) # Hello, world! my_func() # Функция была вызвана 2 раз(а) # Hello, world! 

В этом примере декоратор count_calls принимает функцию func и возвращает новую функцию wrapper . Последняя отслеживает количество вызовов func и выводит сообщение при каждом вызове. Затем декоратор применяется к функции my_func . Каждый раз, когда my_func вызывается, декоратор увеличивает счетчик вызовов и выводит сообщение.

Рассмотрим еще один пример, где создадим декоратор, который измеряет время выполнения функции:

import time def timer(func): def wrapper(*args, **kwargs): start_time = time.time() result = func(*args, **kwargs) end_time = time.time() print(f"Время выполнения функции func.__name__>: end_time - start_time> сек.") return result return wrapper @timer def some_function(): time.sleep(2) some_function() # Время выполнения функции some_function: 2.000108242034912 сек. 

Здесь мы определяем декоратор timer , который принимает функцию func и возвращает функцию-обертку wrapper . Функция-обертка вызывает функцию func , замеряет время ее выполнения и сохраняет результат работы func в переменную result . Затем функция-обертка выводит время выполнения функции на экран и возвращает результат вызова функции.

В конце применяем декоратор timer к функции some_function . Когда мы вызываем функцию some_function , декоратор автоматически вызывается и выводит время выполнения функции на экран.

Выводы

Существует большое количество готовых декораторов, доступных в стандартной библиотеке Python и других библиотеках. Некоторые из них позволяют кэшировать результаты функций, обеспечивать авторизацию и безопасность, профилировать код, проверять типы данных и многое другое.

Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

• 130 курсов, 2000+ часов теории
• 1000 практических заданий в браузере
• 360 000 студентов

Наши выпускники работают в компаниях:

Декораторы в Python

Декоратор — это функция, которая принимает в качестве аргумента другую (оригинальную) функцию и изменяет ее поведение, не изменяя саму функцию. Возвращает другую функцию — замыкание.

• Замыкание обычно принимает любой набор позиционных и именованных аргументов.
• Замыкание вызывает оригинальную функцию с помощью переданных аргументов и возвращает результат в декоратор.

Пример декоратора

Для начала определим функцию net_price :

def net_price(price, tax): """ подсчитывает стоимость интернета исходя из цены и налога Аргументы: price: цена интернета tax: налог на добавленную стоимость или налог с продаж Возвращает стоимость интернета """ return price * (1 + tax) 

Функция net_price рассчитывает итоговую стоимость интернета исходя из цены и налога. Она возвращает число net_price — стоимость интернета.

Предположим, что вам нужно получить стоимость в долларах. Тогда результат 100 нужно отформатировать так: $100. Для этого можно использовать декоратор.

По определению, декоратор — это функция, которая принимает функцию в качестве аргумента:

def currency(fn): pass

И возвращает другую функцию:

def currency(fn): def wrapper(*args, **kwargs): fn(*args, **kwargs) return wrapper

Здесь функция currency() возвращает функцию wrapper() . У wrapper() следующие параметры: *args , **kwargs .

Эти параметры позволяют вызывать произволную функцию fn() с любым набором позиционных и именованных аргументов.

В этом примере функция wrapper() , по сути, напрямую выполняет функцию fn() , но не изменяет ее поведение.

Внутри функциия wrapper() вы можете вызвать fn() , получить ее результат и отформатировать результат.

Например, таким образом можно добавить знак валюты.

def currency(fn): def wrapper(*args, **kwargs): result = fn(*args, **kwargs) return f'$' return wrapper

Функция currency() — декоратор.

currency() принимает в качестве аргумента любую другую функцию и возвращает результат этой функции со знаком $ перед ним.

Чтобы использовать декоратор currency() , нужно передать функцию net_price , чтобы получить новую функцию и выполнть ее, как если бы это была исходная функция. То есть сделать вот так:

net_price = currency(net_price) print(net_price(100, 0.05)) # Вывод: $105.0

Символ @

В предыдущем примере функция currency() — декоратор. С ее помощью вы можете декорировать функцию net_price следующим образом:

net_price = currency(net_price)

Общий синтаксис такой:

функция = декоратор(функция)

В Python есть более короткий способ декорирования — с помощью символа @ :

@декоратор
def функция(): 
тело функции

То есть вместо того чтобы писать так:

net_price = currency(net_price) 

функцию net_price можно декорировать с помощью currency при создании следующим образом:

@currency def net_price(price, tax): """ подсчитывает стоимость интернета исходя из цены и налога Аргументы: price: цена интернета tax: налог на добавленную стоимость или налог с продаж Возвращает стоимость интернета """ return price * (1 + tax) 

Если все соединить вместе, получится такой код:

# декоратор def currency(fn): def wrapper(*args, **kwargs): result = fn(*args, **kwargs) return f'$' return wrapper # декорируемая функция @currency def net_price(price, tax): """ подсчитывает стоимость интернета исходя из цены и налога Аргументы: price: цена интернета tax: налог на добавленную стоимость или налог с продаж Возвращает стоимость интернета """ return price * (1 + tax) print(net_price(100, 0.05))

Документация декорируемых функций

Функция-декоратор возвращает новую функцию — функцию-обертку (wrapper).

Если вы воспользуетесь встроенной функци help() для вывода документации новых функций, вы не увидите документации для оригинальной функции. Например:

help(net_price) 

Вывод

wrapper(*args, **kwargs)
None

А если вы попытаесь вывести свойство __name__ новой функции, Python вернет имя внутренней функции, которую возвращает декоратор:

print(net_price.__name__)

Вывод

wrapper

Что это значит? Когда вы декорируете функцию, вы теряете сигнатуру и документацию оригинальной функции.

Чтобы исправить это, можэно использовать функцию wraps() из стандартного модуля functools . На самом деле wraps — тоже декоратор.

Вот, как использовать декоратор wraps :

from functools import wraps def currency(fn): @wraps(fn) def wrapper(*args, **kwargs): result = fn(*args, **kwargs) return f'$' return wrapper @currency def net_price(price, tax): """ подсчитывает стоимость интернета исходя из цены и налога Аргументы: price: цена интернета tax: налог на добавленную стоимость или налог с продаж Возвращает стоимость интернета """ return price * (1 + tax) help(net_price) print(net_price.__name__) 

Вывод

net_price(price, tax) подсчитывает стоимость интернета исходя из цены и налога 
Аргументы: 
price: цена интернета 
tax: налог на добавленную стоимость или налог с продаж 
Возвращает 
стоимость интернета
net_price

Что нужно запомнить

• Декоратор — это функция, которая принимает в качестве аргумента другую функцию и изменяет ее поведение, не изменяя саму функцию
• Для декорирования функция можно использовать символ @ .
• Чтобы сохранить документацию и название исходной функции используйте функцию wraps() из встроенного модуля functools .