У тебя двадцать функций, и нужно, чтобы каждая записывала свои вызовы в журнал, повторяла попытку после сетевой ошибки или запоминала уже вычисленные результаты. Копировать одни и те же строки в двадцать мест — плохая идея. Ответ Python — декоратор: одна строка вроде @lru_cache над функцией добавляет ей новое поведение, не трогая её код. На декораторах построены Flask, FastAPI и pytest. Чтобы писать свои, нужны две идеи: функции — это объекты, а вложенные функции умеют запоминать своё окружение; это замыкания.
Функции — это объекты
В Python функция — обычный объект, как число или список. Её можно присвоить другому имени, сохранить в словаре, передать в другую функцию и вернуть из функции. Именно поэтому работает map(square, ...): мы передаём саму функцию, не вызывая её (без скобок).
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:
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). Значит, вложенная функция может читать переменные окружающей её функции. Самое интересное: она сохраняет их и после того, как внешняя функция завершилась:
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:
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
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, поэтому подходит для функций с любой сигнатурой:
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__ и другие атрибуты исходной функции в обёртку. Обёртка может хранить и своё состояние в атрибуте:
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:
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 декоратор оборачивает функцию первым:
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¹⁶ вызовов, а с кэшем каждое значение вычисляется только один раз:
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, чтобы функция сохранила своё имя.
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 к накопленной сумме и возвращает новую сумму. У каждого накопителя должна быть своя сумма.
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мемоизирует чистые функции с хешируемыми аргументами.