Вложенные функции Python: назначение, синтаксис и практические сценарии

Расширенные примеры вложенных функций Python

Фабрика валидаторов с сообщением об ошибке

Внешняя функция создает валидатор для конкретного поля. Внутренняя функция замыкает min_len и field.

def make_length_validator(field, min_len):
    def validate(value):
        if len(value) < min_len:
            return f'{field}: минимум {min_len} символов'
        return None
    return validate

validate_name = make_length_validator('name', 3)
validate_code = make_length_validator('code', 5)
print(validate_name('ab'))
print(validate_code('abc'))
print(validate_name('alice'))

name: минимум 3 символов
code: минимум 5 символов
None

Каждый валидатор хранит собственные field и min_len. Такой прием полезен в формах и API.

Декоратор с параметрами через вложенные функции

Внешняя функция принимает параметры декоратора, средняя получает функцию, внутренняя выполняет вызов.

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            result = None
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print('Hello', name)
    return name

print(greet('Anna'))

Hello Anna
Hello Anna
Hello Anna
Anna

Три уровня вложенности типичны для декораторов с аргументами.

Аккумулятор с несколькими действиями и nonlocal

Внутренние функции изменяют общее состояние через nonlocal.

def make_account(balance=0):
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            return 'Недостаточно средств'
        balance -= amount
        return balance
    def get_balance():
        return balance
    return deposit, withdraw, get_balance

dep, wd, get = make_account(100)
print(dep(50))
print(wd(30))
print(get())

150
120
120

Все три функции замыкают одну ячейку balance.

Вложенная функция как ключ сортировки

Локальная функция может ссылаться на внешние параметры сортировки.

def sort_by_weight(items, weights):
    def key(item):
        return weights.get(item, 0)
    return sorted(items, key=key)

items = ['b', 'a', 'c']
weights = {'a': 10, 'b': 5, 'c': 1}
print(sort_by_weight(items, weights))

['c', 'b', 'a']

key замыкает weights и применяется только внутри sort_by_weight.

Рекурсивный поиск во вложенных словарях

Внутренняя функция рекурсивно обходит структуру и накапливает путь.

def find_key(data, target):
    def walk(node, path):
        if isinstance(node, dict):
            for k, v in node.items():
                new_path = path + [k]
                if k == target:
                    return new_path
                found = walk(v, new_path)
                if found:
                    return found
        elif isinstance(node, list):
            for index, item in enumerate(node):
                found = walk(item, path + [index])
                if found:
                    return found
        return None
    return walk(data, [])

data = {'a': {'b': [{'c': 1}]}}
print(find_key(data, 'c'))

['a', 'b', 0, 'c']

Внешняя функция задает начальный путь, а walk скрывает детали обхода.

Генератор, создаваемый вложенной функцией

Вложенная функция может быть генератором и возвращаться как итератор.

def make_range_generator(start, stop):
    def gen():
        current = start
        while current < stop:
            yield current
            current += 1
    return gen

gen = make_range_generator(2, 5)
print(list(gen()))

[2, 3, 4]

start и stop остаются доступными во время итерации.

Замыкание для обработки событий

Вложенная функция запоминает идентификатор события и не зависит от внешнего цикла.

def make_handlers(event_ids):
    handlers = []
    for event_id in event_ids:
        def handler(event_id=event_id):
            return f'Обработчик {event_id}'
        handlers.append(handler)
    return handlers

for h in make_handlers([10, 20, 30]):
    print(h())

Обработчик 10
Обработчик 20
Обработчик 30

Аргумент по умолчанию фиксирует текущее значение event_id.

Кэширование с ручным замыканием и подсчетом вызовов

Внешняя функция хранит cache и calls. Внутренняя функция обновляет их.

def memo_square():
    cache = {}
    calls = 0
    def square(n):
        nonlocal calls
        calls += 1
        if n not in cache:
            cache[n] = n * n
        return cache[n]
    def stats():
        return calls, len(cache)
    return square, stats

square, stats = memo_square()
print(square(4))
print(square(4))
print(square(5))
print(stats())

16
16
25
(3, 2)

Функция stats показывает, что вычисление square выполнялось три раза, а уникальных значений два.

Вложенная функция в методе класса

Метод может создавать локальную функцию для обработки данных и не раскрывать ее в интерфейсе класса.

class Report:
    def __init__(self, rows):
        self.rows = rows
    def total(self):
        def to_number(value):
            return float(value.replace(',', '.'))
        return sum(to_number(row['amount']) for row in self.rows)

report = Report([{'amount': '1,5'}, {'amount': '2,25'}])
print(report.total())

3.75

to_number нужна только внутри total и не засоряет пространство имен класса.