Контекстный менеджер python для чего

Менеджер контекста в Python

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

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

Управление ресурсами

Чтобы действительно понять, что такое диспетчер контекста и как мы можем его использовать, мы должны сначала исследовать мотивы, стоящие за ним – потребности, которые привели к этому «изобретению».

Основная цель менеджеров контекста в Python – это управление ресурсами. Когда программа хочет получить доступ к ресурсу на компьютере, она запрашивает об этом у ОС, а ОС, в свою очередь, предоставляет ей дескриптор этого ресурса. Некоторыми распространенными примерами таких ресурсов являются файлы и сетевые порты.

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

Самый простой способ добиться правильного управления ресурсами – это вызвать функцию закрытия после того, как мы закончим с ресурсом. Например:

Здесь мы открываем файл с именем readme.txt, читаем файл и сохраняем его содержимое в виде строки текста, а затем, когда мы закончили с ним, закрываем файл, вызывая метод close() объекта open_file.

На первый взгляд это может показаться нормальным, но на самом деле это совсем не надежно. Если между открытием файла и закрытием файла произойдет что-то неожиданное, в результате чего программа не сможет выполнить строку, содержащую оператор close, произойдет утечка ресурсов. Эти неожиданные события – это то, что мы называем исключениями, обычно случаются, когда кто-то принудительно закрывает программу во время ее выполнения.

Теперь правильный способ справиться с этим – использовать обработку исключений с использованием блоков try … else. Взгляните на следующий пример:

Python всегда обеспечивает выполнение кода в блоке else, независимо от того, что может произойти. Таким образом программисты на других языках справляются с управлением ресурсами, но программисты получают специальный механизм, который позволяет им реализовать ту же функциональность без всяких шаблонов. Здесь в игру вступают контекстные менеджеры.

Реализация

Теперь, когда мы закончили с самой важной частью понимания менеджеров контекста, мы можем перейти к их реализации. В этом руководстве мы реализуем собственный класс File. Это полностью излишне, поскольку Python уже предоставляет это, но, тем не менее, это будет хорошее учебное упражнение, поскольку мы всегда сможем вернуться к классу File, который уже есть в стандартной библиотеке.

Стандартный и «низкоуровневый» способ реализации диспетчера контекста – это определение двух «волшебных» методов в классе, для которого вы хотите реализовать управление ресурсами, __enter__ и __exit__. Если вы начали заниматься объектно-ориентированным программированием на Python, вы наверняка уже сталкивались с методом __init__.

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

Давайте посмотрим на пример:

Как видите, метод __enter__ открывает ресурс – файл – и возвращает его. Когда мы используем этот FileManager в операторе with, этот метод будет вызван, и его возвращаемое значение будет привязано к целевой переменной, которую вы упомянули в предложении as. Я продемонстрировал в следующем фрагменте кода:

Давайте разберемся по частям. Во-первых, экземпляр класса FileManager создается при его создании, передавая конструктору имя файла «readme.txt». Затем оператор with начинает работать с ним – он вызывает метод __enter__ этого объекта FileManager и присваивает возвращаемое значение файловой переменной, указанной в предложении as. Затем внутри блока with мы можем делать с открытым ресурсом все, что захотим.

Другая важная часть головоломки – это метод __exit__. Он содержит код очистки, который должен быть выполнен после того, как мы закончим работу с ресурсом, несмотря ни на что. Инструкции в этом методе будут аналогичны инструкциям в блоке else, который мы обсуждали ранее. Повторюсь, метод __exit__ содержит инструкции по правильному закрытию обработчика ресурсов, чтобы он был освобожден для дальнейшего использования другими программами в ОС.

Теперь давайте посмотрим, как мы могли бы написать этот метод:

Теперь, когда экземпляры этого класса будут использоваться в операторе with, этот метод __exit__ будет вызываться до того, как программа выйдет из блока with или до того, как программа остановится из-за некоторого исключения. Теперь давайте посмотрим на весь класс FileManager, чтобы получить полное представление.

Мы только что определили действия открытия и очистки в соответствующих магических методах, а Python позаботится об управлении ресурсами, где бы этот класс ни использовался. Это подводит меня к следующей теме, различным способам использования классов диспетчера контекста, таких как этот класс FileManager.

Использование

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

Использование contextlib

Разработчики Python создали библиотеку с именем contextlib, содержащую утилиты для менеджеров контекста, как будто они недостаточно упростили проблему управления ресурсами. Я собираюсь кратко продемонстрировать только один из них.

Когда у нас есть такая функция, мы можем украсить ее с помощью декоратора contextlib.contextmanager, и все в порядке.

Как видите, декорированная функция open_file возвращает диспетчер контекста, и мы можем использовать его напрямую. Это позволяет без лишних хлопот достичь того же эффекта, что и при создании класса FileManager.

Источник

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

Предисловие

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

Немного о терминах

Начну пожалуй с терминов, которые часто путают начинающих Python программистов.

List comprehensions или генераторы списков возвращают список. Я всегда путал генераторы списков и выражения — генераторы (но не генераторы выражений!). Согласитесь, по русский звучит очень похоже. Выражения — генераторы это generator expressions, специальные выражения, которые возвращают итератор, а не список. Давайте сравним:

Это две совершенно разные конструкции. Первый возвращает генератор (то есть итератор), второй обычный список.

Generators или генераторы это специальные функции, которые возвращают итератор. Что бы получить генератор нужно возвратить функции значение через yield:

Кстати, в Python 3.3 появилась новая конструкция yield from. Совместное использование yield и for используется настолько часто, что эти две конструкции решили объединить.

Что такое контекстные менеджеры и для чего они нужны?

Контекстные менеджеры это специальные конструкции, которые представляют из себя блоки кода, заключенные в инструкцию with. Инструкция with создает блок используя протокол контекстного менеджера, о котором мы поговорим далее в этой статье. Простейшей функцией, использующей данный протокол является функция open(). Каждый раз, как мы открываем файл нам необходимо его закрыть, что бы вытолкнуть выходные данные на диск (на самом деле Python вызывает метод close() автоматически, но явное его использование является хорошим тоном). Например:

Что бы каждый раз не вызывать метод close() мы можем воспользоваться контекстным менеджером функции open(), который автоматически закроет файл после выхода из блока:

Здесь нам не нужно каждый раз вызывать метод close, что бы вытолкнуть данные в файл. Из этого следует, что контекстный менеджер используется для выполнения каких либо действий до входа в блок и после выхода из него. Но функциональность контекстных менеджеров на этом не заканчивается. Во многих языках программирования для подобных задач используются деструкторы. Но в Python если объект используется где то еще то нет гарантии, что деструктор будет вызван, так как метод __del__ вызывается только в том случае, если все ссылки на объект были исчерпаны:

Решим эту задачу через контекстные менеджеры:

Теперь попробуем вызвать менеджер контекста:

Мы увидели, что произошел гарантированный выход из блока после выполнения нашего кода.

Протокол контекстного менеджера

Мы уже кратко рассмотрели протокол контекстного менеджера написав небольшой класс Hello. Давайте теперь разберемся в протоколе более подробно. Что бы объект стал контекстным менеджером в его класс обязательно нужно включить два метода: __enter__ и __exit__. Первый метод выполняется до входа в блок. Методу можно возвратить текущий экземпляр класса, что бы к нему можно было обращаться через инструкцию as.

Метод __exit__ выполняется после выхода из блока with, и он содержит три параметра — exp_type, exp_value и exp_tr. Контекстный менеджер может вылавливать исключения, которые были возбуждены в блоке with. Мы можем вылавливать только нужные нам исключения или подавлять ненужные.

Переменная exp_type содержит в себе класс исключения, которое было возбуждено, exp_value — сообщение исключения. В примере мы закрываем файл и подавляем исключение IOError посредством возврата True методу __exit__. Все остальные исключения в блоке мы разрешаем. Как только наш код подходит к концу и блок заканчивается вызывается метод self.fp.close(), не зависимо от того, какое исключение было возбуждено. Кстати, внутри блока with можно подавлять и такие исключения как NameError, SyntaxError, но этого делать не стоит.

Протоколы контекстных менеджеров очень просты в использовании, но для обычных задач есть еще более простой способ, который поставляется вместе со стандартной библиотекой питона. Далее мы рассмотрим пакет contextlib.

Пакет contextlib

Создание контекстных менеджеров традиционным способом, то есть написанием классов с методами __enter__ и __exit__ не одна из сложных задач. Но для тривиального кода написание подобных классов требует больше возьни. Для этих целей был придуман декоратор contextmanager(), входящий в состав пакета contextlib. Используя декоратор contextmanager() мы можем из обычной функции сделать контекстный менеджер:

Проверим работоспособность кода:

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

Как видно из примера, реализация с использованием классов практически ничем не отличается по функциональности от реализации с использованием декоратора contextmanager(), но использование декоратора намного упрощает наш код.

Еще один интересный пример использования декоратора contextmanager():

Похоже на блоки в руби не так ли?

И напоследок поговорим о вложенных контекстах. Вложенные контексты позволяют управлять несколькими контекстами одновременно. Например:

вход в контекст first
вход в контекст second
внутри блока first second
выход из контекста second
выход из контекста first

Аналогичный код без использования функции nested:

Этот код хоть и похож на предыдущий, в некоторых ситуациях он будет работать не так как нам хотелось бы. Объекты context(‘first’) и context(‘second’) вызываются до входа в блок, поэтому мы не сможем перехватывать исключения, которые были возбуждены в этих объектах. Согласитесь, первый вариант намного компактнее и выглядит красивее. А вот в Python 2.7 и 3.1 функция nested устарела и была добавлена новая синтаксическая конструкция для вложенных контекстов:

range и xrange в Python 2.7 и Python 3

Известно, что Python 2.7 range возвращает список. Думаю все согласятся, что хранить большие объемы данных в памяти нецелесообразно, поэтому мы используем функцию xrange, возвращающий объект xrange который ведет себя почти так же как и список, но не хранит в памяти все выдаваемые элементы. Но меня немного удивило поведение xrange в Python 2.x, когда функции передаются большие значения. Давайте посмотрим на пример:

Python нам говорит о том, что int слишком длинный и он не может быть переконвертирован в C long. Оказывается у Python 2.x есть ограничения на целое число, в этом мы можем убедиться просмотрев константу sys.maxsize:

Вот оно максимальное значение целого числа:

Python аккуратно переконвертировал наше число в long int. Не удивляйтесь, если xrange в Python 2.x будет вести себя иначе при больших значениях.

В Python 3.3 целое число может быть бесконечно большим, давайте проверим:

Конвертирование в long int не произошло. Вот еще пример:

Не очевидное поведение некоторых конструкций

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

Каков будет результат выполнения данной конструкции? Неподготовленный разработчик сообщит о результате: [[‘a’], [b’], [c’]]. Но на самом деле мы получаем:

Почему в каждом списке результат дублируется? Дело в том, что оператор умножения создает ссылки внутри нашего списка на один и тот же список. В этом легко убедиться немного дополнив наш пример:

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

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

В пределах lambda функции переменная i замыкается и как бы создается экземпляр еще одной переменной i в блоке lambda — функции, которая является ссылкой на переменную i в цикле for. Каждый раз когда счетчик цикла for меняется, меняются и значения во всех lambda функциях, поэтому мы получаем значение i-1 во всех функциях. Исправить это легко, явно передав lambda функции в качестве первого параметра значение по умолчанию — переменную i:

Источник

Менеджеры контекста (оператор «with»)

Введение

Примеры

Введение в контекстные менеджеры и оператор with

Например, файловые объекты являются контекстными менеджерами. Когда контекст заканчивается, объект файла закрывается автоматически:

Присвоение цели

Многие контекстные менеджеры возвращают объект при вводе. Вы можете назначить этот объект на новое имя в with заявлением.

Например, с помощью подключения к базе данных в with утверждением может дать вам объект курсора:

Файловые объекты возвращаются сами по себе, это позволяет как открыть объект файла, так и использовать его в качестве диспетчера контекста в одном выражении:

Написание собственного менеджера контекста

Если вам необходим только __exit__ метод, вы можете вернуть экземпляр менеджера контекста:

Написание собственного менеджера контекста с использованием синтаксиса генератора

Также можно написать менеджер контекста с использованием синтаксиса генератора благодаря contextlib.contextmanager декоратора:

Несколько контекстных менеджеров

Вы можете открыть несколько менеджеров контента одновременно:

Это имеет тот же эффект, что и вложенные контекстные менеджеры:

Управление ресурсами

__init__() метод устанавливает объект, в данном случае настраивает имя файла и режим открытия файла. __enter__() открывает и возвращает файл и __exit__() просто закрывает его.

Используйте класс File:

Синтаксис

Параметры

Примечания

Научим основам Python и Data Science на практике

Это не обычный теоритический курс, а онлайн-тренажер, с практикой на примерах рабочих задач, в котором вы можете учиться в любое удобное время 24/7. Вы получите реальный опыт, разрабатывая качественный код и анализируя реальные данные.

Скрытые возможности

Введение Примеры Перегрузка оператора Все в Python является объектом. Каждый объект имеет несколько специальных внутренних методов, которые он использует для взаимодействия с другими объектами. Как правило, эти методы следуют __action__ именования. В совокупности, это называется как

Источник

Контекстные менеджеры в Python

Контекстные менеджеры – одна из основных функций языка, которая делает Python уникальным. Оператор with позволяет разработчикам писать свой код в сжатом и понятном виде. Новый вложенный блок даёт визуальный сигнал и облегчает понимание кода. Понимание контекстных менеджеров является ключом к пониманию идеи питонического кода.

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

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

Коротко о контекстных менеджерах

Говоря простыми словами, контекстные менеджеры упрощают запись блоков try-finally.

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

Некоторые важные моменты, которые следует помнить.

Если __exit__ возвращает True, исключение будет подавлено.

Простые менеджеры контекста также могут быть написаны с использованием генераторов и декоратора contextmanager:

Надежные деструкторы

Контекстные менеджеры дают нам надежный метод очистки ресурсов. В отличие от других языков OO, таких как C ++ и Java, вызов метода деструктора Python __del__ не всегда гарантируется. Он вызывается только тогда, когда счётчик ссылок на объект достигает нуля. Это может произойти в конце текущей функции или в конце программы или никогда в случае циклических ссылок.

До Python 3.4, если все объекты в эталонном цикле имеют метод __del__, Python не будет вызывать его при их удалении сборщиком мусора. Это связано с тем, что у Python нет безопасного способа узнать, какой порядок удаления этих объекты.

Начиная с Python 3.4, объекты с __del__ теперь могут быть удалены сборщиком мусора. Однако порядок их вызова не определён.

Давайте рассмотрим несколько реальных примеров с контекстными менеджерами.

Убедитесь, что открытый поток закрывается

Объекты StringIO ведут себя одинаково:

Менеджер контекста closing вызывает метод close() для любого объекта, если такой метод в нём существует.

Проверка на возникновение исключения при тестировании

Настройка mocks перед тестированием

При использовании в качестве декоратора mock.patch передает вновь созданный mock объект (возвращаемое значение __enter__) в декорированную функцию. ContextDecorator в Python 3, с другой стороны, не предоставляет доступа к возвращаемому значению метода __enter__.

Синхронизация доступа к общим ресурсам

Оператор with в этом случае вызывает lock.acquire() при входе и lock.release() при выходе.

В потоковом модуле в качестве контекстных менеджеров могут использоваться Lock, RLock, Condition, Semaphore, BoundedSemaphore.

Аналогичный подход можно использовать для блокировки файлов при доступе к ним. Например, диспетчер контекста pidfile использует fcntl.flock() для получения блокировки файла в python-демонах.

Настройка среды выполнения Python

Управление подключениями к базе данных и транзакциями

Обёртка соединений по протоколу

Тайминги выполнения кода

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

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

Работа с временными файлами

Перенаправление потоков ввода и вывода

В Python 3.4+ диспетчер контекста redirect_stdout и redirect_stderr можно использовать для временного перенаправления потоков stdout и stderr.

redirect_stdout только перенаправляет вызовы stdout из Python, но не из кода библиотеки C.

Чтение и запись в файл inplace

Управление пулом процессов

Библиотека multiprocessing Python предоставляет кучу менеджеров контекстов для управления соединениями, пулами и блокировками ресурсов на уровне ОС.

Резюме

Короче говоря, Context Managers можно использовать в самых разных случаях. Начните использовать их сразу же, когда заметите шаблон «настройка-завершение», чтобы сделать свой код более питоничным.

Источник

Оператор with в Python — менеджеры контекста

Оператор Python with очень полезен. Он появился с Python 2.5, и теперь это вездесущая функция, используемая почти каждым приложением.

Самое полезное (фактически единственное!) Он открывает и освобождает ресурсы.

По сути, он обрабатывает открытие и закрытие любых ресурсов, которые могут вам понадобиться для определенной части программы, а затем автоматически закрывает ее.

Зачем нужны контекстные менеджеры в Python?

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

Оператор with теперь автоматически это делает, поэтому вам не нужно каждый раз закрывать файл вручную. У оператора with есть контекст (блок), в котором он действует. Это как объем заявления.

Когда программа выходит из этого контекста, with автоматически закрывается ваш файл. Из-за этого with часто называют диспетчером контекста. Таким образом, можно использовать те же процедуры обработки файлов.

Обратите внимание, насколько это интуитивно понятно. Оператор Python with всегда будет закрывать файл в конце, даже если программа завершилась ненормально даже в контексте или блоке.

Эта функция безопасности рекомендуемый выбор для всех программистов.

Использование

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

А теперь идем дальше. После создания объекта контекста он вызывает метод __enter__ dunder для объекта.

Использование as необязательно, особенно если у вас есть ссылка на исходный объект контекста в другом месте.

После этого мы входим во вложенный блок операторов.

После того, как вложенный блок закончился, ИЛИ, если в нем есть исключение, программа всегда выполняет __exit__ для объекта контекста.

Это первая функция безопасности, о которой мы говорили ранее. Итак, что бы ни случилось, мы всегда будем использовать __exit__ для освобождения ресурсов и выхода из контекста.

Наконец, если возможно, __exit__ может быть реализован так, чтобы восстановить состояние объекта контекста, чтобы он вернулся в то состояние, к которому он принадлежал.

Чтобы было понятнее, давайте рассмотрим пример создания нашего собственного диспетчера контекста для класса.

Создание наших собственных менеджеров контекста для нашего класса

Рассмотрим приведенный ниже класс, для которого у нас будет собственный диспетчер контекста для обработки файлов.

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

Теперь метод __enter__ dunder сохраняет состояние объекта и открывает файл. Теперь мы внутри блока.

Хорошо, похоже, у нас нет ошибок. Мы только что реализовали собственные контекстные менеджеры для нашего Custom Class. Теперь есть другой подход к созданию диспетчера контекста, который использует генераторы.

Однако это обычно не рекомендуется, если вы точно не знаете, что делаете, поскольку вы должны сами обрабатывать исключения.

Есть два разных метода для менеджера контекста. Эти методы —

Метод __enter __()

Метод __enter __() используется для входа в контекст времени выполнения. Он вернет либо текущий объект, либо другой связанный объект. Возвращаемое значение привязывается к идентификатору в качестве предложения оператора with.

Метод __exit __ (exc_type, exc_val, exc_tb)

Метод __exit __() используется для возврата результата логического типа. Это указывает на любое исключение, которое произошло. Если есть одно исключение для оператора with, оно перейдет в конец блока.

Источник