# properties.py
Значения класса:
    def __init __ (сам):
        self._value1 = 0
        self._value2 = 0
        self._value3 = 0
        self._value4 = 0
        self._value5 = 0

    @имущество
    def value1 (self):
        вернуть self._value1

    @ value1.setter
    def value1 (self, value):
        self._value1 = значение, если значение% 2 == 0 иначе 0

    @имущество
    def value2 (self):
        вернуть себя._value2

    @ value2.setter
    def value2 (self, value):
        self._value2 = значение, если значение% 2 == 0, иначе 0

    @имущество
    def value3 (self):
        вернуть self._value3

    @ value3.setter
    def value3 (self, value):
        self._value3 = значение, если значение% 2 == 0, иначе 0

    @имущество
    def value4 (self):
        вернуть self._value4

    @ value4.setter
    def value4 (self, value):
        self._value4 = значение, если значение% 2 == 0, иначе 0

    @имущество
    def value5 (self):
        вернуть себя._value5

    @ value5.setter
    def value5 (self, value):
        self._value5 = значение, если значение% 2 == 0 иначе 0

my_values ​​= Значения ()
my_values.value1 = 1
my_values.value2 = 4
печать (my_values.value1)
печать (my_values.value2)
  

Как видите, здесь много дублированного кода. Можно использовать дескрипторы Python для разделения поведения всех свойств. Вы можете создать дескриптор EvenNumber и использовать его для всех свойств, например:

  # properties2.ру
класс EvenNumber:
    def __set_name __ (я, владелец, имя):
        self.name = имя

    def __get __ (self, obj, type = None) -> объект:
        return obj .__ dict __. get (self.name) или 0

    def __set __ (self, obj, value) -> Нет:
        obj .__ dict __ [self.name] = (значение, если значение% 2 == 0, иначе 0)

Значения класса:
    значение1 = Четное число ()
    значение2 = Четное число ()
    значение3 = Четное число ()
    значение4 = Четное число ()
    значение5 = Четное число ()

my_values ​​= Значения ()
my_values.value1 = 1
my_values.value2 = 4
печать (my_values.значение1)
печать (my_values.value2)
  

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

Заключение

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

Вы узнали:

• Что такое дескрипторы Python и когда их использовать
• Где дескрипторы используются во внутреннем устройстве Python
• Как реализовать свои собственные дескрипторы

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

Если у вас есть какие-либо вопросы, оставьте комментарий ниже или свяжитесь со мной в Twitter! Если вы хотите глубже погрузиться в дескрипторы Python, ознакомьтесь с официальным руководством по дескрипторам Python HowTo Guide.

Primer on Python Decorators - Real Python

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

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

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

Функции

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

  >>> def add_one (число):
... вернуть число + 1

>>> add_one (2)
3
  

В общем, функции в Python могут также иметь побочные эффекты, а не просто превращать входные данные в выходные. Функция print () является основным примером этого: она возвращает None , имея побочный эффект вывода чего-либо на консоль.Однако, чтобы понять декораторы, достаточно думать о функциях как о чем-то, что превращает заданные аргументы в значение.

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

Первоклассные предметы

В Python функции - это первоклассные объекты. Это означает, что функций можно передавать и использовать в качестве аргументов , как и любой другой объект (string, int, float, list и т. Д.).Рассмотрим следующие три функции:

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

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

def greet_bob (greeter_func):
    return greeter_func ("Боб")
  

Здесь say_hello () и be_awesome () - обычные функции, которые ожидают имя, заданное в виде строки. Однако функция greet_bob () ожидает функцию в качестве аргумента. Мы можем, например, передать ему say_hello () или функцию be_awesome () :

  >>> greet_bob (say_hello)
"Привет, Боб"

>>> greet_bob (be_awesome)
«Йо Боб, вместе мы самые крутые!»
  

Обратите внимание, что greet_bob (say_hello) относится к двум функциям, но по-разному: greet_bob () и say_hello .Функция say_hello названа без скобок. Это означает, что передается только ссылка на функцию. Функция не выполняется. С другой стороны, функция greet_bob () написана в круглых скобках, поэтому она будет вызываться как обычно.

Внутренние функции

Можно определять функции внутри других функций . Такие функции называются внутренними функциями. Вот пример функции с двумя внутренними функциями:

  def parent ():
    print ("Печать из функции parent ()")

    def first_child ():
        print ("Печать из функции first_child ()")

    def second_child ():
        print ("Печать из функции second_child ()")

    second_child ()
    Первый ребенок()
  

Что происходит, когда вы вызываете функцию parent () ? Подумайте об этом минутку.Результат будет следующим:

  >>> родитель ()
Печать из функции parent ()
Печать из функции second_child ()
Печать из функции first_child ()
  

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

Кроме того, внутренние функции не определены до вызова родительской функции.Они имеют локальную область видимости parent () : они существуют только внутри функции parent () как локальные переменные. Попробуйте вызвать first_child () . Вы должны получить ошибку:

  Traceback (последний вызов последним):
  Файл "", строка 1, в 
NameError: имя first_child не определено
  

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

Возврат функций из функций

Python также позволяет использовать функции в качестве возвращаемых значений. В следующем примере возвращается одна из внутренних функций из внешней функции parent () :

  def parent (число):
    def first_child ():
        return "Привет, я Эмма"

    def second_child ():
        return "Зови меня Лиам"

    если num == 1:
        вернуть first_child
    еще:
        return second_child
  

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

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

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

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

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

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

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

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

say_whee = my_decorator (say_whee)
  

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

  say_whee = my_decorator (say_whee)
  

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

  из 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)
  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> 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 ()
  

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

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 основано на следующем расширении ряда:

При вызове функции приближаться_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 () дает доступ ко всем глобальным переменным в текущей области, включая ваши плагины:

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

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

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

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

  из flask 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 .Ранее мы использовали повтор без скобок для ссылки на объект функции. Добавленные круглые скобки необходимы при определении декораторов, принимающих аргументы.
• Аргумент 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 теперь можно использовать с аргументами или без них:

  @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
  

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

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

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

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

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

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

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

  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.35006567
45
  

Проверка JSON

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

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

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

  из импорта колбы Flask, request, abort
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:

Свойства показателей (Алгебра 1, Показатели и экспоненциальные функции) - Mathplanet

В предыдущих главах мы рассказали о полномочиях.{30}} $$

Camtasia | ТехСмит

{{display}}

Количество: {{количество}}

{{total}}

{{display}}

Включено

{{total}}