Замыкания в Python: полное руководство с примерами

Что такое замыкание?

Замыкание (closure) в Python — это функция, которая сохраняет доступ к переменным из своей лексической области видимости, даже когда внешняя функция завершила выполнение. Это мощный инструмент функционального программирования, позволяющий создавать функции с “памятью” о среде, в которой они были созданы.

Основные характеристики:

1. Вложенная функция
2. Доступ к переменным из внешней области видимости
3. Возврат вложенной функции как объекта

Как работает замыкание: простой пример

def outer_function(message):
    def inner_function():
        print(message)
    return inner_function

closure = outer_function("Привет, мир!")
closure()  # Вывод: Привет, мир!

Здесь inner_function запоминает переменную message даже после завершения outer_function.

Условия создания замыкания

1. Вложенность функций: Одна функция должна быть определена внутри другой
2. Захват переменных: Вложенная функция должна использовать переменные из внешней области
3. Возврат функции: Внешняя функция возвращает вложенную как объект

Практическое применение

1. Сохранение состояния между вызовами

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

c = counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

2. Создание декораторов

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"Вызов функции {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

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

print(add(2, 3))  # Вывод: Вызов функции add \n 5

3. Фабрики функций

def power_factory(exponent):
    def power(base):
        return base ** exponent
    return power

square = power_factory(2)
cube = power_factory(3)

print(square(4))  # 16
print(cube(2))    # 8

Особенности работы с замыканиями

Ключевое слово nonlocal

Для изменения переменных из внешней области:

def accumulator(start):
    total = start
    def add(n):
        nonlocal total
        total += n
        return total
    return add

acc = accumulator(10)
print(acc(5))  # 15
print(acc(3))  # 18

Атрибуты замыкания

Исследуйте замыкание с помощью:

print(closure.__closure__)           # Кортеж ячеек
print(closure.__closure__[0].cell_contents)  # Значение переменной

Распространенные ошибки

1. Позднее связывание в циклах

Проблема:

functions = []
for i in range(3):
    def func():
        return i
    functions.append(func)

print([f() for f in functions])  # [2, 2, 2]

Решение:

functions = []
for i in range(3):
    def func(i=i):
        return i
    functions.append(func)

print([f() for f in functions])  # [0, 1, 2]

2. Изменение переменных без nonlocal

def broken_counter():
    count = 0
    def increment():
        count += 1  # Вызовет UnboundLocalError
        return count
    return increment

Замыкания vs Классы

Используйте замыкания, когда:

• Нужен простой объект с одним методом
• Требуется легковесное решение
• Хотите скрыть состояние

Используйте классы, когда:

• Нужно несколько методов
• Требуется наследование
• Необходимы сложные операции с состоянием

Продвинутые техники

Замыкания с изменяемым состоянием

def create_stack():
    items = []
    def stack(action, value=None):
        nonlocal items
        if action == "push":
            items.append(value)
        elif action == "pop":
            return items.pop()
        elif action == "show":
            return items.copy()
    return stack

s = create_stack()
s("push", 10)
s("push", 20)
print(s("pop"))  # 20

Комбинирование с lambda

def multiplier(n):
    return lambda x: x * n

times3 = multiplier(3)
print(times3(5))  # 15

Оптимизация производительности

Замыкания обычно быстрее классов благодаря:

• Отсутствию поиска в словаре атрибутов
• Более эффективному доступу к локальным переменным
• Меньшим накладным расходам

Лучшие практики

1. Используйте nonlocal для изменения переменных
2. Избегайте больших объектов в замыканиях
3. Документируйте захваченные переменные
4. Используйте замыкания для инкапсуляции
5. Избегайте цикловых зависимостей в захваченных объектах

Заключение

Замыкания в Python — мощный инструмент для:

• Создания функций с состоянием
• Реализации паттернов проектирования
• Построения абстракций высшего порядка
• Инкапсуляции данных

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