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

Функции как объекты, правило LEGB, замыкания и `nonlocal`, собственные декораторы, декораторы с аргументами, `functools.wraps` и кэширование через `lru_cache`.

  • Продвинутый
  • 22 мин
  • 10 вопросов
  • Урок 18 из 66

В этом уроке ты узнаешь

  • Передавать и возвращать функции как объекты и объяснять, когда вычисляются значения по умолчанию
  • Создавать замыкания и правильно использовать nonlocal
  • Писать декоратор с @wraps и декоратор с аргументами
  • Кэшировать результаты с lru_cache и знать его ограничения

У тебя двадцать функций, и нужно, чтобы каждая записывала свои вызовы в журнал, повторяла попытку после сетевой ошибки или запоминала уже вычисленные результаты. Копировать одни и те же строки в двадцать мест — плохая идея. Ответ Python — декоратор: одна строка вроде @lru_cache над функцией добавляет ей новое поведение, не трогая её код. На декораторах построены Flask, FastAPI и pytest. Чтобы писать свои, нужны две идеи: функции — это объекты, а вложенные функции умеют запоминать своё окружение; это замыкания.

Функции — это объекты

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

Python
def square(x):
    return x * x

f = square
print(f(5), f.__name__)

operations = {'double': lambda x: x * 2, 'square': square}
for name, op in operations.items():
    print(name, op(7))

print(list(map(square, [1, 2, 3])))
Ожидаемый результат
25 square
double 14
square 49
[1, 4, 9]

Раз функция — объект, у неё есть и атрибуты: __name__, __doc__ и __defaults__, где хранятся значения параметров по умолчанию. Эти значения вычисляются один раз — когда выполняется def, а не при каждом вызове. Этим объясняется одна из самых известных ловушек Python:

Python
def add_item(item, basket=[]):
    basket.append(item)
    return basket

print(add_item('apple'))
print(add_item('pear'))
print(add_item.__defaults__)

def add_item_fixed(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

print(add_item_fixed('apple'), add_item_fixed('pear'))
Ожидаемый результат
['apple']
['apple', 'pear']
(['apple', 'pear'],)
['apple'] ['pear']

Чтобы читать дальше, зарегистрируйся бесплатно

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

Замыкания и nonlocal

Python ищет имя в четырёх областях в порядке LEGB: Local (текущая функция), Enclosing (объемлющие функции), Global (модуль) и Built-in (встроенные имена вроде len и print). Значит, вложенная функция может читать переменные окружающей её функции. Самое интересное: она сохраняет их и после того, как внешняя функция завершилась:

Python
def make_multiplier(factor):
    def multiply(x):
        return x * factor
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(10), triple(10))
print(double.__closure__[0].cell_contents)
Ожидаемый результат
20 30
2

Замыкание (closure)Определение

Замыкание — функция вместе с запомненными ею переменными из объемлющей области. Здесь double помнит factor = 2: значение хранится в ячейке (cell), которую можно увидеть через __closure__.

Читать переменную объемлющей функции можно свободно, но присваивание заставляет Python считать имя новой локальной переменной, и count += 1 упадёт с UnboundLocalError. Ключевое слово **nonlocal** говорит, что имя принадлежит объемлющей функции. Каждый вызов make_counter() создаёт отдельный, скрытый от всех count:

Python
def make_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

counter = make_counter()
print(counter(), counter(), counter())
other = make_counter()
print(other())
Ожидаемый результат
1 2 3
1
Python
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])

funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs])
Ожидаемый результат
[2, 2, 2]
[0, 1, 2]

Декораторы

Декоратор — функция, которая принимает функцию и возвращает новую. Обычно это обёртка (wrapper), которая что-то делает до и после вызова оригинала. Строка @log_calls над def add — всего лишь синтаксический сахар для add = log_calls(add). Обёртка принимает *args, **kwargs, поэтому подходит для функций с любой сигнатурой:

Python
def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f'calling {func.__name__}{args}')
        result = func(*args, **kwargs)
        print(f'{func.__name__} returned {result}')
        return result
    return wrapper

@log_calls
def add(a, b):
    return a + b

total = add(2, 3)
print(total, add.__name__)
Ожидаемый результат
calling add(2, 3)
add returned 5
5 wrapper

Посмотри на последнюю строку: функция теперь называется wrapper. Декоратор подменил add и потерял её имя и строку документации — это мешает отладке, документации и инструментам вроде pytest. Решение — декоратор **functools.wraps**: он копирует __name__, __doc__ и другие атрибуты исходной функции в обёртку. Обёртка может хранить и своё состояние в атрибуте:

Python
from functools import wraps

def count_calls(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        wrapper.calls += 1
        return func(*args, **kwargs)
    wrapper.calls = 0
    return wrapper

@count_calls
def greet(name):
    """Return a greeting."""
    return f'Salam, {name}!'

print(greet('Leyla'))
print(greet('Elvin'))
print(greet.calls, greet.__name__, greet.__doc__)
Ожидаемый результат
Salam, Leyla!
Salam, Elvin!
2 greet Return a greeting.

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

Как же работает @retry(times=3)? Сначала вызывается retry(times=3), и её результат — это настоящий декоратор. Значит, у декоратора с аргументами три уровня: фабрика, принимающая аргументы, декоратор, принимающий функцию, и обёртка, работающая при каждом вызове. Благодаря замыканиям обёртка видит и times, и func:

Python
from functools import wraps

def retry(times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except ConnectionError as e:
                    print(f'attempt {attempt} failed: {e}')
            raise ConnectionError(f'{func.__name__} failed {times} times')
        return wrapper
    return decorator

calls = 0
@retry(times=3)
def fetch_rates():
    global calls
    calls += 1
    if calls < 3:
        raise ConnectionError('server busy')
    return {'USD': 1.7}

print(fetch_rates())
Ожидаемый результат
attempt 1 failed: server busy
attempt 2 failed: server busy
{'USD': 1.7}
Первые два вызова неудачны, третий проходит — вызывающий код ошибок даже не видит. После трёх неудач обёртка сама возбудила бы исключение.

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

Python
def bold(func):
    return lambda: '<b>' + func() + '</b>'

def italic(func):
    return lambda: '<i>' + func() + '</i>'

@bold
@italic
def title():
    return 'Educora'

print(title())
Ожидаемый результат
<b><i>Educora</i></b>

Готовые декораторы: lru_cache

В стандартной библиотеке много полезных декораторов. **functools.lru_cache хранит результаты функции в словаре, где ключ — её аргументы; это называется мемоизацией**. Наивная рекурсивная fib(80) сделала бы около 7,6 · 10¹⁶ вызовов, а с кэшем каждое значение вычисляется только один раз:

Python
from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

print(fib(80))
print(fib.cache_info())
Ожидаемый результат
23416728348467685
CacheInfo(hits=78, misses=81, maxsize=None, currsize=81)

cache_info() показывает, что настоящих вычислений было всего 81 (misses), а на остальные 78 запросов ответил кэш (hits). maxsize=None означает неограниченный кэш; если указать число, например maxsize=128, первыми удаляются давно не использованные (LRU) записи. Начиная с Python 3.9 @functools.cache — короткая форма lru_cache(maxsize=None). В следующих уроках ты встретишь и другие встроенные декораторы: @property, @classmethod, @staticmethod, @dataclass и @contextmanager.

Задание

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

Задание · Python
from functools import wraps

def uppercase(func):
    # return a wrapper (with @wraps) that returns func's result in upper case
    ...

@uppercase
def greet(name):
    return f'salam, {name}'

print(greet('Aysel'))
print(greet.__name__)
Ожидаемый результат
SALAM, AYSEL
greet

Задание

Напиши make_accumulator(start): она возвращает функцию add(x), которая при каждом вызове прибавляет x к накопленной сумме и возвращает новую сумму. У каждого накопителя должна быть своя сумма.

Задание · Python
def make_accumulator(start=0):
    # return a function add(x) that adds x to a running total and returns it
    ...

acc = make_accumulator(100)
print(acc(10))
print(acc(5))
other = make_accumulator()
print(other(1))
Ожидаемый результат
110
115
1

Запомни

  • Функции — объекты: их можно передавать, возвращать и хранить; значения по умолчанию вычисляются один раз, при выполнении def.
  • Замыкание помнит переменные объемлющей функции; nonlocal позволяет присваивать им новые значения.
  • @deco над def f означает f = deco(f); обёртка использует *args, **kwargs и @wraps(func).
  • Декоратор с аргументами — это фабрика: @retry(times=3) означает retry(times=3)(f).
  • lru_cache мемоизирует чистые функции с хешируемыми аргументами.
Заметил ошибку или неточность в уроке?

Проверь себя

Вопросов: 10. Каждый правильный ответ приносит XP.

Вопрос 1 / 10

Вопрос 1 / 10. Что означает @timer, написанный над def load():?