Замыкания, LEGB и nonlocal: функции как объекты первого класса

В C функция — это, по сути, указатель на код, и у неё нет собственного состояния. Если callback'у нужны данные, вы вручную собираете структуру контекста и передаёте указатель на неё в каждый вызов:

struct counter_context { int count; };

void callback(void* context) {
    struct counter_context* ctx = (struct counter_context*)context;
    ctx->count++;
    printf("Count is now %d\n", ctx->count);
}

Функция и её данные — две отдельные сущности, связанные вручную.

В Python это встроено в язык: функция, определённая внутри другой функции, автоматически «захватывает» переменные из окружающей области видимости. Такая пара «функция + захваченные переменные» называется замыканием (closure). Это прямая замена паттерна «контекст + callback», только структуру контекста и связывание генерирует сам интерпретатор.

Правило LEGB и nonlocal

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

def make_counter():
    count = 0                  # Enclosing для inner
    def inner():
        nonlocal count         # без этого — UnboundLocalError на count += 1
        count += 1
        return count
    return inner

c = make_counter()
print(c(), c(), c())  # 1 2 3

Ключевая ловушка: присваивание внутри вложенной функции по умолчанию создаёт новую локальную переменную, а не изменяет внешнюю. count += 1 без nonlocal — это попытка прочитать count как локальную переменную до того, как ей что-то присвоено, отсюда UnboundLocalError. nonlocal — явная декларация «это имя из объемлющей функции, не создавай новую локальную копию». Для чтения nonlocal не нужен.

flowchart TD
    L["Local — переменные внутри самой функции"] --> E["Enclosing — переменные объемлющих функций"]
    E --> G["Global — переменные модуля"]
    G --> B["Built-in — встроенные имена (len, range...)"]

graph TD
    subgraph MAKER["кадр make_counter()"]
        A["count = 0"]
        subgraph INNER["кадр inner()"]
            B["nonlocal count"]
            C["count += 1"]
        end
    end
    C --> B
    B -->|"то же самое имя, та же ячейка"| A

Ловушка: захват переменной цикла

funcs = []
for i in range(3):
    funcs.append(lambda: i)

print([f() for f in funcs])  # [2, 2, 2], не [0, 1, 2]!

Причина: замыкание захватывает имя i, а не его значение в момент создания лямбды. Значение ищется в момент вызова (позднее связывание, late binding), а к этому времени цикл завершён и i равно 2. Это аналог ситуации в C, когда несколько указателей ссылаются на один и тот же адрес переменной цикла — только в Python это происходит неявно, без единого &i в коде.

Исправление — зафиксировать значение как default-аргумент (он вычисляется при создании функции, то есть отдельно на каждой итерации):

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

Здесь работает механизм из предыдущего урока — «default вычисляется один раз, в момент создания функции» — только теперь он нам на пользу. Второй, более чистый способ — фабричная функция: каждый её вызов создаёт новую область видимости с собственной переменной.

validators = []
for min_val in [10, 20, 30]:
    validators.append(lambda value: value > min_val)

val_10, val_20, val_30 = validators
print(val_10(15))   # False — ожидали True: все смотрят на min_val == 30

def make_validator(min_val):
    def is_greater_than(value):
        return value > min_val      # min_val — Enclosing-переменная этого вызова
    return is_greater_than

val_10, val_20, val_30 = [make_validator(m) for m in (10, 20, 30)]
print(val_10(15), val_20(25), val_30(35))  # True True True

acc = make_accumulator()
print(acc(10))  # 10
print(acc(5))   # 15
print(acc(1))   # 16