что такое замыкание python
Замыкания в функциях Python.
Сохранение локального состояния функцией.
Функции могут иметь вложенные функции, родительские функции могут возвращать внутренние функции, в свою очередь внутренние функции могут также сохранять и переносить с собой некоторые состояния родительской функции.
Функции, которые делают это, называются лексическими замыканиями или просто замыканиями. Замыкание запоминает значения из своей заключительной лексической области, даже если поток программы больше не находится в этой области.
На практике это означает, что функции могут не только возвращать поведение, но и предварительно настраивать его. Вот еще один простой пример, иллюстрирующий эту идею:
Как Python связывает переменные в замыканиях?
Что бы избежать нежелательного поведения при использований замыканий в программах, разберем один проблемный случай, на котором станет понятно как Python связывает переменные в замыканиях.
Такое поведение происходит из-за позднего связывания в Python, согласно которому значения переменных, используемых в замыканиях, просматриваются (извлекаются из локальной области функции) во время вызова внутренней функции. Таким образом, в приведенном выше коде всякий раз, когда вызывается какая-либо из возвращаемых функций, значение i ищется в окружающей области во время ее вызова, а к тому времени цикл for i in range(5) завершен, следовательно переменной i уже назначено его окончательное значение 4. НЕ ПОПАДАЙТЕСЬ!
Замыкания, это средство для построения иерархических данных.
Вот как определяется “свойство замыкания” в книге “Структура и интерпретация компьютерных программ” Айбельсона Х., Сассмана Д.Д.: “В общем случае, операция комбинирования объектов данных обладает свойством замыкания в том случае, если результаты соединения объектов с помощью этой операции сами могут соединяться этой же операцией”.
Это свойство позволяет строить иерархические структуры данных. Покажем это на примере кортежей в Python.
Передав в качестве аргументов числа, получим простой кортеж.
Эту операцию можно производить не только над числами, но и над сущностями, ей же порожденными.
Избегайте рекурсии в Python: вспомните о замыкании
Вот что получается, когда кандидат наук заморачивается рекурсией…
Раньше я был программистом, которому очень нравились рекурсивные функции, просто потому, что это очень круто, с их помощью можно продемонстрировать свои навыки программирования и интеллект. Однако в большинстве случаев рекурсивные функции имеют высокую сложность, поэтому нам следует избегать их использования.
Одно из решений намного лучше – по возможности задействовать динамическое планирование: вероятно, оно – лучший способ решать задачи, которые можно разделить на подзадачи. Одна из моих предыдущих статей демонстрирует мощь динамического планирования.
Здесь я представлю ещё одну технику Python, которую можно использовать как альтернативу рекурсивной функции. Эта техника не превосходит динамическое планирование, но она гораздо проще, с точки зрения мышления. Другими словами, иногда сложно заставить динамическое планирование работать из-за абстракции идей, тогда как проще воспользоваться замыканием.
Что такое замыкание в Python?
Прежде всего позвольте мне на простом примере продемонстрировать, что такое замыкание в Python. Посмотрите на функцию ниже:
Здесь вложенная функция – это и есть замыкание. Если проверить возвращаемое значение внешней функции, окажется, что оно является функцией.
Что делает замыкание? Поскольку оно вернуло функцию, мы, конечно, можем запустить её.
Видно, что внутренняя функция может обращаться к переменным, определённым во внешней функции. Обычно замыкание не применяется так, как показано выше, потому что это некрасиво. Мы обычно хотим определить другую функцию, чтобы удерживать функцию, которая возвращается замыканием.
Следовательно, мы также можем сказать, что в замыкании Python мы определили функцию, которая определяет функции.
Доступ к внешним переменным из внутренней функции
Как тогда мы можем использовать замыкание, чтобы заменить им рекурсию? Не торопитесь. Давайте посмотрим на другую проблему, связанную с доступом к внешним переменным из внутренней функции.
В замыкании выше мы хотим добавить 1 к внешней переменной x во внутренней функции. Это работает неочевидным образом.
Фибоначчи с помощью замыкания
Фибоначчи обычно используется как пример рекурсивных функций, как рекурсивный «Hello, World!». Напомню, о чём речь. Последовательность Фибоначчи – это ряд чисел, каждое следующее число – это сумма двух чисел перед ним. Первые два числа, X₀ и X₁, особенные. Это 0 и 1. Значит, X₂, как упоминалось выше, – это сумма X₀ и X₁. И так далее [сократил].
Рекурсивная функция требует, чтобы мы мыслили в обратном порядке, от «текущей ситуации» к «предыдущей ситуации» и, в конечном счёте, об условии завершения рекурсии. При помощи замыкания можно думать о проблеме более естественным образом. В коде ниже показана реализация Фибоначчи через замыкание:
Мы знаем, что Фибоначчи начинается с двух специальных чисел X₀ = 0 и X₁ = 1, поэтому просто определяем их во внешней функции. Затем внутренняя функция get_next_number просто возвращает сумму двух чисел, полученных от внешней функции. Кроме того, не забудьте обновить X₀ и X₁ с помощью X₁ и X₂. Код можно упростить:
Этот код сначала обновляет две переменные, а затем возвращает вторую, что эквивалентно коду выше. Затем мы можем использовать это замыкание, чтобы вычислить числа Фибоначчи. Например, вот последовательность Фибоначчи до двадцатого.
Сравниваем производительность
А как насчёт производительности? Давайте сравним! Сначала реализуем функцию Фибоначчи рекурсивно:
Функцию можно проверить: вывести 20-е число последовательности Фибоначчи.
Теперь напишем то же самое с замыканием.
2,79 мс против 2,75 мкс. Замыкание в 1000 раз быстрее рекурсии! Интуитивно понятно: причина в том, что все временные значения для каждого уровня рекурсии хранятся в памяти отдельно, тогда как замыкание каждый раз обновляет одни и те же переменные. Кроме того, существует ограничение глубины рекурсии. В случае замыкания, поскольку это в основном цикл for, никаких ограничений нет. Вот пример получения 1000-го числа Фибоначчи.
Это действительно огромное число, но метод замыкания может завершить вычисление примерно за 100 мкс, тогда как рекурсия сталкивается со своими ограничениями.
Как ещё применять замыкание?
Замыкания Python очень полезны не только как замена рекурсивных функций. В некоторых случаях оно также может заменить классы Python на решение изящнее, особенно когда в классе не слишком много атрибутов и методов. Предположим, у нас есть словарь студентов с их экзаменационными отметками.
Хочется иметь несколько функций, которые помогут нам фильтровать студентов по оценкам, помещать их в разные классы. Однако со временем критерии могут измениться. В этом случае можно определить замыкание Python, вот так:
Замыкание определяет функцию, которая, в свою очередь, определяет другие функции на основе динамически передаваемых параметров. Мы передадим нижнюю и верхнюю границы класса оценки, и замыкание вернёт нам функцию, которая отфильтрует студентов.
Код выше даёт нам 4 функции, которые классифицируют учащегося по соответствующим классам на основе указанных нами границ. Обратите внимание, что мы можем изменить границу в любой момент, чтобы выполнить другую функцию или переопределить текущие функции оценки. Давайте теперь проверим функции.
Выглядит очень аккуратно! Но имейте в виду, что в более сложных случаях всё равно нужно определять классы.
Что в итоге?
В этой статье я представил технику, называемую замыканием, в Python. Её можно применить, чтобы переписать рекурсивные функций и в большинстве случаев значительно превзойти их.
В самом деле, замыкание может оказаться не лучшим решением некоторых проблем, с точки зрения производительности, особенно когда применимо динамическое планирование. Однако намного проще работать с ним в плане мышления. Иногда динамическое планирование излишне: например, когда не так уж важна производительность, может быть достаточно замыкания.
Замыкание также может использоваться, чтобы заменить некоторые юзкейсы, для удовлетворения которым мы можем захотеть реализовать класс. В таких случаях замыкание выглядит аккуратнее и элегантнее.
Узнайте подробности, как получить Level Up по навыкам и зарплате или востребованную профессию с нуля, пройдя онлайн-курсы SkillFactory со скидкой 40% и промокодом HABR, который даст еще +10% скидки на обучение:
5 важных аспектов замыканий в Python
Sep 15 · 6 min read
Замыкания не являются уникальным явлением Python и встречаются во многих других языках. При этом несмотря на то, что большинство начинающих разработчиков об этой концепции слышали, они не знают, что конкретно они из себя представляют и как используются. В данной статье я подчеркну наиболее важную информацию о замыканиях в Python, чтобы упростить для вас их освоение.
1. Внутренние и внешние функции
Как я уже отмечал, замыкания есть во многих языках программирования, а в Википедии им дано следующее определение:
Это определение для многих п о кажется слишком техническим и не относится конкретно к Python. Чтобы помочь вам понять этот принцип, я выражу его более просто: замыкание — это внутренняя функция, создаваемая во внешней функции и использующая ее переменные. Она возвращается внешней функцией в виде ее выходного значения. Не слишком технически? Думаю, слишком. Лучше всего показать на примере. Начнем со следующего фрагмента кода.
В этом коде double multiplier и triple_multiplier представляют два замыкания, так как соответствуют их определению:
Привязка нелокальных переменных является, пожалуй, наиболее мутной частью темы замыканий. Именно этот процесс мы и разберем далее.
2. Локальные и нелокальные переменные
При работе с функциями мы знаем, что внутри них можно использовать любые передаваемые параметры, которые называются локальными переменными. По существу, функция формирует локальную область видимости, ограничивающую доступ к ее переменным.
Помимо отличия между локальными и нелокальными переменными, некоторые из вас могли слышать о глобальных переменных, которые определяются на уровне модуля. В этом случае обычно фигурируют такие термины, как глобальная и встроенная области.
Как вы могли заметить, то с позиции внутренней функции мы называем процесс обращения к локальным переменным внешней функции привязкой нелокальных переменных. Использование слова “привязка” в этом случае примечательно. Что конкретно оно значит? Разберем это далее.
3. Привязка нелокальных переменных
Привязка нелокальных переменных в ряде других языков называется захватом нелокальных переменных, что передает характеристику замыканий. Можно просто представить себе этот процесс как “владение” используемыми нелокальными переменными внутренней функцией. Рассмотрим это на примере:
Причина в том, что замыкания уже установили привязку нелокальной переменной, которую используют. Иначе говоря, у них есть копия этой привязанной переменной. Чтобы пронаблюдать эту особенность, рассмотрим несколько специальных проверочных функций:
__code__.co_freevars позволяет проверить имя привязки нелокальной переменной для замыканий, а __closure__[0].cell_contents уточняет значение привязанной нелокальной переменной. Вам не обязательно знать подробности этих функций, так как они являются просто внутренними реализациями.
Эту информацию важно знать, потому что замыкания получают собственные копии нелокальных переменных путем привязки, что позволяет им продолжать работать даже после удаления внешней функции.
4. Ключевое слово Nonlocal и исключение Unboundlocalerror
5. Почему замыкания?
Мы рассмотрели, чем являются замыкания, но вас может заинтересовать, зачем вообще они нужны? Одно из наиболее распространенных применений состоит в создании функций-декораторов. Несмотря на то, что замыкания вы можете и не знать, я уверен, что о декораторах вы слышали наверняка. В Python декораторы — это функции, которые изменяют поведение других функций, не влияя на их алгоритмы.
Функция simple_logger является декоратором, использование которого подразумевает наличие перед именем символа @ и размещение самого его над декорируемой функцией. При вызове функции hello_world произойдет следующее:
Суть в том, что декорированная функция по факту является замыканием. В процессе декорации внутренне происходит два этапа:
Чтобы убедиться в том, что hello_world действительно является замыканием, можно снова выполнить проверку:
Заключение
В этой статье мы рассмотрели пять наиболее важных аспектов замыканий. Вот их краткий обзор:
Функции в Python: замыкания
В этой статье мы рассмотрим замыкания (closures) в Python: как их определять и когда их стоит использовать.
Нелокальная переменная во вложенной функции
Прежде чем перейти к тому, что такое замыкание, мы должны сначала понять, что такое вложенная функция и нелокальная (nonlocal) переменная.
Функция, определенная внутри другой функции, называется вложенной функцией. Вложенные функции могут получать доступ к переменным из локальной области видимости объемлющих функций (enclosing scope).
В Python нелокальные переменные по умолчанию доступны только для чтения. Если нам необходимо их модифицировать, то мы должны объявить их явно как нелокальные (используя ключевое слово nonlocal).
Ниже приведен пример вложенной функции, обращающейся к нелокальной переменной.
Определение замыкания
Что произойдет в приведенном выше примере, если последняя строка функции print_msg() вернет функцию printer() вместо ее вызова? Определим данную функцию следующим образом:
Этот метод, с помощью которого некоторые данные (в данном случае строка «Hello») прикрепляются к некоторому коду, в Python называется замыканием.
Ссылка на переменную объемлющей функции действительна, даже когда объемлющая функция закончила работу, и переменная вышла из области видимости или сама функция удаляется из текущего пространства имен.
Попробуйте выполнить следующее, чтобы увидеть результат:
Здесь возвращаемая функция все еще работает, даже если исходная функция была удалена.
Когда мы имеем дело с замыканием?
Как видно из приведенного выше примера, мы имеем дело с замыканием в Python, когда вложенная функция ссылается на значение из локальной области видимости объемлющей функции.
Критерии, которые должны быть выполнены для создания замыкания в Python, изложены в следующих пунктах:
Когда стоит использовать замыкания?
Так для чего же нужны замыкания?
Замыкания позволяют избежать использования глобальных (global) значений и обеспечивают некоторую форму сокрытия данных. Для этого также может использоваться объектно-ориентированный подход.
Если в классе необходимо реализовать небольшое количество методов (в большинстве случаев один метод), замыкания могут обеспечить альтернативное и более элегантное решение. Но когда количество атрибутов и методов становится больше, лучше реализовать класс.
Вот простой пример, где замыкание может быть более предпочтительным, чем определение класса и создание объектов. Но выбор остается за вами.
Декораторы в Python также широко используют замыкания.
В заключение следует отметить, что можно найти значения, включенные в функцию замыкания.
Объект cell имеет атрибут cell_contents, который хранит значение.
Больше примеров замыканий вы можете найти по ссылке.
Изучаем продвинутые возможности Python, часть 2: замыкания, декораторы, модуль functools
В первой части серии публикаций о продвинутых возможностях Python мы познакомились с итераторами, генераторами и модулем itertools. В сегодняшней публикации речь пойдёт о замыканиях, декораторах и модуле functools.
Декораторы
Декоратор — паттерн проектирования, при использовании которого класс или функция изменяет или дополняет функциональность другого класса или функции без использования наследования или прямого изменения исходного кода. В Python декораторы представляют собой функции или любые вызываемые объекты, которые принимают на вход набор необязательных аргументов и функцию или класс и возвращают функцию или класс. Их можно использовать для реализации паттерна проектирования декоратора или для решения других задач. Декораторы классов появились в Python 2.6.
Кстати, если вы не знакомы с замыканиями Python, прежде чем читать дальше ознакомьтесь с дополнением о замыканиях в конце этой статьи. Концепцию декораторов сложно понять, если вы не знакомы с замыканиями.
Также обратите внимание, как имя возвращаемой функции заменяется именем оригинальной функции в случае, если оно используется позже. Python не делает этого по умолчанию.
Декораторы класса
В предыдущем разделе мы рассмотрели декораторы функций и некоторые необычные способы их применения. Теперь давайте рассмотрим декораторы классов. В данном случае декоратор принимает на вход класс (объект с типом type в Python) и возвращает модифицированный класс.
Теперь можно написать декоратор класса.
Вот как он будет использоваться. Обратите внимание, как здесь обрабатываются переопределённые методы и наследование.
Несколько примеров из Flask
Рассмотрим несколько интересных примеров использования декораторов в Flask.
Представьте, что хотите, чтобы некоторые функции выводили предупреждающие сообщения, если они вызываются при определённых обстоятельствах в режиме отладки. Вместо того, чтобы вручную добавлять код в начало каждой функции, можно использовать декоратор. Это то, что делает декоратор, который можно найти в файле app.py Flask.
Дополнительное чтение
Много информации о декораторах вы найдёте на официальной вики-странице Python. Также можно посмотреть замечательное видео Дэвида Безли о метапрограммировании в Python 3.
Приложение: замыкания
Ещё один пример, более сложный. Убедитесь, что понимаете, почему код работает именно так.
Адаптированный перевод статьи A Study of Python’s More Advanced Features Part II: Closures, Decorators and functools by Sahand Saba. Мнение автора оригинальной публикации может не совпадать с мнением администрации «Хекслета».