Замыкания и lambda

Вложенные функции

Функцию можно объявить внутри другой функции. Внутренняя видит переменные внешней:

def greet(name):
    def make_message():
        return f"Привет, {name}!"     # name из объемлющей функции
    return make_message()

print(greet("Аня"))

Замыкание

Если внешняя функция возвращает внутреннюю, та продолжает «помнить» переменные внешней, даже когда внешняя уже завершилась:

def make_power(exp):
    def power(base):
        return base ** exp
    return power

square = make_power(2)
cube = make_power(3)
print(square(5), cube(2))
print(square.__closure__, square.__closure__[0].cell_contents)
print(square.__code__.co_freevars)

Нажмите 👣 Пошагово: make_power завершается, её кадр исчезает, но функция power хранит ссылку на exp.

Замыкание = функция + ссылки на переменные объемлющей области (они хранятся в ячейках, __closure__). Такие переменные называются свободными (co_freevars).

Зачем замыкания

• Фабрики функций: настроить функцию заранее (make_power(2)).
• Состояние без класса: счётчики, кеши, аккумуляторы (с nonlocal).
• Декораторы — целиком построены на замыканиях (следующие уроки).
• Колбэки с контекстом: button.on_click(make_handler(user_id)).

def make_counter(start=0):
    count = start
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

clicks = make_counter()
views = make_counter(100)
print(clicks(), clicks(), views(), clicks())

Позднее связывание — ловушка

Замыкание хранит ссылку на переменную, а не на её значение. Значение читается в момент вызова:

funcs = []
for i in range(3):
    funcs.append(lambda: i)
print([f() for f in funcs])       # [2, 2, 2] — к моменту вызова i == 2

# Исправление 1: значение по умолчанию вычисляется при создании функции
funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs])

# Исправление 2: functools.partial
from functools import partial
def show(i):
    return i
funcs = [partial(show, i) for i in range(3)]
print([f() for f in funcs])

lambda

lambda параметры: выражение создаёт функцию из одного выражения:

add = lambda a, b: a + b
print(add(2, 3), add.__name__)
print(sorted(["бб", "а", "ввв"], key=lambda s: len(s)))
print(list(map(lambda x: x ** 2, [1, 2, 3])))
print((lambda x: "чёт" if x % 2 == 0 else "нечет")(7))

Ограничения: одно выражение — нет присваиваний (кроме :=), return, циклов, try; нет docstring; в трассировке ошибок имя <lambda>.

Итог

• Вложенная функция видит переменные объемлющей; если её вернуть — получится замыкание.
• Замыкание хранит ссылки на переменные в ячейках __closure__; изменять их — через nonlocal.
• Позднее связывание: значение читается при вызове; исправление — x=x или partial.
• lambda — функция из одного выражения для коротких аргументов.