Декораторы оформители: Оформление свадьбы от лучших декораторов | Свадебный декор и декораторы для свадьбы

  >>> первый = родительский (1)
>>> второй = родительский (2)

>>> первый
<функция parent.  .first_child в 0x7f599f1e2e18>

>>> второй
<родительская функция. .second_child на 0x7f599dad5268>
  

Несколько загадочный вывод просто означает, что первая переменная относится к локальной функции first_child () внутри parent () , а вторая указывает на second_child () .

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

  >>> первый ()
'Привет, я Эмма'

>>> второй ()
"Зови меня Лиам"
  

Наконец, обратите внимание, что в предыдущем примере вы выполняли внутренние функции в родительской функции, например first_child () .Однако в этом последнем примере вы не добавляли круглые скобки к внутренним функциям - first_child - при возврате. Таким образом, у вас будет ссылка на каждую функцию, которую вы могли бы вызвать в будущем. Есть смысл?

Простые декораторы

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

  def my_decorator (функция):
    def wrapper ():
        print ("Что-то происходит до вызова функции.")
        func ()
        print ("Что-то происходит после вызова функции.")
    возвратная обертка

def say_whee ():
    print ("Уф!")

say_whee = my_decorator (say_whee)
  

Можете ли вы угадать, что происходит, когда вы вызываете say_whee () ? Попробуйте:

  >>> say_whee ()
Что-то происходит до вызова функции.
Ой!
Что-то происходит после вызова функции.
  

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

Так называемое оформление происходит на следующей строке:

  say_whee = my_decorator (say_whee)
  

Фактически, имя say_whee теперь указывает на внутреннюю функцию wrapper () . Помните, что вы возвращаете оболочку как функцию, когда вызываете my_decorator (say_whee) :

  >>> say_whee
<функция my_decorator. .wrapper по адресу 0x7f3c5dfd42f0>
  

Однако wrapper () имеет ссылку на исходный say_whee () как func и вызывает эту функцию между двумя вызовами print () .

Проще говоря: декораторы оборачивают функцию, изменяя ее поведение.

Прежде чем двигаться дальше, давайте взглянем на второй пример. Поскольку wrapper () - это обычная функция Python, способ изменения функции декоратором может меняться динамически.Чтобы не беспокоить соседей, следующий пример будет запускать декорированный код только в течение дня:

  из datetime import datetime

def not_during_the_night (функция):
    def wrapper ():
        если 7 <= datetime.now (). hour <22:
            func ()
        еще:
            pass # Тише, соседи спят
    возвратная обертка

def say_whee ():
    print ("Уф!")

say_whee = not_during_the_night (say_whee)
  

Если вы попытаетесь позвонить по номеру say_whee () после отхода ко сну, ничего не произойдет:

Синтаксический сахар!

То, как вы украсили say_whee () выше, немного неуклюже.Прежде всего, вы набираете имя say_whee три раза. Кроме того, украшение немного скрывается под определением функции.

Вместо этого Python позволяет использовать декораторы более простым способом с помощью символа @ , иногда называемого синтаксисом «пирога». Следующий пример делает то же самое, что и первый пример декоратора:

  def my_decorator (функция):
    def wrapper ():
        print ("Что-то происходит до вызова функции.")
        func ()
        print ("Что-то происходит после вызова функции.")
    возвратная обертка

@my_decorator
def say_whee ():
    print ("Уф!")
  

Итак, @my_decorator - это просто более простой способ сказать say_whee = my_decorator (say_whee) . Вот как вы применяете декоратор к функции.

Повторное использование декораторов

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

Создайте файл decorators.py со следующим содержимым:

  def do_twice (func):
    def wrapper_do_twice ():
        func ()
        func ()
    вернуть wrapper_do_twice
  

Примечание: Вы можете назвать свою внутреннюю функцию как хотите, и общее имя, например wrapper () , обычно подходит. В этой статье вы увидите множество декораторов. Чтобы разделить их, мы назовем внутреннюю функцию тем же именем, что и декоратор, но с префиксом wrapper_ .

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

  из декораторов import do_twice

@do_twice
def say_whee ():
    print ("Уф!")
  

Когда вы запустите этот пример, вы должны увидеть, что исходный say_whee () выполняется дважды:

  >>> say_whee ()
Ой!
Ой!
  

Украшение функций аргументами

Допустим, у вас есть функция, которая принимает некоторые аргументы.Ты еще можешь его украсить? Давай попробуем:

  из декораторов import do_twice

@do_twice
def greet (имя):
    print (f "Привет, {имя}")
  

К сожалению, запуск этого кода вызывает ошибку:

  >>> привет ("Мир")
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: wrapper_do_twice () принимает 0 позиционных аргументов, но дан 1
  

Проблема в том, что внутренняя функция wrapper_do_twice () не принимает никаких аргументов, но ей было передано name = "World" .Вы можете исправить это, разрешив wrapper_do_twice () принимать один аргумент, но тогда он не будет работать для функции say_whee () , созданной вами ранее.

Решение состоит в том, чтобы использовать * args и ** kwargs во внутренней функции-оболочке. Затем он примет произвольное количество позиционных аргументов и аргументов ключевого слова. Перепишите decorators.py следующим образом:

  def do_twice (func):
    def wrapper_do_twice (* args, ** kwargs):
        func (* аргументы, ** kwargs)
        func (* аргументы, ** kwargs)
    вернуть wrapper_do_twice
  

Внутренняя функция wrapper_do_twice () теперь принимает любое количество аргументов и передает их функции, которую она украшает.Теперь оба ваших say_whee () и greet () примеров работают:

  >>> say_whee ()
Ой!
Ой!

>>> привет ("Мир")
Привет, мир
Привет, мир
  

Возвращение значений из декорированных функций

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

  из декораторов import do_twice

@do_twice
def return_greeting (имя):
    print ("Создание приветствия")
    return f "Привет, {имя}"
  

Попробуйте использовать:

  >>> hi_adam = return_greeting ("Адам")
Создание приветствия
Создание приветствия
>>> печать (привет_адам)
Никто
  

Ой, ваш декоратор съел возвращаемое значение из функции.

Поскольку do_twice_wrapper () не возвращает значение явно, вызов return_greeting ("Adam") завершился возвратом None .

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

  def do_twice (func):
    def wrapper_do_twice (* args, ** kwargs):
        func (* аргументы, ** kwargs)
        return func (* args, ** kwargs)
    вернуть wrapper_do_twice
  

Возвращаемое значение последнего выполнения функции:

  >>> return_greeting («Адам»)
Создание приветствия
Создание приветствия
"Привет, Адам"
  

Кто ты на самом деле?

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

  >>> печать
<встроенная функция печати>

>>> print .__ name__
'Распечатать'

>>> help (распечатать)
Справка по встроенной функции print во встроенных модулях:

Распечатать(...)
    <полное справочное сообщение>
  

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

  >>> say_whee
<функция do_twice. .wrapper_do_twice по адресу 0x7f43700e52f0>

>>> say_whee .__ name__
'wrapper_do_twice'

>>> помогите (say_whee)
Справка по функции wrapper_do_twice в декораторах модулей:

wrapper_do_twice ()
  

Однако после оформления say_whee () очень запуталась в своей идентичности. Теперь он сообщает, что это внутренняя функция wrapper_do_twice () внутри декоратора do_twice () . Хотя технически это правда, это не очень полезная информация.

Чтобы исправить это, декораторы должны использовать декоратор @ functools.wraps , который сохранит информацию об исходной функции. Обновите decorators.py снова:

  импорт функциональных средств

def do_twice (функция):
    @ functools.wraps (функция)
    def wrapper_do_twice (* args, ** kwargs):
        func (* аргументы, ** kwargs)
        return func (* args, ** kwargs)
    вернуть wrapper_do_twice
  

В декорированной функции say_whee () ничего менять не нужно:

  >>> say_whee
<функция say_whee в 0x7ff79a60f2f0>

>>> say_whee.__имя__
'say_whee'

>>> помогите (say_whee)
Справка по функции say_whee в модуле whee:

say_whee ()
  

Намного лучше! Теперь say_whee () после оформления остается самим собой.

Технические детали: Декоратор @ functools.wraps использует функцию functools.update_wrapper () для обновления специальных атрибутов, таких как __name__ и __doc__ , которые используются в интроспекции.

Несколько примеров из реального мира

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

  импорт функциональных средств

декоратор def (func):
    @ functools.wraps (функция)
    def wrapper_decorator (* args, ** kwargs):
        # Сделай что-нибудь перед
        значение = func (* аргументы, ** kwargs)
        # Сделайте что-нибудь после
        возвращаемое значение
    вернуть wrapper_decorator
  

Эта формула - хороший шаблонный шаблон для создания более сложных декораторов.

Примечание: В следующих примерах мы будем предполагать, что эти декораторы сохранены в ваших декораторах .py . Напомним, что вы можете скачать все примеры в этом руководстве.

Функции синхронизации

Начнем с создания декоратора @timer . Он будет измерять время, необходимое для выполнения функции, и выводить продолжительность на консоль. Вот код:

  импорт функциональных средств
время импорта

def таймер (функция):
    "" "Вывести время выполнения декорированной функции" ""
    @ functools.wraps (функция)
    def wrapper_timer (* args, ** kwargs):
        start_time = время.perf_counter () # 1
        значение = func (* аргументы, ** kwargs)
        end_time = time.perf_counter () # 2
        run_time = end_time - start_time # 3
        print (f "Завершено {func .__ name __! r} за {run_time: .4f} secs")
        возвращаемое значение
    вернуть wrapper_timer

@timer
def Waste_some_time (num_times):
    для _ в диапазоне (num_times):
        сумма ([i ** 2 для i в диапазоне (10000)])
  

Этот декоратор работает, сохраняя время непосредственно перед запуском функции (в строке с пометкой # 1 ) и сразу после завершения функции (в # 2 ).Время, которое занимает функция, является разницей между ними ( # 3 ). Мы используем функцию time.perf_counter () , которая хорошо измеряет временные интервалы. Вот несколько примеров таймингов:

  >>> Waste_some_time (1)
Завершено "Waste_some_time" за 0,0010 секунды

>>> Waste_some_time (999)
Завершено "Waste_some_time" за 0,3260 секунды
  

Запускай сам. Прорабатывайте код построчно. Убедитесь, что вы понимаете, как это работает.Но не волнуйтесь, если вы не поняли. Декораторы - продвинутые существа. Попробуйте на нем поспать или сделайте рисунок потока программы.

Примечание: Декоратор @timer отлично подходит, если вы просто хотите получить представление о времени выполнения ваших функций. Если вы хотите проводить более точные измерения кода, вам следует вместо этого рассмотреть модуль timeit в стандартной библиотеке. Он временно отключает сборку мусора и запускает несколько попыток, чтобы убрать шум из быстрых вызовов функций.

Код отладки

Следующий декоратор @debug будет печатать аргументы, с которыми вызывается функция, а также ее возвращаемое значение каждый раз, когда функция вызывается:

  импорт функциональных средств

def отладка (функция):
    "" "Распечатать подпись функции и возвращаемое значение" ""
    @ functools.wraps (функция)
    def wrapper_debug (* args, ** kwargs):
        args_repr = [repr (a) для a в аргументах] # 1
        kwargs_repr = [f "{k} = {v! r}" для k, v в kwargs.items ()] # 2
        подпись = "," .join (args_repr + kwargs_repr) # 3
        print (f "Вызов {func .__ name __} ({подпись})")
        значение = func (* аргументы, ** kwargs)
        print (f "{func .__ name __! r} вернула {value! r}") # 4
        возвращаемое значение
    вернуть wrapper_debug
  

Подпись создается путем объединения строковых представлений всех аргументов. Цифры в следующем списке соответствуют пронумерованным комментариям в коде:

1. Создайте список позиционных аргументов.Используйте repr () , чтобы получить красивую строку, представляющую каждый аргумент.
2. Создайте список аргументов ключевого слова. Строка f форматирует каждый аргумент как ключ = значение , где спецификатор ! R означает, что repr () используется для представления значения.
3. Списки позиционных аргументов и аргументов ключевого слова объединяются в одну строку подписи с каждым аргументом, разделенным запятой.
4. Возвращаемое значение печатается после выполнения функции.

Давайте посмотрим, как декоратор работает на практике, применив его к простой функции с одной позицией и одним аргументом ключевого слова:

  @debug
def make_greeting (имя, возраст = Нет):
    если возраст отсутствует:
        return f "Привет, {имя}!"
    еще:
        return f "Ого, {имя}! {возраст}, ты уже вырос!"
  

Обратите внимание, как декоратор @debug печатает подпись и возвращаемое значение функции make_greeting () :

  >>> make_greeting ("Бенджамин")
Вызов make_greeting ('Бенджамин')
«make_greeting» вернул «Привет, Бенджамин!»
«Привет, Бенджамин!»

>>> make_greeting ("Ричард", возраст = 112)
Вызов make_greeting ('Ричард', возраст = 112)
make_greeting вернул: «Эй, Ричард! Уже 112, вы растете! »
«Эй, Ричард! Уже 112, вы растете! »

>>> make_greeting (name = "Dorrisile", возраст = 116)
Вызов make_greeting (name = 'Dorrisile', возраст = 116)
make_greeting вернул: «Эй, Доррисиль! 116 уже, вы растете! '
«Эй, Доррисиль! 116 уже, вы растете! '
  

Этот пример может показаться не сразу полезным, поскольку декоратор @debug просто повторяет то, что вы только что написали.Он более эффективен в применении к небольшим удобным функциям, которые вы сами не вызываете напрямую.

В следующем примере вычисляется приближение к математической константе e :

  импорт математики
от декораторов импортировать отладку

# Применяем декоратор к стандартной библиотечной функции
math.factorial = отладка (math.factorial)

def приблизительно_e (условия = 18):
    вернуть сумму (1 / math.factorial (n) для n в диапазоне (условия))
  

В этом примере также показано, как можно применить декоратор к уже определенной функции.Приближение e основано на следующем расширении серии:

При вызове функции аппроксимат_е () вы можете увидеть, как работает декоратор @debug :

  >>> приблизительно_е (5)
Вызов факториала (0)
'factorial' вернул 1
Вызов факториала (1)
'factorial' вернул 1
Вызов факториала (2)
'факториал' вернул 2
Вызов факториала (3)
'factorial' вернул 6
Вызов факториала (4)
'factorial' вернул 24
2,708333333333333
  

В этом примере вы получаете хорошее приближение к истинному значению e = 2.718281828, добавив всего 5 терминов.

Код замедления

Следующий пример может показаться не очень полезным. Зачем вам замедлять свой код Python? Вероятно, наиболее распространенный вариант использования состоит в том, что вы хотите ограничить скорость функции, которая постоянно проверяет, изменился ли ресурс, например веб-страница. Декоратор @slow_down будет за одну секунду до того, как вызовет декорированную функцию:

  импорт функциональных средств
время импорта

def slow_down (func):
    "" "Спите 1 секунду перед вызовом функции" ""
    @functools.обертывания (func)
    def wrapper_slow_down (* args, ** kwargs):
        время сна (1)
        return func (* args, ** kwargs)
    вернуть wrapper_slow_down

@замедлять
обратный отсчет def (from_number):
    если from_number <1:
        print ("Взлет!")
    еще:
        печать (from_number)
        обратный отсчет (from_number - 1)
  

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

  >>> обратный отсчет (3)
3
2
1
Взлет!
  

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

Декоратор @slow_down всегда спит на одну секунду. Позже вы увидите, как управлять скоростью, передавая аргумент декоратору.

Регистрация плагинов

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

  импорт случайный
ПЛАГИНЫ = dict ()

регистр def (функция):
    "" "Зарегистрируйте функцию как плагин" ""
    ПЛАГИНЫ [func .__ name__] = func
    функция возврата

@регистр
def say_hello (имя):
    return f "Привет, {имя}"

@регистр
def be_awesome (имя):
    return f "Эй, {name}, вместе мы самые крутые!"

def randomly_greet (имя):
    приветствующий, greeter_func = random.choice (список (PLUGINS.items ()))
    print (f "Использование {greeter! r}")
    return greeter_func (имя)
  

Декоратор @register просто сохраняет ссылку на декорированную функцию в глобальном dict PLUGINS .Обратите внимание, что вам не нужно писать внутреннюю функцию или использовать @ functools.wraps в этом примере, потому что вы возвращаете исходную функцию без изменений.

Функция randomly_greet () случайным образом выбирает одну из зарегистрированных функций для использования. Обратите внимание, что словарь PLUGINS уже содержит ссылки на каждый объект функции, зарегистрированный как плагин:

  >>> ПЛАГИНЫ
{'say_hello': <функция say_hello at 0x7f768eae6730>,
 'be_awesome': <функция be_awesome at 0x7f768eae67b8>}

>>> randomly_greet («Алиса»)
Использование say_hello
"Привет, Алиса"
  

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

Если вы знакомы с globals () в Python, вы можете увидеть некоторое сходство с тем, как работает архитектура плагина. globals () дает доступ ко всем глобальным переменным в текущей области, включая ваши плагины:

  >>> глобалы ()
{..., # Множество переменных, не показанных здесь.'say_hello': <функция say_hello в 0x7f768eae6730>,
 'be_awesome': <функция be_awesome at 0x7f768eae67b8>,
 'randomly_greet': <функция randomly_greet в 0x7f768eae6840>}
  

Используя декоратор @register , вы можете создать свой собственный тщательно подобранный список интересных переменных, эффективно выбирая вручную некоторые функции из globals () .

Пользователь вошел в систему?

Последний пример перед тем, как перейти к некоторым более красивым декораторам, обычно используется при работе с веб-фреймворком.В этом примере мы используем Flask для настройки веб-страницы / secret , которая должна быть видна только пользователям, которые вошли в систему или иным образом аутентифицированы:

  из фляги import Flask, g, request, redirect, url_for
import functools
app = Flask (__ имя__)

def login_required (func):
    "" "Убедитесь, что пользователь вошел в систему, прежде чем продолжить" ""
    @ functools.wraps (функция)
    def wrapper_login_required (* args, ** kwargs):
        если g.user - None:
            return redirect (url_for ("логин", next = request.url))
        return func (* args, ** kwargs)
    вернуть wrapper_login_required

@ app.route ("/ секрет")
@login_required
def secret ():
    ...
  

Хотя это дает представление о том, как добавить аутентификацию в ваш веб-фреймворк, обычно вам не следует писать такие типы декораторов самостоятельно. Для Flask вместо этого вы можете использовать расширение Flask-Login, которое добавляет больше безопасности и функциональности.

Необычные декораторы

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

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

Классы декорирования

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

Некоторые часто используемые декораторы, даже встроенные в Python, - это @classmethod , @staticmethod и @property . Декораторы @classmethod и @staticmethod используются для определения методов внутри пространства имен класса, которые не связаны с конкретным экземпляром этого класса. Декоратор @property используется для настройки геттеров и сеттеров для атрибутов класса.Разверните поле ниже, чтобы увидеть пример использования этих декораторов.

В следующем определении класса Circle используются декораторы @classmethod , @staticmethod и @property :

  класс Круг:
    def __init __ (self, radius):
        self._radius = радиус

    @имущество
    радиус деф (self):
        "" "Получить значение радиуса" ""
        вернуть self._radius

    @ radius.setter
    радиус деф (self, value):
        "" "Установить радиус, при отрицательном значении повысить ошибку" ""
        если значение> = 0:
            себя._radius = значение
        еще:
            поднять ValueError ("Радиус должен быть положительным")

    @имущество
    область определения (self):
        "" "Вычислить площадь внутри круга" ""
        return self.pi () * self.radius ** 2

    def cyl_volume (self, height):
        "" "Вычислить объем цилиндра с кругом в качестве основания" ""
        вернуть self.area * height

    @classmethod
    def unit_circle (cls):
        "" "Заводской метод создания окружности радиусом 1" ""
        возврат cls (1)

    @staticmethod
    def pi ():
        "" "Значение π, можно использовать математику.пи вместо "" "
        возврат 3,1415926535
  

В этом классе:

• .cylinder_volume () - это обычный метод.
• .radius - свойство изменяемое: для него можно задать другое значение. Однако, определив метод установки, мы можем провести некоторое тестирование ошибок, чтобы убедиться, что он не установлен на бессмысленное отрицательное число. Доступ к свойствам осуществляется как к атрибутам без скобок.
• .area является недвижимым имуществом: недвижимость без номера .setter () нельзя изменить. Несмотря на то, что он определен как метод, его можно получить как атрибут без скобок.
• .unit_circle () - это метод класса. Он не привязан к одному конкретному экземпляру Circle . Методы класса часто используются как фабричные методы, которые могут создавать определенные экземпляры класса.
• .pi () - статический метод. На самом деле он не зависит от класса Circle , за исключением того, что является частью его пространства имен.Статические методы можно вызывать как для экземпляра, так и для класса.

Класс Circle , например, можно использовать следующим образом:

  >>> c = Круг (5)
>>> c.radius
5

>>> c.area
78,5398163375

>>> c.radius = 2
>>> c.area
12,566370614

>>> c.area = 100
AttributeError: невозможно установить атрибут

>>> c.cylinder_volume (высота = 4)
50.265482456

>>> c.radius = -1
ValueError: радиус должен быть положительным.

>>> c = Круг.unit_circle ()
>>> c.radius
1

>>> c.pi ()
3,1415926535

>>> Circle.pi ()
3,1415926535
  

Давайте определим класс, в котором мы декорируем некоторые из его методов, используя декораторы @debug и @timer , описанные ранее:

  из декораторов импорт отладки, таймер

класс TimeWaster:
    @отлаживать
    def __init __ (self, max_num):
        self.max_num = max_num

    @timer
    def Waste_time (self, num_times):
        для _ в диапазоне (num_times):
            sum ([i ** 2 for i in range (self.max_num)])
  

Используя этот класс, вы можете увидеть эффект декораторов:

  >>> tw = TimeWaster (1000)
Вызов __init __ (<объект time_waster.TimeWaster по адресу 0x7efccce03908>, 1000)
'__init__' не вернул None

>>> tw.waste_time (999)
Завершено "Waste_time" за 0,3376 секунды
  

Другой способ использования декораторов для классов - это украсить весь класс . Это, например, сделано в новом модуле dataclasses в Python 3.7:

  из классов данных импортировать класс данных

@dataclass
класс PlayingCard:
    ранг: str
    костюм: ул.
  

Смысл синтаксиса аналогичен декораторам функций. В приведенном выше примере вы могли оформить украшение, написав PlayingCard = dataclass (PlayingCard) .

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

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

  из таймера импорта декораторов

@timer
класс TimeWaster:
    def __init __ (self, max_num):
        себя.max_num = max_num

    def Waste_time (self, num_times):
        для _ в диапазоне (num_times):
            sum ([i ** 2 для i в диапазоне (self.max_num)])
  

Украшение класса не украшает его методы. Напомним, что @timer - это просто сокращение от TimeWaster = timer (TimeWaster) .

Здесь @timer измеряет только время, необходимое для создания экземпляра класса:

  >>> tw = TimeWaster (1000)
Завершил TimeWaster за 0.0000 секунд

>>> tw.waste_time (999)
>>>
  

Позже вы увидите пример определения подходящего декоратора класса, а именно @singleton , который гарантирует, что существует только один экземпляр класса.

Декораторы раскроя

Вы можете применить несколько декораторов к функции, наложив их друг на друга:

  из декораторов import debug, do_twice

@отлаживать
@do_twice
def greet (имя):
    print (f "Привет, {имя}")
  

Подумайте об этом как о выполняемых декораторах в том порядке, в котором они перечислены.Другими словами, @debug вызывает @do_twice , который вызывает greet () или debug (do_twice (greet ())) :

  >>> привет ("Ева")
Вызов приветствия ('Ева')
Привет Ева
Привет Ева
'привет' вернулся Нет
  

Обратите внимание на разницу, если мы изменим порядок @debug и @do_twice :

  из декораторов import debug, do_twice

@do_twice
@отлаживать
def greet (имя):
    print (f "Привет, {имя}")
  

В этом случае @do_twice будет применяться и к @debug :

  >>> привет ("Ева")
Вызов приветствия ('Ева')
Привет Ева
'привет' вернулся Нет
Вызов приветствия ('Ева')
Привет Ева
'привет' вернулся Нет
  

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

Иногда бывает полезно передать аргументам декораторам .Например, @do_twice можно расширить до декоратора @repeat (num_times) . Затем в качестве аргумента можно указать количество раз выполнения декорированной функции.

Это позволит вам сделать что-то вроде этого:

  @repeat (num_times = 4)
def greet (имя):
    print (f "Привет, {имя}")
  

  >>> привет ("Мир")
Привет, мир
Привет, мир
Привет, мир
Привет, мир
  

Подумайте, как вы могли бы этого добиться.

До сих пор имя, написанное после @ , относилось к объекту функции, который может быть вызван с другой функцией. Чтобы быть последовательным, вам нужно repeat (num_times = 4) , чтобы вернуть объект функции, который может действовать как декоратор. К счастью, вы уже знаете, как возвращать функции! В общем, вам нужно что-то вроде следующего:

  def повтор (num_times):
    def decorator_repeat (функция):
        ... # Создать и вернуть функцию-оболочку
    вернуть decorator_repeat
  

Обычно декоратор создает и возвращает внутреннюю функцию-оболочку, поэтому полное написание примера даст вам внутреннюю функцию внутри внутренней функции.Хотя это может показаться программным эквивалентом фильма «Начало», мы распутаем все это через мгновение:

  def повтор (num_times):
    def decorator_repeat (функция):
        @ functools.wraps (функция)
        def wrapper_repeat (* args, ** kwargs):
            для _ в диапазоне (num_times):
                значение = func (* аргументы, ** kwargs)
            возвращаемое значение
        вернуть wrapper_repeat
    вернуть decorator_repeat
  

Это выглядит немного беспорядочно, но мы поместили только тот же самый шаблон декоратора, который вы уже видели много раз, внутри одного дополнительного def , который обрабатывает аргументы декоратора.Начнем с самой внутренней функции:

  def wrapper_repeat (* args, ** kwargs):
    для _ в диапазоне (num_times):
        значение = func (* аргументы, ** kwargs)
    возвращаемое значение
  

Эта функция wrapper_repeat () принимает произвольные аргументы и возвращает значение декорированной функции func () . Эта функция-оболочка также содержит цикл, который вызывает декорированную функцию num_times раз. Это не отличается от предыдущих функций оболочки, которые вы видели, за исключением того, что в них используется параметр num_times , который должен быть предоставлен извне.

Сделав шаг вперед, вы найдете функцию декоратора:

  def decorator_repeat (func):
    @ functools.wraps (функция)
    def wrapper_repeat (* args, ** kwargs):
        ...
    вернуть wrapper_repeat
  

Опять же, decorator_repeat () выглядит точно так же, как функции декоратора, которые вы написали ранее, за исключением того, что он назван по-другому. Это потому, что мы резервируем базовое имя - repeat () - для самой внешней функции, которую будет вызывать пользователь.

Как вы уже видели, самая внешняя функция возвращает ссылку на функцию-декоратор:

  def повтор (num_times):
    def decorator_repeat (функция):
        ...
    вернуть decorator_repeat
  

В функции repeat () происходит несколько тонких вещей:

• Определение decorator_repeat () как внутреннюю функцию означает, что repeat () будет ссылаться на объект функции - decorator_repeat .Ранее мы использовали repeat без скобок для ссылки на объект функции. Добавленные круглые скобки необходимы при определении декораторов, принимающих аргументы.
• Аргумент num_times , по-видимому, не используется в самом repeat () . Но при передаче num_times создается закрытие, в котором сохраняется значение num_times до тех пор, пока оно не будет использовано позже wrapper_repeat () .

Когда все настроено, посмотрим, соответствуют ли результаты ожидаемым:

  @repeat (num_times = 4)
def greet (имя):
    print (f "Привет, {имя}")
  

  >>> привет ("Мир")
Привет, мир
Привет, мир
Привет, мир
Привет, мир
  

Как раз тот результат, к которому мы стремились.

И то и другое, но не беспокойтесь о хлебе

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

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

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

  def имя (_func = None, *, kw1 = val1, kw2 = val2, ...): # 1
    def decorator_name (func):
        ... # Создать и вернуть функцию-оболочку.

    если _func равно None:
        вернуть decorator_name # 2
    еще:
        вернуть имя_декоратора (_func) # 3
  

Здесь аргумент _func действует как маркер, отмечая, был ли декоратор вызван с аргументами или нет:

1. Если name был вызван без аргументов, декорированная функция будет передана как _func .Если он был вызван с аргументами, тогда _func будет Нет , и некоторые из аргументов ключевого слова могли быть изменены по сравнению с их значениями по умолчанию. * в списке аргументов означает, что остальные аргументы не могут быть вызваны как позиционные аргументы.
2. В этом случае декоратор был вызван с аргументами. Вернуть функцию-декоратор, которая может читать и возвращать функцию.
3. В этом случае декоратор был вызван без аргументов. Немедленно примените декоратор к функции.

Используя этот шаблон в декораторе @repeat из предыдущего раздела, вы можете написать следующее:

  def repeat (_func = None, *, num_times = 2):
    def decorator_repeat (функция):
        @ functools.wraps (функция)
        def wrapper_repeat (* args, ** kwargs):
            для _ в диапазоне (num_times):
                значение = func (* аргументы, ** kwargs)
            возвращаемое значение
        вернуть wrapper_repeat

    если _func равно None:
        вернуть decorator_repeat
    еще:
        вернуть decorator_repeat (_func)
  

Сравните это с оригинальным @repeat .Единственные изменения - это добавленный параметр _func и , если - , иначе в конце.

Рецепт 9.6 отличной поваренной книги Python показывает альтернативное решение с использованием functools.partial () .

Эти примеры показывают, что @repeat теперь можно использовать с аргументами или без них:

  @ повтор
def say_whee ():
    print ("Уф!")

@repeat (num_times = 3)
def greet (имя):
    print (f "Привет, {имя}")
  

Напомним, что значение по умолчанию num_times - 2:

  >>> say_whee ()
Ой!
Ой!

>>> привет ("Пенни")
Привет Пенни
Привет Пенни
Привет Пенни
  

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

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

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

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

  импорт функциональных средств

def count_calls (func):
    @functools.обертывания (func)
    def wrapper_count_calls (* args, ** kwargs):
        wrapper_count_calls.num_calls + = 1
        print (f "Вызов {wrapper_count_calls.num_calls} из {func .__ name __! r}")
        return func (* args, ** kwargs)
    wrapper_count_calls.num_calls = 0
    вернуть wrapper_count_calls

@count_calls
def say_whee ():
    print ("Уф!")
  

Состояние - количество вызовов функции - хранится в атрибуте функции .num_calls функции-оболочки. Вот эффект от его использования:

  >>> say_whee ()
Вызов 1 из say_whee
Ой!

>>> say_whee ()
Вызов 2 из "say_whee"
Ой!

>>> say_whee.num_calls
2
  

Классы как декораторы

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

Напомним, что синтаксис декоратора @my_decorator - это просто более простой способ сказать func = my_decorator (func) . Следовательно, если my_decorator является классом, ему необходимо принять func в качестве аргумента в своем .__init __ () метод. Кроме того, экземпляр класса должен быть вызываемым, чтобы он мог заменять декорированную функцию.

Чтобы экземпляр класса был вызываемым, вы реализуете специальный метод .__ call __ () :

  класс Счетчик:
    def __init __ (self, start = 0):
        self.count = start

    def __call __ (сам):
        self.count + = 1
        print (f "Текущее количество: {self.count}")
  

Метод .__ call __ () выполняется каждый раз, когда вы пытаетесь вызвать экземпляр класса:

  >>> counter = Counter ()
>>> счетчик ()
Текущее количество - 1

>>> счетчик ()
Текущее количество - 2

>>> счетчик.считать
2
  

Следовательно, типичная реализация класса декоратора должна реализовывать .__ init __ () и .__ call __ () :

  импорт функциональных средств

класс CountCalls:
    def __init __ (self, func):
        functools.update_wrapper (сам, функция)
        self.func = func
        self.num_calls = 0

    def __call __ (self, * args, ** kwargs):
        self.num_calls + = 1
        print (f "Вызов {self.num_calls} из {self.func .__ name __! r}")
        вернуть себя.func (* аргументы, ** kwargs)

@CountCalls
def say_whee ():
    print ("Уф!")
  

Метод .__ init __ () должен хранить ссылку на функцию и может выполнять любую другую необходимую инициализацию. Метод .__ call __ () будет вызываться вместо декорированной функции. По сути, она выполняет то же самое, что и функция wrapper () в наших предыдущих примерах. Обратите внимание, что вам нужно использовать функцию functools.update_wrapper () вместо @functools.обертывания .

Этот декоратор @CountCalls работает так же, как и в предыдущем разделе:

  >>> say_whee ()
Вызов 1 из say_whee
Ой!

>>> say_whee ()
Вызов 2 из "say_whee"
Ой!

>>> say_whee.num_calls
2
  

Больше примеров из реального мира

Мы далеко продвинулись вперед, придумав, как создавать все виды декораторов. Давайте подведем итоги и вложим наши новые знания в создание еще нескольких примеров, которые действительно могут быть полезны в реальном мире.

Код замедления, пересмотренный

Как отмечалось ранее, наша предыдущая реализация @slow_down всегда спит в течение одной секунды. Теперь вы знаете, как добавлять параметры к декораторам, поэтому давайте перепишем @slow_down , используя необязательный аргумент rate , который определяет, как долго он спит:

  импорт функциональных средств
время импорта

def slow_down (_func = None, *, rate = 1):
    "" "Спать на заданное количество секунд перед вызовом функции" ""
    def decorator_slow_down (функция):
        @functools.обертывания (func)
        def wrapper_slow_down (* args, ** kwargs):
            time.sleep (скорость)
            return func (* args, ** kwargs)
        вернуть wrapper_slow_down

    если _func равно None:
        вернуть decorator_slow_down
    еще:
        вернуть decorator_slow_down (_func)
  

Мы используем шаблон, представленный в разделе "Оба, пожалуйста, но не обращайте внимания на хлеб", чтобы сделать @slow_down вызываемым как с аргументами, так и без них. Та же самая рекурсивная функция обратного отсчета () , что и раньше, теперь спит по две секунды между каждым отсчетом:

  @slow_down (скорость = 2)
обратный отсчет def (from_number):
    если from_number <1:
        print ("Взлет!")
    еще:
        печать (from_number)
        обратный отсчет (from_number - 1)
  

Как и раньше, вы должны запустить пример самостоятельно, чтобы увидеть эффект декоратора:

  >>> обратный отсчет (3)
3
2
1
Взлет!
  

Создание синглтонов

Синглтон - это класс с одним экземпляром.В Python есть несколько синглтонов, которые вы часто используете, в том числе None , True и False . Дело в том, что None - это синглтон, который позволяет вам сравнивать None с использованием ключевого слова is , как вы видели в разделе Оба, пожалуйста:

 , если _func равно None:
    вернуть decorator_name
еще:
    вернуть имя_декоратора (_func)
  

Использование is возвращает True только для объектов, которые являются одним и тем же экземпляром.Следующий декоратор @singleton превращает класс в одноэлемент, сохраняя первый экземпляр класса как атрибут. Более поздние попытки создания экземпляра просто возвращают сохраненный экземпляр:

  импорт функциональных средств

def singleton (cls):
    "" "Сделать класс Singleton-классом (только один экземпляр)" ""
    @ functools.wraps (cls)
    def wrapper_singleton (* args, ** kwargs):
        если не wrapper_singleton.instance:
            wrapper_singleton.instance = cls (* аргументы, ** kwargs)
        вернуть wrapper_singleton.пример
    wrapper_singleton.instance = Нет
    вернуть wrapper_singleton

@singleton
класс TheOne:
    проходить
  

Как видите, этот декоратор классов следует тому же шаблону, что и декораторы наших функций. Единственное отличие состоит в том, что мы используем cls вместо func в качестве имени параметра, чтобы указать, что он предназначен для декоратора класса.

Посмотрим, работает ли:

  >>> first_one = TheOne ()
>>> another_one = TheOne ()

>>> id (first_one)
140094218762280

>>> id (другой_он)
140094218762280

>>> first_one это другой_one
Правда
  

Кажется очевидным, что first_one действительно является тем же экземпляром, что и another_one .

Примечание: Singleton-классы на самом деле не так часто используются в Python, как в других языках. Эффект синглтона обычно лучше реализовать как глобальную переменную в модуле.

Кэширование возвращаемых значений

Декораторы могут предоставить хороший механизм для кэширования и запоминания. В качестве примера рассмотрим рекурсивное определение последовательности Фибоначчи:

  из декораторов import count_calls

@count_calls
def fibonacci (число):
    если число <2:
        вернуть номер
    вернуть фибоначчи (число - 1) + фибоначчи (число - 2)
  

Хотя реализация проста, производительность во время выполнения ужасна:

  >>> фибоначчи (10)
<Большой объем вывода count_calls>
55

>>> фибоначчи.num_calls
177
  

Чтобы вычислить десятое число Фибоначчи, вам действительно нужно вычислить только предыдущие числа Фибоначчи, но эта реализация каким-то образом требует целых 177 вычислений. Быстро становится хуже: требуется 21891 вычислений для фибоначчи (20) и почти 2,7 миллиона вычислений для 30-го числа. Это потому, что код продолжает пересчитывать уже известные числа Фибоначчи.

Обычное решение - реализовать числа Фибоначчи с использованием цикла для и таблицы поиска.Однако простое кеширование вычислений тоже поможет:

  импорт функциональных средств
из декораторов импортировать count_calls

def кеш (функция):
    "" "Сохранять кеш предыдущих вызовов функций" ""
    @ functools.wraps (функция)
    def wrapper_cache (* args, ** kwargs):
        cache_key = аргументы + кортеж (kwargs.items ())
        если cache_key отсутствует в wrapper_cache.cache:
            wrapper_cache.cache [cache_key] = func (* аргументы, ** kwargs)
        вернуть wrapper_cache.cache [cache_key]
    wrapper_cache.кеш = dict ()
    вернуть wrapper_cache

@cache
@count_calls
def fibonacci (число):
    если число <2:
        вернуть номер
    вернуть фибоначчи (число - 1) + фибоначчи (число - 2)
  

Кэш работает как справочная таблица, поэтому теперь fibonacci () выполняет необходимые вычисления только один раз:

  >>> фибоначчи (10)
Вызов 1 из 'fibonacci'
...
Звоните 11 из 'fibonacci'
55

>>> фибоначчи (8)
21 год
  

Обратите внимание, что при последнем вызове fibonacci (8) никаких новых вычислений не потребовалось, поскольку восьмое число Фибоначчи уже было вычислено для fibonacci (10) .

В стандартной библиотеке кэш наименее недавно использованных (LRU) доступен как @ functools.lru_cache .

У этого декоратора больше возможностей, чем у того, что вы видели выше. Вам следует использовать @ functools.lru_cache вместо написания собственного декоратора кеша:

  импорт функциональных средств

@ functools.lru_cache (maxsize = 4)
def fibonacci (число):
    print (f "Вычисление фибоначчи ({число})")
    если число <2:
        вернуть номер
    вернуть фибоначчи (число - 1) + фибоначчи (число - 2)
  

Параметр maxsize указывает, сколько последних вызовов кэшируется.Значение по умолчанию - 128, но вы можете указать maxsize = None , чтобы кэшировать все вызовы функций. Однако имейте в виду, что это может вызвать проблемы с памятью, если вы кэшируете много больших объектов.

Вы можете использовать метод .cache_info () , чтобы увидеть, как работает кэш, и при необходимости настроить его. В нашем примере мы использовали искусственно маленький maxsize , чтобы увидеть эффект удаления элементов из кеша:

  >>> фибоначчи (10)
Вычисление фибоначчи (10)
Вычисление фибоначчи (9)
Вычисление фибоначчи (8)
Вычисление фибоначчи (7)
Вычисление фибоначчи (6)
Вычисление фибоначчи (5)
Вычисление фибоначчи (4)
Вычисление фибоначчи (3)
Вычисление фибоначчи (2)
Вычисление фибоначчи (1)
Вычисление фибоначчи (0)
55

>>> фибоначчи (8)
21 год

>>> фибоначчи (5)
Вычисление фибоначчи (5)
Вычисление фибоначчи (4)
Вычисление фибоначчи (3)
Вычисление фибоначчи (2)
Вычисление фибоначчи (1)
Вычисление фибоначчи (0)
5

>>> фибоначчи (8)
Вычисление фибоначчи (8)
Вычисление фибоначчи (7)
Вычисление фибоначчи (6)
21 год

>>> фибоначчи (5)
5

>>> фибоначчи. 3")
объем def (радиус, высота):
    вернуть математику.3 ":
    вернуть math.pi * radius ** 2 * height
  

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

Единицы становятся еще более мощными и увлекательными, когда они связаны с библиотекой, которая может конвертировать единицы. Одна такая библиотека - пинта . При установленной пинте ( pip install Pint ) вы можете, например, преобразовать объем в кубические дюймы или галлоны:

  >>> импортная пинта
>>> урег = пинта.UnitRegistry ()
>>> vol = volume (3, 5) * ureg (volume.unit)

>>> том
<Количество (141,3716694115407, 'сантиметр ** 3')>

>>> vol.to ("кубические дюймы")
<Количество (8,627028576414954, дюйм ** 3 дюйма)>

>>> vol.to ("галлоны"). m # Величина
0,0373464440537444
  

Вы также можете изменить декоратор для непосредственного возврата пинты Количество . Такое Количество получается путем умножения значения на единицу. В пинте единицы нужно искать в UnitRegistry .Реестр хранится как атрибут функции, чтобы не загромождать пространство имен:

  def use_unit (unit):
    "" "Заставить функцию вернуть количество с заданной единицей измерения" ""
    use_unit.ureg = pint.UnitRegistry ()
    def decorator_use_unit (функция):
        @ functools.wraps (функция)
        def wrapper_use_unit (* args, ** kwargs):
            значение = func (* аргументы, ** kwargs)
            возвращаемое значение * use_unit.ureg (unit)
        вернуть wrapper_use_unit
    вернуть decorator_use_unit

@use_unit («метры в секунду»)
def average_speed (расстояние, продолжительность):
    расстояние / продолжительность возврата
  

С декоратором @use_unit преобразование единиц практически не требует усилий:

  >>> bolt = average_speed (100, 9.58)
>>> болт
<Количество (10,438413361169102, "метр в секунду")>

>>> bolt.to ("км в час")
<Количество (37,578288100208766, "километр / час")>

>>> bolt.to ("миль / ч"). m # Величина
23.3500656745
  

Проверка JSON

Давайте посмотрим на последний вариант использования. Взгляните на следующий обработчик маршрута Flask:

  @ app.route ("/ grade", methods = ["POST"])
def update_grade ():
    json_data = request.get_json ()
    если "student_id" отсутствует в json_data:
        прервать (400)
    # Обновление базы данных
    вернуть "успех!"
  

Здесь мы гарантируем, что ключ student_id является частью запроса.Хотя эта проверка работает, на самом деле она не принадлежит самой функции. К тому же, возможно, есть и другие маршруты, которые используют ту же проверку. Итак, давайте оставим его СУХИМ и абстрагируем ненужную логику с помощью декоратора. Следующий декоратор @validate_json выполнит эту работу:

  из фляги импорт фляги, запрос, прерывание
import functools
app = Flask (__ имя__)

def validate_json (* ожидаемые_арги): # 1
    def decorator_validate_json (func):
        @functools.обертывания (func)
        def wrapper_validate_json (* args, ** kwargs):
            json_object = request.get_json ()
            для ожидаемого_арга в ожидаемом_арг: # 2
                если ожидаемый_арг отсутствует в json_object:
                    прервать (400)
            return func (* args, ** kwargs)
        вернуть wrapper_validate_json
    вернуть decorator_validate_json
  

В приведенном выше коде декоратор принимает список переменной длины в качестве аргумента, чтобы мы могли передать столько строковых аргументов, сколько необходимо, каждый из которых представляет ключ, используемый для проверки данных JSON:

1. Список ключей, которые должны присутствовать в JSON, передается в качестве аргументов декоратору.
2. Функция-оболочка проверяет наличие каждого ожидаемого ключа в данных JSON.

Затем обработчик маршрута может сосредоточиться на своей реальной работе - обновлении оценок - поскольку он может с уверенностью предположить, что данные JSON действительны:

  @ app.route ("/ grade", methods = ["POST"])
@validate_json ("student_id")
def update_grade ():
    json_data = request.get_json ()
    # Обновление базы данных.
    вернуть "успех!"
  

Заключение

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

• Их можно использовать повторно.
• Они могут украшать функции аргументами и возвращаемыми значениями.
• Они могут использовать @ functools.wraps , чтобы больше походить на декорированную функцию.

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

• Декорировать классы
• Декораторы гнезд
• Добавить аргументы декораторам
• Сохранить состояние в декораторах
• Использовать классы как декораторы

Вы видели, что для определения декоратора вы обычно определяете функцию, возвращающую функцию-оболочку.Функция-оболочка использует * args и ** kwargs для передачи аргументов декорированной функции. Если вы хотите, чтобы ваш декоратор также принимал аргументы, вам нужно вложить функцию-оболочку в другую функцию. В этом случае обычно получается три оператора return .

Вы можете найти код из этого руководства в Интернете.

Дополнительная литература

Если вы все еще ищете больше, в нашей книге Python Tricks есть раздел о декораторах, как и в Поваренной книге Python Дэвида Бизли и Брайана К.Джонс.

Для более глубокого погружения в историческую дискуссию о том, как декораторы должны быть реализованы в Python, см. PEP 318, а также Python Decorator Wiki. Дополнительные примеры декораторов можно найти в библиотеке декораторов Python. Декоратор Модуль может упростить создание ваших собственных декораторов, а его документация содержит дополнительные примеры декораторов.

Кроме того, мы составили для вас небольшую и милую шпаргалку по декораторам Python:

Как это использовать и зачем?

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

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

Это также называется метапрограммированием , потому что часть программы пытается изменить другую часть программы во время компиляции.

Предпосылки для изучения декораторов

Чтобы понять, что такое декораторы, мы должны сначала знать несколько основных вещей в Python.

Мы должны быть довольны тем фактом, что все в Python (да, даже классы) являются объектами. Имена, которые мы определяем, являются просто идентификаторами, привязанными к этим объектам.Функции не исключение, они тоже объекты (с атрибутами). К одному и тому же функциональному объекту могут быть привязаны разные имена.

Вот пример.

  по умолчанию сначала (сообщение):
    печать (сообщение)


первый ("Привет")

второй = первый
второй («Привет»)  

Выход

  Привет
Привет  

Когда вы запускаете код, обе функции первая и вторая дают одинаковый результат. Здесь имена первый и второй относятся к одному и тому же функциональному объекту.

Теперь все становится еще страннее.

Функции могут быть переданы в качестве аргументов другой функции.

Если вы использовали такие функции, как map , filter и reduce в Python, то вы уже об этом знаете.

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

  def inc (x):
    вернуть x + 1


def dec (x):
    вернуть x - 1


def работать (func, x):
    результат = func (x)
    вернуть результат  

Мы вызываем функцию следующим образом.

  >>> работать (inc, 3)
4
>>> работать (dec, 3)
2  

Кроме того, функция может возвращать другую функцию.

  def is_called ():
    def is_returned ():
        print ("Привет")
    возврат is_returned


new = is_called ()

# Выводит "Hello"
новый ()  

Выход

  Привет  

Здесь is_returned () - это вложенная функция, которая определяется и возвращается каждый раз, когда мы вызываем is_called () .

Наконец, мы должны знать о замыканиях в Python.

Возвращение к декораторам

Функции и методы называются вызываемыми , поскольку они могут быть вызваны.

Фактически, любой объект, реализующий специальный метод __call __ () , называется вызываемым. Итак, в самом простом смысле декоратор - это вызываемый объект, который возвращает вызываемый объект.

По сути, декоратор берет функцию, добавляет некоторую функциональность и возвращает ее.

  def make_pretty (функция):
    def inner ():
        print ("Меня украсили")
        func ()
    вернуть внутренний


def обычный ():
    print («Я обычный»)  

Когда вы запускаете следующие коды в оболочке,

  >>> обыкновенный ()
Я обычный

>>> # украсим эту обычную функцию
>>> pretty = make_pretty (обычный)
>>> довольно ()
Я был украшен
Я рядовой  

В примере, показанном выше, make_pretty () является декоратором.На этапе присвоения:

  pretty = make_pretty (обычный)  

Функция normal () была оформлена, а возвращаемой функции было присвоено имя pretty .

Мы видим, что функция декоратора добавила некоторые новые функции к исходной функции. Это похоже на упаковку подарка. Декоратор действует как обертка. Характер декорированного объекта (настоящего подарка внутри) не меняется. Но сейчас это выглядит красиво (раз уж разукрашено).

Обычно мы украшаем функцию и переназначаем ее как,

  обычный = make_pretty (обычный).  

Это обычная конструкция, и по этой причине в Python есть синтаксис, упрощающий ее.

Мы можем использовать символ @ вместе с именем функции-декоратора и разместить его над определением функции, которую нужно оформить. Например,

  @make_pretty
def обычный ():
    print («Я обычный»)  

эквивалентно

  def обычный ():
    print («Я обычный»)
обычный = make_pretty (обычный)  

Это просто синтаксический сахар для реализации декораторов.

Декорирование функций с помощью параметров

Вышеупомянутый декоратор был простым и работал только с функциями, не имеющими параметров. Что, если бы у нас были функции, принимающие такие параметры, как:

  def div (a, b):
    возврат а / б  

Эта функция имеет два параметра: a и b . Мы знаем, что это приведет к ошибке, если мы передадим b как 0.

  >>> разделить (2,5)
0,4
>>> разделить (2,0)
Отслеживание (последний вызов последний):
...
ZeroDivisionError: деление на ноль  

Теперь давайте сделаем декоратор для проверки этого случая, который вызовет ошибку.

  def smart_divide (функция):
    def внутренний (a, b):
        print («собираюсь разделить», а, «и», б)
        если b == 0:
            print ("Упс! не могу разделить")
            возвращение

        return func (a, b)
    вернуть внутренний


@smart_divide
def div (a, b):
    печать (а / б)  

Эта новая реализация вернет Нет , если возникнет состояние ошибки.

  >>> разделить (2,5)
Я разделю 2 и 5
0,4

>>> разделить (2,0)
Я делю 2 и 0
Ой! не может делить  

Таким образом мы можем декорировать функции, которые принимают параметры.

Внимательный наблюдатель заметит, что параметры вложенной функции inner () внутри декоратора такие же, как параметры функций, которые он украшает. Учитывая это, теперь мы можем создавать генеральные декораторы, работающие с любым количеством параметров.

В Python эта магия выполняется как функция (* args, ** kwargs) . Таким образом, args будет кортежем позиционных аргументов, а kwargs будет словарем аргументов ключевого слова. Примером такого декоратора будет:

  def works_for_all (функция):
    def inner (* args, ** kwargs):
        print («Я могу украсить любую функцию»)
        return func (* args, ** kwargs)
    возврат внутренний  

Создание цепочек декораторов в Python

В Python можно объединить несколько декораторов.

Это означает, что функция может быть украшена несколько раз разными (или одинаковыми) декораторами. Мы просто размещаем декораторы над желаемой функцией.

  def star (func):
    def inner (* args, ** kwargs):
        печать ("*" * 30)
        func (* аргументы, ** kwargs)
        печать ("*" * 30)
    вернуть внутренний


def процент (функция):
    def inner (* args, ** kwargs):
        печать ("%" * 30)
        func (* аргументы, ** kwargs)
        печать ("%" * 30)
    вернуть внутренний


@star
@процентов
def принтер (сообщение):
    печать (сообщение)


принтер ("Здравствуйте")  

Выход

  ******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Привет
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************  

Приведенный выше синтаксис,

  @star
@процентов
def принтер (сообщение):
    печать (сообщение)  

эквивалентно

 Принтер  def (сообщение):
    печать (сообщение)
принтер = звездочка (процент (принтер))  

Порядок, в котором мы цепляем декораторов, имеет значение.Если бы мы изменили порядок как,

  @ процент
@star
def принтер (сообщение):
    печать (сообщение)  

Результатом будет:

  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
******************************
Привет
******************************
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  

декораторов Python: от простых декораторов до множественного вложения | Салил Джайн

 // Интерфейс компонента определяет операции, которые могут быть
// изменено декораторами.интерфейс DataSource
    метод writeData (данные)
    метод readData (): данные

// Конкретные компоненты предоставляют реализации по умолчанию для
// операции. Может быть несколько вариантов этих
// классы в программе.
класс FileDataSource реализует DataSource.
    конструктор FileDataSource (имя файла) {...}

    метод writeData (data) - это
        // Записываем данные в файл.

    метод readData (): данные
        // Считываем данные из файла.

// Базовый класс декоратора следует тому же интерфейсу, что и
// другие компоненты.Основная цель этого класса -
// определяем интерфейс упаковки для всех конкретных декораторов.
// Реализация кода упаковки по умолчанию может включать
// поле для хранения обернутого компонента и средства для
// инициализируем его.
класс DataSourceDecorator реализует DataSource - это
    защищенное поле wrappee: DataSource

    конструктор DataSourceDecorator (источник: DataSource)
        wrappee = источник

    // Базовый декоратор просто делегирует всю работу
    // завернутый компонент.Дополнительные поведения могут быть добавлены в
    // бетонные декораторы.
    метод writeData (data) - это
        wrappee.writeData (данные)

    // Конкретные декораторы могут вызывать родительскую реализацию
    // операция вместо вызова обернутого объекта
    // напрямую. Такой подход упрощает расширение декоратора.
    // классы.
    метод readData (): данные
        вернуть wrappee.readData ()

// Конкретные декораторы должны вызывать методы обернутого объекта,
// но могут добавить к результату что-то свое.Декораторы
// может выполнять добавленное поведение до или после
// вызов обернутого объекта.
класс EncryptionDecorator расширяет DataSourceDecorator - это
    метод writeData (data) - это
        // 1. Зашифровать переданные данные.
        // 2. Передаем зашифрованные данные в writeData обертки
        // метод.

    метод readData (): данные
        // 1. Получить данные из метода readData обертки.
        // 2. Попробуйте его расшифровать, если он зашифрован.
        // 3. Вернуть результат.

// Вы можете обернуть объекты несколькими слоями декораторов.класс CompressionDecorator расширяет DataSourceDecorator.
    метод writeData (data) - это
        // 1. Сжать переданные данные.
        // 2. Передаем сжатые данные в writeData обертки
        // метод.

    метод readData (): данные
        // 1. Получить данные из метода readData обертки.
        // 2. Попробуйте распаковать, если он сжат.
        // 3. Вернуть результат.


// Вариант 1. Простой пример сборки декоратора.
класс Application - это
    метод dumbUsageExample () - это
        source = new FileDataSource ("somefile.dat ")
        source.writeData (salaryRecords)
        // Целевой файл был записан с простыми данными.

        source = new CompressionDecorator (исходный код)
        source.writeData (salaryRecords)
        // Целевой файл был записан со сжатым
        // данные.

        source = new EncryptionDecorator (источник)
        // Исходная переменная теперь содержит это:
        // Шифрование> Сжатие> FileDataSource
        source.writeData (salaryRecords)
        // Файл был записан сжатым и
        // зашифрованные данные.// Вариант 2. Клиентский код, использующий внешний источник данных.
// Объекты SalaryManager не знают и не заботятся о данных
// особенности хранения. Они работают с предварительно настроенными данными
// источник получен из конфигуратора приложения.
класс SalaryManager - это
    источник поля: DataSource

    конструктор SalaryManager (источник: DataSource) {...}

    метод load () - это
        вернуть source.readData ()

    метод save () - это
        source.writeData (salaryRecords)
    // ... Другие полезные методы ...


// Приложение может собирать разные стеки декораторов на
// время выполнения, в зависимости от конфигурации или среды.класс ApplicationConfigurator - это
    метод configurationExample () - это
        источник = новый FileDataSource ("salary.dat")
        если (enabledEncryption)
            source = new EncryptionDecorator (источник)
        если (включено сжатие)
            source = new CompressionDecorator (исходный код)

        logger = новый SalaryManager (источник)
        зарплата = logger.load ()
    // ...
 

 @example_decorator
def example_func (foo):
  #function body
  вернуть что-то 

 def func ():
   print ('Привет')
obj = func ()
объект
#ouput: Hello 

 def func1 (имя):
   print ('Привет', имя)

def func2 (функция)
   name = 'Джон'
   return func (имя)
 

 >>> func2 (func1)
Привет, Джон 

 def func1 ():
 def func2 (): # вложенная функция
   print ('Привет')
 return func2 () # функция возврата 

 >>> func1 ()
Привет
 

 def display ():
  печать ('Гарри')

#defining функции декоратора
def decorator_func (функция):
   def inner_func ():
      print ('Я украшен Гарри')
   вернуть inner_func ()

# Исходная функция
отображать()

# После декорирования с помощью decorator_func
decorator_func (дисплей) 

  Гарри
Я украшен Гарри  

 #defining decorator function
def decorator_func (функция):
   def inner_func ():
      print ('Я украшен Гарри')
   вернуть inner_func ()

@decorator_func
def display ():
   печать ('Гарри')
 

  Я украшен Гарри  

 @decorator_func
def display ():
   print ('Гарри') 

 def display ():
   печать ('Гарри')
display = decorator_func (дисплей) 

  def perfect_square (str_param):
  def middle_decorator (функция):
    def inner (x):
      печать (str_param, 'из', x)
      print ('Квадрат', x, 'равно')
      return func (x)
    вернуть внутренний
  вернуть middle_decorator

@perfect_square ('Найди квадрат')
def display_square (a):
  вернуть а * а
  

 >>> display_square (2)
Найдите квадрат 2
Квадрат 2 - это
4