Функции, замыкания, декораторы

Потому что захватывается ячейка, а не содержимое, — и это то же самое решение, что делает nonlocal возможным.

Классическая ловушка:

fs = [lambda: i for i in range(3)]
print([f() for f in fs])       # → [2, 2, 2]

fs = [lambda i=i: i for i in range(3)]
print([f() for f in fs])       # → [0, 1, 2]

Все три лямбды смотрят в одну ячейку, и к моменту вызова там лежит последнее значение. Второй вариант работает потому, что дефолт вычисляется в момент выполнения lambda — то самое раннее связывание из урока 01, здесь применённое по назначению.

Почему не сделали захват по значению. Тогда стало бы невозможно замыкание, которое меняет внешнюю переменную, — счётчики, аккумуляторы, декораторы с состоянием. Пришлось бы вводить два разных синтаксиса захвата, как в C++ ([=] и [&]). Python выбрал одно правило и явный обходной путь через дефолт.

Видно это прямо в code object:

def outer():
    n = 0
    def inner(): return n
    return inner
print(outer().__code__.co_freevars)          # → ('n',)
print(outer().__closure__[0].cell_contents)  # → 0

cell_contents — содержимое ячейки, а сама ячейка одна на всех, кто её захватил.

Работает — до первой встречи с интроспекцией, а на ней стоит половина инструментов.

Без wraps декоратор подменяет объект функции, и наружу торчит обёртка со своим именем, своей докстрокой и сигнатурой (*a, **k):

import functools, inspect

def bare(fn):
    def w(*a, **k): return fn(*a, **k)
    return w

def kept(fn):
    @functools.wraps(fn)
    def w(*a, **k): return fn(*a, **k)
    return w

@bare
def f(x: int) -> int:
    "складывает"
    return x

@kept
def g(x: int) -> int:
    "складывает"
    return x

print(f.__name__, f.__doc__, inspect.signature(f))
# → w None (*a, **k)
print(g.__name__, g.__doc__, inspect.signature(g))
# → g складывает (x: int) -> int

Что ломается по-настоящему: сообщения об ошибках и логи показывают w вместо имени функции; help() и Sphinx теряют документацию; pytest путается в фикстурах; typing.get_type_hints не находит аннотаций; кеши и диспетчеры, ключующиеся по __qualname__, склеивают разные функции в одну.

Плюс wraps сохраняет __wrapped__ — по нему inspect добирается до исходной функции сквозь любое число слоёв. Это единственная причина, по которой inspect.signature в примере выше вернула правильную сигнатуру.

Потому что кеш живёт на классе, а ключом в него попадает self.

Декоратор применяется к функции в теле класса, то есть один раз на класс, а не на инстанс. Первый аргумент метода — сам объект, значит он оказывается частью ключа и удерживается кешем ссылкой. Инстанс не умрёт, пока кеш не вытеснит его запись, а при maxsize=None — никогда.

import functools, gc, weakref

class Heavy:
    def __init__(self): self.data = bytearray(10**6)
    @functools.lru_cache(maxsize=None)
    def compute(self, k): return k * 2

h = Heavy()
r = weakref.ref(h)
h.compute(1)
del h
gc.collect()
print(r())          # → объект жив, хотя ссылок в коде нет

В проде это выглядит как сервис, у которого память растёт линейно с числом обработанных объектов, и профилировщик честно показывает их достижимыми — потому что они достижимы.

Что делать. Кешировать свободную функцию, принимающую только неизменяемые аргументы, и звать её из метода. Или functools.cached_property, если значение зависит только от объекта, — там кеш лежит в самом объекте и умирает вместе с ним. Или явный словарь на инстансе. Для методов, где ключ — только аргументы, а не состояние, подойдёт @staticmethod с lru_cache.

С 3.8 существует functools.cached_property, а в 3.12 добавили предупреждение о такой ошибке в документацию — но не в код: язык её по-прежнему не ловит.

Потому что @dec(arg) — это не особый синтаксис, а сначала вызов, потом декорирование.

Строка @retry(3) разворачивается в f = retry(3)(f). То есть retry(3) обязана вернуть декоратор, а он уже вернёт обёртку. Отсюда ровно три уровня: параметры → функция → аргументы вызова.

import functools

def retry(times):                      # 1. принимает параметры
    def decorator(fn):                 # 2. принимает функцию
        @functools.wraps(fn)
        def wrapper(*a, **k):          # 3. принимает аргументы вызова
            for attempt in range(times):
                try: return fn(*a, **k)
                except Exception:
                    if attempt == times - 1: raise
        return wrapper
    return decorator

@retry(3)
def flaky(): ...

Отсюда же самая частая ошибка — декоратор, который хочет работать и с аргументами, и без: @retry и @retry(3) одновременно. Это требует различать «мне передали функцию» и «мне передали параметр», и обычно пишется через проверку callable(первый аргумент). Читается плохо; проще не поддерживать обе формы.

Более чистая альтернатива, если вложенность мешает, — класс с __call__: параметры лежат в __init__, обёртка в __call__, уровней два. Но тогда придётся руками восстанавливать __name__ и __doc__, и на методах класс-декоратор ведёт себя иначе, потому что не является дескриптором.