Замыкания и декораторы в Python: часть 1 — замыкания20.12.2023 11:30

Впервые столкнувшись с концепцией замыканий, я мало что понял, и мне потребовалось потратить какое-то время на поиск и изучение дополнительных материалов, чтобы разобраться. Если у вас возникли те же проблемы, я постараюсь коротко, но понятно объяснить эту тему.

При написании этого туториала, я ожидаю, что читатель уже знаком с понятием «область видимости» (неплохая статья).

От простого к сложному

Замыкание (closure) или фабричная функция это функция определяемая и возвращаемая другой функцией, при этом замыкание получает доступ к значениям и объектам в области видимости «родительской» (или объемлющей) функции независимо от того из какой области видимости происходит вызов замыкания.

def outers(): 
    n = 2

    def closure(): 
        return n ** 2 
    return closure


closure_foo = outers()      # Вызываем внешнюю функцию, возвращаемая функция (замыкание) присваивается переменной 
print(closure_foo)          # .closure at 0x7f254d6fe170> 
num = closure_foo()         # Вызываем замыкание, результат присваивается переменной 
print(num)                  # 4 

# Второй вариант вызова замыкания 
print(outers()())           # 4

На примере видно, что функция closure имеет доступ к переменной n определенной в родительской функции, несмотря на то, что интерпретатор уже не находится в соответствующей зоне видимости.

Второй вариант вызова замыкания не сложно понять, если проследить эволюцию значений:

Скобки после имени функции говорят интерпретатору о том, что ее необходимо вызвать. После вызова outers(), на ее место возвращается замыкание closure, к которому добавляется оставшаяся пара скобок. Замыкание вызывается, возвращая на свое место результат.

Немного истории о замыканиях в Python

def f1():
    х = 88

    def f2(х=х):    # Запоминает X из объемлющей области видимости
                    # посредством стандартных значений
        print(х)
    f2()


f1()    # Выводит 88

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

def outers(lst):

    def closure():
        return lst[0] * 2
    return closure


x = ['a']
closure_foo = outers(x)    # Вызываем внешнюю функцию, передав ей список в качестве аргумента
print(closure_foo())       # aa

x[0] = 'b'                 # меняем единственный элемент списка
print(closure_foo())       # bb

В указанном примере содержимое списка x меняется после определения замыкания, однако результат вызова замыкания показывает, что ему доступно актуальное содержимое списка.

Однако важно понимать и другую особенность, замыкание «запоминает» именно те объекты и значения, что были доступны родительской функции в момент его определения, что позволяет использовать сразу несколько экземпляров замыканий, отличных друг от друга.

def multiplier(factor):

    def closure(x):
        return factor * x
    return closure


double = multiplier(2)
triple = multiplier(3)

print(double(5))  # 10 результат аналогичен вызову multiplier(2)(5)
print(triple(4))  # 12 результат аналогичен вызову multiplier(3)(4)

В данном примере механизм замыканий используется для определения нескольких схожих функций (double и triple), что позволяет избежать дублирования кода. Кроме того, этот пример призван продемонстрировать, что разные экземпляры одного замыкания будут иметь доступ к разным значениям из области видимости родительской функции.

Так же для создания замыкания может использоваться анонимная функция.

def modify(foo):
    return lambda x: foo(x)


"""
# результат аналогичен обычному синтаксису
def modify(foo):

    def closure(x):
        return foo(x)
    return closure
"""


to_str = modify(str)
to_str(152)              # '152'
to_bool = modify(bool)
to_bool('John Cena')     # True
to_bool('')              # False
adder = modify(lambda x: x + 1)
adder(152)               # 153

В данном примере функции modify передаются различные функции (в том числе анонимные). Полученное замыкание возвращает результат применения функции к своему аргументу.

Почти настоящий код

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

def count_calls():
    counter = 0

    def closure(print_result=False):
        nonlocal counter
        if print_result:
            return counter
        counter += 1
        return counter
    return closure


counter = count_calls()     # Вызвав функцию, получаем счетчик (замыкание)

for _ in range(5):
    counter()               # Вызываем счетчик

print(counter(True))        # Проверяем результат подсчета: 5

for _ in range(2):
    counter()

print(counter(1))           # 7

В данном примере, с использованием замыкания создается счетчик, с помощью которого можно отслеживать, например, количество вызовов некоторой функции. В примере счетчик был 5 раз вызван в первом цикле и два раза во втором. Для проверки результата подсчета функции нужно передать соответствующий аргумент и тогда данный вызов не будет учитываться при подсчете результата. Для «обнуления» счетчика необходимо получить новый экземпляр замыкания, вызвав внешнюю функцию. Одновременно можно использовать сразу несколько счетчиков.

Пример использования счетчика в учебном проекте

import random


def count_calls():
    counter = 0

    def closure(print_result=False):
        nonlocal counter
        if print_result:
            return counter
        counter += 1
        return counter
    return closure


def is_prime(num: int) -> bool:
    for divisor in range(2, int(num ** (0.5)) + 1):
        if num % divisor == 0:
            return False
    return True


def generate_num_and_check_is_prime():

    def _cast_num_to_target_type(num, prime) -> int:
        while prime != is_prime(num):
            num += 1
            counter()
        return num

    prime = True    # random.choice([True, False])
    random_num = random.randint(1, 10_000_000)
    num = _cast_num_to_target_type(random_num, prime)
    return num


attempts_max = 0
attempts_max_num = 0
for i in range(100_000):
    counter = count_calls()
    num = generate_num_and_check_is_prime()
    attempts = counter(1)
    if attempts > attempts_max:
        attempts_max = attempts
        attempts_max_num = num

print(
    f'Максимальное количество итераций ({attempts_max}) '
    f'потребовалось при генерации числа {attempts_max_num}'
)

Вместо вывода

В своей книге Марк Лутц пишет: «Разумеется, наилучшая рекомендация для большей части кода заключается в том, чтобы избегать вложения операторов def внутрь def, т.к. тогда программа станет гораздо проще — согласно духу Python плоский код, как правило, лучше вложенного». Однако важно отметить, что существует множество ситуаций, в которых от использования замыканий отказаться нельзя, так как их применение является оптимальным и предпочтительным решением. Понимание механизмов их работы является ключевым для освоения более сложных концепций, таких как декораторы, о которых будет рассказано в следующей части.

© Habrahabr.ru