Для чего нужно замыкание?

Для чего нужно замыкание?

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

Основное определение

Замыкание — это комбинация:

1. Функция (вложенная функция)
2. Окружение (переменные из внешней функции)

def outer(x):
    # x — переменная внешней функции
    
    def inner():  # inner — замыкание
        # inner "помнит" переменную x
        return x * 2
    
    return inner

# Создаём замыкание
my_closure = outer(5)

# Даже после выхода из outer, замыкание помнит x=5
print(my_closure())  # 10

# Проверяем что переменная сохранилась
print(my_closure.__closure__)  # (<cell at ...: int object at ...>,)
print(my_closure.__closure__[0].cell_contents)  # 5

Основные применения замыканий

1. Создание функций с предустановленными параметрами (Partial Application)

def multiply(x):
    def inner(y):
        return x * y
    return inner

# Создаём специализированные функции
double = multiply(2)
triple = multiply(3)
square = multiply(10)

print(double(5))    # 10
print(triple(5))    # 15
print(square(5))    # 50

Это намного удобнее, чем передавать параметры каждый раз:

# ❌ Без замыкания — нужно помнить параметр
multiply(2, 5)  # Какой параметр? Порядок легко забыть
multiply(3, 5)

# ✅ С замыканием — понятнее
double(5)  # Явно что это удвоение
triple(5)  # Явно что это утроение

2. Декораторы (самое частое использование)

Декораторы — это замыкания в действии:

def log_calls(func):
    def wrapper(*args, **kwargs):
        # wrapper — замыкание, помнит func
        print(f"Вызов {func.__name__}({args}, {kwargs})")
        result = func(*args, **kwargs)
        print(f"Результат: {result}")
        return result
    return wrapper

@log_calls
def add(x, y):
    return x + y

add(2, 3)  # Автоматически логирует вызов

Без замыканий этот синтаксис был бы невозможен.

3. Приватные переменные (инкапсуляция)

Пython не имеет истинных приватных переменных, но замыкания помогают имитировать их:

def create_counter():
    count = 0  # Приватная переменная (доступна только замыканию)
    
    def increment():
        nonlocal count  # Модифицировать переменную в замыкании
        count += 1
        return count
    
    def get_count():
        return count
    
    return increment, get_count

inc, get = create_counter()

print(inc())      # 1
print(inc())      # 2
print(get())      # 2

# count недоступна снаружи
print(count)      # NameError: name 'count' is not defined ✅

Это невозможно без замыканий:

# ❌ Без замыкания — переменная видна всем
count = 0
def increment():
    global count  # ❌ Загрязнение глобального пространства
    count += 1

4. Колбэки и асинхронное программирование

import asyncio

def create_handler(user_id):
    # Замыкание помнит user_id
    async def handle_request(request):
        user = await db.get_user(user_id)
        return user.name
    return handle_request

# Каждый обработчик помнит свой user_id
handler_1 = create_handler(1)
handler_2 = create_handler(2)

5. Factory паттерны (создание объектов)

def create_validator(min_val, max_val):
    # Замыкание помнит мин/макс значения
    def validate(value):
        if min_val <= value <= max_val:
            return True
        return False
    return validate

# Создаём специализированные валидаторы
validate_age = create_validator(0, 150)
validate_score = create_validator(0, 100)
validate_temperature = create_validator(-50, 60)

print(validate_age(25))        # True
print(validate_score(150))     # False
print(validate_temperature(-10))  # True

6. Конфигурация и инъекция зависимостей

def create_db_connector(host, port, password):
    # Замыкание помнит параметры подключения
    def query(sql):
        connection = create_connection(host, port, password)
        return connection.execute(sql)
    return query

# Разные конфигурации
local_db = create_db_connector('localhost', 5432, 'dev_pass')
prod_db = create_db_connector('prod.example.com', 5432, 'prod_pass')

local_db("SELECT * FROM users")  # Использует локальные параметры
prod_db("SELECT * FROM users")   # Использует продакшн параметры

7. Кэширование результатов (Memoization)

def memoize(func):
    cache = {}  # Замыкание помнит кэш
    
    def wrapper(n):
        if n in cache:
            print(f"Из кэша: {n}")
            return cache[n]
        
        print(f"Вычисляю: {n}")
        result = func(n)
        cache[n] = result
        return result
    
    return wrapper

@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(5))   # Вычисляю...
print(fibonacci(5))   # Из кэша: 5 ✅

Преимущества замыканий

1. Инкапсуляция данных

# ✅ Данные защищены от случайного изменения
def create_account(initial_balance):
    balance = initial_balance
    
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
    
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            raise ValueError("Недостаточно средств")
        balance -= amount
        return balance
    
    def get_balance():
        return balance
    
    return deposit, withdraw, get_balance

deposit, withdraw, get_balance = create_account(1000)
print(get_balance())      # 1000
print(deposit(500))       # 1500
print(withdraw(300))      # 1200

2. Упрощение кода

# Без замыкания — много боilerplate кода
class Multiplier:
    def __init__(self, factor):
        self.factor = factor
    
    def multiply(self, x):
        return x * self.factor

multiply_by_2 = Multiplier(2)
print(multiply_by_2.multiply(5))  # 10

# С замыканием — просто и элегантно
def multiplier(factor):
    return lambda x: x * factor

multiply_by_2 = multiplier(2)
print(multiply_by_2(5))  # 10

3. Функциональный стиль программирования

# Функция, которая возвращает функцию
def add(x):
    return lambda y: x + y

# Функция, которая принимает функцию
def apply_twice(func):
    return lambda x: func(func(x))

add_5 = add(5)
add_10_to_itself = apply_twice(add_5)
print(add_10_to_itself(0))  # 10

Важный момент: nonlocal

# ❌ Ошибка: попытка присвоить переменную из outer скопа
def outer():
    x = 10
    def inner():
        x = x + 1  # UnboundLocalError! Python думает x локальная
    inner()

# ✅ Решение: использовать nonlocal
def outer():
    x = 10
    def inner():
        nonlocal x  # Разрешить изменение x из inner
        x = x + 1
    inner()
    return x  # 11

Выводы

Замыкания нужны для:

• Создания гибких функций с запомненными параметрами
• Написания декораторов и middleware
• Инкапсуляции данных и создания приватных переменных
• Функционального программирования (map, filter, reduce)
• Обработки колбэков и асинхронного кода
• Factory паттернов для создания специализированных объектов
• Кэширования и оптимизации производительности

Без замыканий код был бы многословнее и менее гибким. Замыкания — это фундаментальная особенность современных языков программирования.