Класс украсить: Как украсить класс на Новый год: много возможностей преображения

  >>> первый = родительский (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)
'факториал' вернул 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 "Вычисление фибоначчи ({num})")
    если число <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? - Pencil Programmer

Описание: В этом руководстве мы научимся украшать класс в Python с помощью декоратора функций и классов.

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

Он изменяет старый объект дополнительными операторами Python и возвращает ссылку на него.

Например, рассмотрим следующий класс, у него есть два метода: __init__ и display . Метод __init__ инициализирует переменную name , в то время как отображение выводит имя :

  class Student:
    def __init __ (я, имя):
        себя.name = имя
        
    def display (self):
        print ('Name:', self.name)  

Чтобы украсить этот класс в Python, мы можем либо добавить новые методы к классу, либо изменить существующие, либо сделать и то, и другое.

Кроме того, в Python есть два способа сделать это: либо с помощью декоратора функций, либо с помощью декоратора классов.

Давайте посмотрим на каждом примере по отдельности.

Украсить класс с помощью декоратора функций

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

  def mydecorator (студент):
    # определить новый метод отображения
    def newdisplay (сам):
        print ('Имя:', собственное имя)
        print ('Тема: Программирование')
    
    # заменить дисплей новым дисплеем
    student.display = newdisplay
    
    # вернуть измененного учащегося
    вернувшийся студент

@mydecorator
класс Студент:
    def __init __ (я, имя):
        self.name = имя
        
    def display (self):
        print ('Имя:', собственное имя)
        

obj = Студент ('Программист-карандаш')
объектотображать()
'' '
Имя: Программист карандаша
Тема: Программирование
'' ' 

Если бы метод display не существовал в классе, newdisplay был бы добавлен к классу как метод display .

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

Украсить класс с помощью декоратора класса

Чтобы украсить класс с помощью декоратора класса, примите ссылку на класс в качестве аргумента (в методе декоратора __init__ ), измените его код в методе __call__ и, наконец, верните экземпляр измененного класса.

  класс Mydecorator:
    # принять класс в качестве аргумента
    def __init __ (я, студент):
        self.student = студент
    
    # принять аргументы метода __init__ класса
    def __call __ (я, имя):
        # определить новый метод отображения
        def newdisplay (сам):
            print ('Имя:', собственное имя)
            print ('Тема: Python')
            
        # заменить дисплей новым дисплеем
        self.student.display = newdisplay
        
        # вернуть экземпляр класса
        obj = self.Имя ученика)
        вернуть объект

@Mydecorator
класс Студент:
    def __init __ (я, имя):
        self.name = имя
        
    def display (self):
        print ('Имя:', собственное имя)

obj = Студент ('Программист-карандаш')
obj.display ()
'' '
Имя: Программист карандаша
Тема: Python
'' ' 

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

Как украсить класс в колледже

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

1 Мыслите тематически

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

2 Используйте доски объявлений и газетные статьи на стенах класса

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

3 Разместите фотографии

Разместите картины, гобелены, одежду или предметы искусства.Разместите произведения искусства или небольшой гобелен на стенах класса, например, если студенты изучают эпоху Возрождения. Если возможно, попросите учащихся принести свои вещи. Постарайтесь продвигать культурное разнообразие в классе, используя также предметы из разных культур. Например, если вы повесите копию гобелена на английском языке XVI века на стену в классе, обязательно покажите предметы из Китая или Африки того же периода времени.

4 Разместите студенческие работы

Разместите студенческие работы, картинки или стихи в одном углу классной комнаты.Если вы отправились в Италию с другим классом, разместите эти предметы, например, на стене. Попросите учащихся принести свои фотографии, если они тоже путешествовали. Сделайте ставку на использование этих предметов в течение года. Цель состоит в том, чтобы получить как можно больше картинок, чтобы потом их проиллюстрировать другим студентам.

5 Есть раздел ежедневных котировок

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

Как украсить класс с помощью нестандартной рамы

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