Installing Python Modules¶
As a popular open source development project, Python has an active supporting community of contributors and users that also make their software available for other Python developers to use under open source license terms.
This allows Python users to share and collaborate effectively, benefiting from the solutions others have already created to common (and sometimes even rare!) problems, as well as potentially contributing their own solutions to the common pool.
This guide covers the installation part of the process. For a guide to creating and sharing your own Python projects, refer to the distribution guide .
For corporate and other institutional users, be aware that many organisations have their own policies around using and contributing to open source software. Please take such policies into account when making use of the distribution and installation tools provided with Python.
Key terms¶
pip is the preferred installer program. Starting with Python 3.4, it is included by default with the Python binary installers.
A virtual environment is a semi-isolated Python environment that allows packages to be installed for use by a particular application, rather than being installed system wide.
venv is the standard tool for creating virtual environments, and has been part of Python since Python 3.3. Starting with Python 3.4, it defaults to installing pip into all created virtual environments.
virtualenv is a third party alternative (and predecessor) to venv . It allows virtual environments to be used on versions of Python prior to 3.4, which either don’t provide venv at all, or aren’t able to automatically install pip into created environments.
The Python Package Index is a public repository of open source licensed packages made available for use by other Python users.
the Python Packaging Authority is the group of developers and documentation authors responsible for the maintenance and evolution of the standard packaging tools and the associated metadata and file format standards. They maintain a variety of tools, documentation, and issue trackers on both GitHub and Bitbucket.
distutils is the original build and distribution system first added to the Python standard library in 1998. While direct use of distutils is being phased out, it still laid the foundation for the current packaging and distribution infrastructure, and it not only remains part of the standard library, but its name lives on in other ways (such as the name of the mailing list used to coordinate Python packaging standards development).
Changed in version 3.5: The use of venv is now recommended for creating virtual environments.
Basic usage¶
The standard packaging tools are all designed to be used from the command line.
The following command will install the latest version of a module and its dependencies from the Python Package Index:
For POSIX users (including macOS and Linux users), the examples in this guide assume the use of a virtual environment .
For Windows users, the examples in this guide assume that the option to adjust the system PATH environment variable was selected when installing Python.
It’s also possible to specify an exact or minimum version directly on the command line. When using comparator operators such as > , < or some other special character which get interpreted by shell, the package name and the version should be enclosed within double quotes:
Normally, if a suitable module is already installed, attempting to install it again will have no effect. Upgrading existing modules must be requested explicitly:
More information and resources regarding pip and its capabilities can be found in the Python Packaging User Guide.
Creation of virtual environments is done through the venv module. Installing packages into an active virtual environment uses the commands shown above.
How do I …?¶
These are quick answers or links for some common tasks.
… install pip in versions of Python prior to Python 3.4?¶
Python only started bundling pip with Python 3.4. For earlier versions, pip needs to be “bootstrapped” as described in the Python Packaging User Guide.
… install packages just for the current user?¶
Passing the —user option to python -m pip install will install a package just for the current user, rather than for all users of the system.
… install scientific Python packages?¶
A number of scientific Python packages have complex binary dependencies, and aren’t currently easy to install using pip directly. At this point in time, it will often be easier for users to install these packages by other means rather than attempting to install them with pip .
… work with multiple versions of Python installed in parallel?¶
On Linux, macOS, and other POSIX systems, use the versioned Python commands in combination with the -m switch to run the appropriate copy of pip :
Appropriately versioned pip commands may also be available.
On Windows, use the py Python launcher in combination with the -m switch:
Common installation issues¶
Installing into the system Python on Linux¶
On Linux systems, a Python installation will typically be included as part of the distribution. Installing into this Python installation requires root access to the system, and may interfere with the operation of the system package manager and other components of the system if a component is unexpectedly upgraded using pip .
On such systems, it is often better to use a virtual environment or a per-user installation when installing packages with pip .
Pip not installed¶
It is possible that pip does not get installed by default. One potential fix is:
There are also additional resources for installing pip.
Installing binary extensions¶
Python has typically relied heavily on source based distribution, with end users being expected to compile extension modules from source as part of the installation process.
With the introduction of support for the binary wheel format, and the ability to publish wheels for at least Windows and macOS through the Python Package Index, this problem is expected to diminish over time, as users are more regularly able to install pre-built extensions rather than needing to build them themselves.
Some of the solutions for installing scientific software that are not yet available as pre-built wheel files may also help with obtaining other binary extensions without needing to build them locally.
Основы
В Python ключевое слово import применяется для того, чтобы сделать код в одном модуле доступным для работы в другом. Импорт в Python важен для эффективного структурирования кода. Правильное применение импорта повысит вашу продуктивность: вы сможете повторно использовать код и при этом продолжать осуществлять поддержку своих проектов.
В статье представлен подробный обзор инструкции import в Python и того, как она работает. Здесь мощная система импорта. Вам предстоит узнать, как эту мощь задействовать, а также изучить ряд понятий, лежащих в основе системы импорта в Python. Их изложение в статье построено главным образом на примерах (в помощь вам будут несколько примеров кода).
В этой статье вы узнаете, как:
- Работать с модулями, пакетами и пакетами пространств имён.
- Импортировать ресурсы и файлы данных внутри ваших пакетов.
- Динамически импортировать модули во время выполнения.
- Настраивать систему импорта в Python.
На протяжении всей статьи даются примеры: вы сможете поэкспериментировать с тем, как организован импорт в Python, чтобы работать наиболее эффективно. Хотя в статье показан весь код, имеется также возможность скачать его по ссылке ниже:
Базовый импорт Python
Код в Python организован в виде модулей и пакетов. В этой части статьи мы объясним, чем они отличаются друг от друга и как с ними можно работать.
Чуть дальше вы узнаете о нескольких продвинутых и менее известных примерах применения системы импорта в Python. Но начнём с основ — импортирования модулей и пакетов.
Модули
В Python.org glossary даётся следующее определение модуля:
Объект, который служит организационной единицей кода в Python. Модули имеют пространство имён, в котором содержатся произвольные объекты Python. Модули загружаются в Python посредством импортирования. (Источник)
На практике модуль соответствует, как правило, одному файлу с расширением .py . В этом файле содержится код на Python.
Модули обладают сверхспособностью импортироваться и повторно использоваться в другом коде. Рассмотрим следующий пример:
В первой строке import math вы импортируете код в модуль math и делаете его доступным для использования. Во второй строке вы получаете доступ к переменной в модуле math . Модуль math является частью стандартной библиотеки Python, поэтому он всегда доступен для импорта, когда вы работаете с Python.
Обратите внимание, что пишется не просто pi , а math.pi .
math — это не только модуль, а ещё и пространство имён, в котором содержатся все атрибуты этого модуля. Пространства имён важны для читаемости и структурированности кода.
Содержимое пространства имён можно посмотреть с помощью dir() :
Если не указывать при этом никаких аргументов, т.е. напечатать просто dir() , то можно увидеть, что находится в глобальном пространстве имён. Посмотреть содержимое пространства имён math можно, указав его в качестве аргумента вот так: dir(math) .
Вы уже видели самый простой способ импортирования. Есть и другие, которые позволяют импортировать отдельные части модуля и переименовывать его в процессе импортирования.
Вот код, который импортирует из модуля math только переменную pi :
Обратите внимание, что pi помещается в глобальное пространство имён, а не в пространство имён math .
А вот как в процессе импортирования переименовываются модули и атрибуты:
Пакеты
Пакет представляет собой следующий после модуля уровень в организационной иерархии кода. В Python.org glossary даётся следующее определение пакета:
Это модуль Python, который может содержать подмодули или (рекурсивно) подпакеты. Строго говоря, пакет — это модуль Python с атрибутом __path__ . (Источник.)
То есть пакет — это тоже модуль. Пользователю обычно не приходится задумываться о том, что у него импортируется: модуль или пакет.
На практике пакет — это, как правило, каталог файлов, внутри которого находятся файлы Python и другие каталоги. Чтобы создать пакет Python самостоятельно, создайте каталог, а внутри него — файл с именем __init__.py . В __init__.py файле находится содержимое этого пакета-модуля. И он может быть пустым.
Обратите внимание: каталоги без файла __init__.py Python всё равно считает пакетами. Но это уже будут не обычные пакеты, а то, что можно назвать пакетами пространства имён. Подробнее о них чуть дальше в статье.
Вообще подмодули и подпакеты нельзя импортировать вместе с пакетом. Это можно сделать с помощью __init__.py , включив любой или все подмодули и подпакеты, если захотите. В качестве примера создадим пакет для Hello world на разных языках. Пакет будет состоять из следующих каталогов и файлов:
Для файла каждой страны выводится соответствующее приветствие, а файлы __init__.py выборочно импортируют некоторые подпакеты и подмодули. Вот точное содержимое этих файлов:
Обратите внимание: world/__init__.py импортирует только africa , а не europe ; world/africa/__init__.py ничего не импортирует; world/europe/__init__.py импортирует greece и norway , а не spain . Модуль каждой страны при импортировании выводит приветствие.
Разберёмся, как ведут себя подпакеты и подмодули в пакете world :
При импортировании europe модули europe.greece и europe.norway тоже импортируются. Это происходит потому, что модули этих стран выводят приветствие при импортировании:
Файл world/africa/__init__.py пуст. Это означает, что импортирование пакета world.africa создаёт пространство имён, но этим и ограничивается:
Не забывайте: при импорте модуля загружается его содержимое и одновременно создаётся пространство имён с этим содержимым. Последние несколько примеров показывают, что один и тот же модуль может быть частью разных пространств имён.
Технические нюансы: пространство имён модуля реализовано в виде словаря Python и доступно в атрибуте .__dict__ :
Но вам не придётся часто взаимодействовать с .__dict__ напрямую.
Глобальное пространство имён в Python тоже является словарём. Доступ к нему можно получить через globals() .
Импортировать подпакеты и подмодули в файле __init__.py — это обычное дело. Так они становятся более доступными для пользователей. Вот вам пример того, как это происходит в популярном пакете запросов.
Абсолютный и относительный импорт
Напомним исходный код world/__init__.py предыдущего примера:
Чуть ранее мы уже разбирали операторы типа from. import , такие как from math import pi . Что же означает точка ( . ) в from . import africa ?
Точка указывает на текущий пакет, а сам оператор — это пример относительного импорта. Можно прочитать этот
так: «из текущего пакета импортируется подпакет africa ».
Существует эквивалентный ему оператор абсолютного импорта, в котором прямо указывается название этого текущего пакета:
На самом деле, все импорты в world можно было бы сделать в виде таких вот абсолютных импортов с указанием названия текущего пакета.
Относительные импорты должны иметь такую from. import форму, причём обозначение места, откуда вы импортируете, должно начинаться с точки.
В руководстве по стилю PEP 8 рекомендуется в основном абсолютный импорт. Однако относительный импорт в качестве альтернативы абсолютному тоже имеет право на существование при организации иерархии пакетов.
Путь импорта в Python
А как Python находит модули и пакеты, которые импортирует? Более подробно о специфике системы импорта в Python расскажем чуть дальше в статье. А пока нам достаточно просто знать, что Python ищет модули и пакеты в своём пути импорта. Это такой список адресов, по которым выполняется поиск модулей для импорта.
Примечание: когда вы вводите import чего-то (что надо импортировать) , Python будет искать это что-то в нескольких разных местах, прежде чем переходить к поиску пути импорта.
Так, он заглянет в кэш модулей и проверит, не было ли это что-то уже импортировано, а также проведёт поиск среди встроенных модулей.
Подробнее о том, как организован импорт в Python, расскажем чуть дальше в статье.
Путь импорта в Python можно просмотреть, выведя на экран sys.path . В этом списке будет три различных типа адресов:
- Каталог текущего скрипта или текущий каталог, если скрипта нет (например, когда Python работает в интерактивном режиме).
- Содержимое переменной окружения PYTHONPATH .
- Другие каталоги, зависящие от конкретной системы.
Поиск Python, как правило, стартует в начале списка адресов и проходит по всем адресам до первого совпадения с искомым модулем. Каталог скрипта или текущий каталог всегда идёт первым в этом списке. Поэтому можно организовать каталоги так, чтобы скрипты находили ваши самодельные модули и пакеты. При этом надо внимательно следить за тем, из какого каталога вы запускаете Python.
Стоит следить и за тем, чтобы не создавались модули, которые затеняют или скрывают другие важные модули. В качестве примера предположим, что вы определяете следующий модуль math :
Всё пока идёт как надо:
Вот только модуль этот затеняет модуль math , который входит в состав стандартной библиотеки. Это приводит к тому, что наш предыдущий пример поиска значения π больше не работает:
Вместо того, чтобы искать модуль math в стандартной библиотеке, Python теперь ищет ваш новый модуль math для pi .
Во избежание подобных проблем надо быть осторожным с названиями модулей и пакетов. Имена модулей и пакетов верхнего уровня должны быть уникальными. Если math определяется как подмодуль внутри пакета, то он не будет затенять встроенный модуль.
Структурируем импорт
Несмотря на то, что мы можем организовать импорт, используя текущий каталог, переменную окружения PYTHONPATH и даже sys.path , этот процесс часто оказывается неконтролируемым и подверженным ошибкам. Типичный пример даёт нам следующее приложение:
Приложение воссоздаст данную файловую структуру с каталогами и пустыми файлами. Файл structure.py содержит основной скрипт, а files.py — это библиотечный модуль с функциями для работы с файлами. Вот что выводит приложение, запускаемое в данном случае в каталоге structure :
Два файла исходного кода плюс автоматически созданный файл .pyc повторно создаются внутри нового каталога с именем 001 .
Обратимся теперь к исходному коду. Основная функциональность приложения определяется в structure.py :
В строках с 12 по 16 читается корневой путь из командной строки. Точкой здесь обозначается текущий каталог. Этот путь — root файловой иерархии, которую вы воссоздадите.
Вся работа происходит в строках с 19 по 23. Сначала создаётся уникальный путь new_root , который будет корневым каталогом новой файловой иерархии. Затем в цикле проходятся все пути ниже исходного root , и они воссоздаются в виде пустых файлов внутри новой файловой иерархии.
В строке 26 вызывается main() . О проверке условия if в строке 25 подробнее узнаем дальше в статье. А пока нам достаточно знать, что специальная переменная __name__ внутри скриптов имеет значение __main__ , а внутри импортируемых модулей получает имя модуля.
Обратите внимание: в строке 8 импортируются файлы . В этом библиотечном модуле содержатся две служебные функции:
unique_path() работает со счётчиком для обнаружения пути, которого уже не существует. В приложении он нужен, чтобы найти уникальный подкаталог, который будет использоваться в качестве new_root вновь созданной файловой иерархии. add_empty_file() обеспечивает создание всех необходимых каталогов до того, как с помощью .touch() будет создан пустой файл.
Ещё раз взглянем на импорт файлов :
Выглядит он совершенно невинно. Однако по мере роста проекта эта строка станет источником некоторых проблем. Даже если импорт файлов происходит из проекта structure , этот импорт абсолютный: он не начинается с точки. А это означает, что файлы должны быть найдены в пути импорта, чтобы импорт состоялся.
К счастью, каталог с текущим скриптом всегда находится в пути импорта Python. Так что, пока проект не набрал обороты, импорт работает нормально. Но дальше возможны варианты.
Например, кто-то захочет импортировать скрипт в Jupyter Notebook и запускать его оттуда. Или иметь доступ к библиотеке файлов в другом проекте. Могут даже с помощью PyInstaller создавать исполняемые файлы, чтобы упростить их дальнейшее распространение. К сожалению, любой из этих сценариев может вызвать проблемы с импортом файлов.
Каким образом? Вот вам пример. Возьмём руководство по PyInstaller и создадим точку входа в приложение. Добавим дополнительный каталог за пределами каталога приложения:
В этом внешнем каталоге создадим скрипт точки входа cli.py :
Этот скрипт импортирует из исходного скрипта main() и запускает его. Обратите внимание: когда импортируется structure , main() не запускается из-за проверки условия if в строке 25 внутри structure.py . То есть нужно запускать main() явным образом.
По идее, это должно быть аналогично прямому запуску приложения:
Почему же запуск не удался? При импорте файлов неожиданно возникает ошибка.
Проблема в том, что при запуске приложения с cli.py поменялся адрес текущего скрипта, а это, в свою очередь, меняет путь импорта. Файлы больше не находятся в пути импорта, поэтому их абсолютный импорт невозможен.
Одно из возможных решений — поменять путь импорта Python. Вот так:
Здесь в пути импорта есть папка со structure.py и files.py . Поэтому это решение работает. Но такой подход неидеален, ведь путь импорта может стать очень неаккуратным и трудным для понимания.
Фактически происходит воссоздание функции ранних версий Python, называемой неявным относительным импортом. Она была удалена из языка в руководстве по стилю PEP 328 со следующим обоснованием:
В Python 2.4 и более ранних версиях при чтении модуля, расположенного внутри пакета, неясно: относится ли import foo к модулю верхнего уровня или к другому модулю внутри пакета. По мере расширения библиотеки Python всё больше и больше имеющихся внутренних модулей пакета вдруг случайно затеняют модули стандартной библиотеки. Внутри пакетов эта проблема усугубляется из-за невозможности указать, какой модуль имеется в виду. (Источник.)
Другое решение — использовать вместо этого относительный импорт. Меняем импорт в structure.py :
Теперь приложение можно запустить через скрипт точки входа:
Но вызвать напрямую приложение больше не получится:
Проблема в том, что относительный импорт разрешается в скриптах иначе, чем импортируемые модули. Конечно, можно вернуться и восстановить абсолютный импорт, а затем выполнить непосредственный запуск скрипта или даже попытаться провернуть акробатический трюк с try. except и реализовать абсолютный или относительный импорт файлов (в зависимости от того, что сработает).
Есть даже официально санкционированный хакерский приём, позволяющий работать с относительным импортом в скриптах. Вот только в большинстве случаев при этом придётся менять sys.path . Цитируя Реймонда Хеттинджера, можно сказать:
И действительно, лучшее (и более стабильное) решение — поэкспериментировать с системой управления пакетами и импорта Python, устанавливая проект в качестве локального пакета с помощью pip .
Создание и установка локального пакета
При установке пакета из PyPI этот пакет становится доступным для всех скриптов в вашей среде. Но пакеты можно установить и с локального компьютера, и они точно так же будут доступны.
Создание локального пакета не приводит к большому расходу вычислительных ресурсов. Сначала создаём минимальный набор файлов setup.cfg и setup.py во внешнем каталоге structure :
Теоретически name и version могут быть любыми. Надо лишь учесть, что они задействованы pip при обращении к пакету, поэтому стоит выбрать для него значения, легко узнаваемые и выделяющие его из массы других пакетов.
Рекомендуется давать всем таким локальным пакетам общий префикс, например local_ или ваше имя пользователя. В пакетах должен находиться каталог или каталоги, содержащие исходный код. Теперь можно установить пакет локально с помощью pip :
Эта команда установит пакет в вашу систему. structure после этого будет находиться в пути импорта Python. То есть можно будет выполнить её в любом месте, не беспокоясь о каталоге скрипта, относительном импорте или других сложностях. -e означает editable (редактируемый). Это важная опция, позволяющая менять исходный код пакета без его переустановки.
Примечание: такой установочный файл отлично подходит для самостоятельной работы с проектами. Если же вы планируете поделиться кодом ещё с кем-то, то стоит добавить в установочный файл кое-какую дополнительную информацию.
Теперь, когда structure в системе установлена, можно использовать следующую инструкцию импорта:
Она будет работать независимо от того, чем закончится вызов приложения.
Совет: старайтесь разделять в коде скрипты и библиотеки. Вот хорошее практическое правило:
- Скрипт предназначен для запуска.
- Библиотека предназначена для импорта.
Возможно, у вас есть код, который вы хотите запускать самостоятельно и импортировать из других скриптов. На этот случай стоит провести рефакторинг кода, чтобы разделить общую часть на библиотечный модуль.
Разделять скрипты и библиотеки — неплохая идея, тем не менее в Python все файлы можно запускать и импортировать. Ближе к завершению статьи подробнее расскажем о том, как создавать модули, которые хорошо справляются и с тем, и с другим.
Пакеты пространства имён
Модули и пакеты в Python очень тесно связаны с файлами и каталогами. Это отличает Python от многих других языков программирования, в которых пакеты — это не более чем пространства имён без обязательной привязки к тому, как организован исходный код. Для примера можете ознакомиться с обсуждением на PEP 402.
Пакеты пространства имён доступны в Python с версии 3.3. Они в меньшей степени зависят от имеющейся здесь файловой иерархии. Так, пакеты пространств имён могут быть разделены на несколько каталогов. Пакет пространства имён создаётся автоматически, если у вас есть каталог, содержащий файл .py , но нет __init__.py . Подробное объяснение смотрите в PEP 420.
Замечание: справедливости ради стоит отметить, что пакеты неявных пространств имён появились в Python 3.3. В более ранних версиях Python пакеты пространств имён можно было создавать вручную несколькими различными несовместимыми способами. Все эти ранние подходы обобщены и в упрощённом виде представлены в PEP 420.
Для лучшего понимания пакетов пространства имён попробуем реализовать один из них. В качестве поясняющего примера рассмотрим такую задачу. Дано: объект Song . Требуется преобразовать его в одно из строковых представлений. То есть нужно сериализовать объекты Song .
А конкретнее — нужно реализовать код, который работает примерно так:
Предположим, нам повезло наткнуться на стороннюю реализацию нескольких форматов, в которые нужно сериализовать объекты, и она организована как пакет пространства имён:
В файле json.py содержится код, который может сериализовать объект в формат JSON:
Этого несколько ограниченного интерфейса сериализатора будет достаточно, чтобы продемонстрировать, как работают пакеты пространства имён.
В файле xml.py содержится аналогичный XmlSerializer , который может преобразовать объект в XML:
Обратите внимание, что оба этих класса реализуют один и тот же интерфейс с помощью методов .start_object() , .add_property() и .__str__() .
Затем создаём класс Song , который может применять эти сериализаторы:
Song (песня) определяется по идентификатору, названию и исполнителю. Обратите внимание, что .serialize() не нужно знать, в какой формат происходит преобразование, потому что он использует общий интерфейс, определённый ранее.
Установив пакет сторонних serializers , можно работать с ним так:
Для разных объектов сериализатора, вызывая .serialize() получаем разные представления песни.
Примечание: при запуске кода можно получить ModuleNotFoundError или ImportError . Всё потому, что serializers нет в пути импорта Python. Но скоро мы увидим, как решить эту проблему.
Пока все идёт хорошо. Но теперь песни нужно преобразовать и в представление YAML, которое не поддерживается сторонней библиотекой. Тут-то в дело и вступают пакеты пространства имён: можем добавить в пакет serializers собственный YamlSerializer , не прибегая к сторонней библиотеке.
Сначала создаём каталог в локальной файловой системе под названием serializers . Важно, чтобы имя каталога совпадало с именем настраиваемого пакета пространства имён:
В файле yaml.py определяем собственный YamlSerializer . Делаем это с помощью пакета PyYAML , который должен быть установлен из PyPI:
Форматы YAML и JSON очень похожи, поэтому здесь можно повторно использовать большую часть реализации JsonSerializer :
Смотрите: YamlSerializer здесь основан на JsonSerializer , который импортируется из этих самых serializers . А раз json и yaml являются частью одного и того же пакета пространства имён, то мы можем даже использовать относительный импорт: from .json import JsonSerializer .
Поэтому, продолжая этот пример, мы теперь можем преобразовать песню в YAML:
Подобно обычным модулям и пакетам, пакеты пространства имён должны находиться в пути импорта Python. Если бы мы делали, как в предыдущих примерах, то могли бы столкнуться с проблемами: Python не находил бы serializers . В реальном коде мы бы использовали pip для установки сторонней библиотеки, так что они автоматически оказывались бы в нашем пути.
Примечание: в исходном примере выбор сериализатора делался более динамично. Позже мы увидим, как использовать пакеты пространств имён в соответствующем шаблоне «фабричный метод».
И нужно позаботиться о том, чтобы локальная библиотека была доступна так же, как и обычный пакет. Как мы уже убедились, это можно сделать либо запустив Python из соответствующего каталога, либо опять-таки используя pip для установки локальной библиотеки.
В этом примере мы тестируем, как можно интегрировать фейковый сторонний пакет с нашим локальным пакетом. Будь сторонний third_party реальным пакетом, то мы бы загрузили его из PyPI с помощью pip . А так мы можем сымитировать его, установив third_party локально, как уже было сделано ранее в примере со structure .
Или же можно поколдовать с путём импорта. Поместите каталоги third_party и local в одну папку, а затем настройте путь Python вот так:
Теперь можно использовать все сериализаторы, не беспокоясь о том, где они определены: в стороннем пакете или локально.
Руководство по стилю импорта
В руководстве по стилю Python PEP 8 есть ряд рекомендаций, касающихся импорта. Как всегда, в Python важное значение придаётся читаемости и лёгкости сопровождения кода. Вот несколько общих практических правил относительно того, какого стиля надо придерживаться при оформлении импорта:
- Находится в верхней части файла.
- Прописывается в отдельных строках.
- Организуется в группы: сначала идут импорты стандартной библиотеки, затем сторонние импорты, а после — импорты локальных приложений или библиотек.
- Внутри каждой группы импорты располагаются в алфавитном порядке.
- Предпочтение отдаётся абсолютному импорту над относительным.
- Импорты со спецсимволами типа звёздочки ( from module import * ) стараются не использовать.
Инструменты isort и reorder-python-imports отлично подходят для реализации этих рекомендаций в последовательном стиле импорта. Вот пример раздела импорта внутри пакета Real Python feed reader package:
Обратите внимание на чёткую организацию по группам. Сразу позволяет обозначить зависимости этого модуля, которые должны быть установлены: feedparser и html2text . Обычно подразумевается, что стандартная библиотека доступна. Разделение импортов внутри пакета даёт некоторое представление о внутренних зависимостях кода.
Бывают случаи, когда имеет смысл немного отойти от этих правил. Мы уже видели, что относительный импорт может быть альтернативой при организации иерархии пакетов. В конце статьи мы увидим, как в некоторых случаях можно переместить импорт в определение функции, чтобы прервать циклы импорта.
Импорт в Python. Ресурсы и динамический импорт
Иногда наш код зависит от файлов данных или других ресурсов. В небольших скриптах это не проблема — мы можем указать путь к файлу данных и продолжить работу!
Однако, если файл ресурсов важен для нашего пакета и хочется поделиться им с другими пользователями, возникает несколько проблем:
- У нас не будет контроля над путём к ресурсу, так как это будет зависеть от настроек пользователя, а также от того, как пакет распространяется и устанавливается. Можно попробовать узнать путь к ресурсу с помощью атрибутов пакета __file__ или __path__ , но такой способ не всегда может сработать так, как мы ожидаем.
- Пакет может находиться внутри ZIP-файла или старого файла .eggfile, и в этом случае ресурс даже не будет физическим файлом в компьютере пользователя.
Было предпринято несколько попыток решить эти проблемы, в том числе с помощью setuptools.pkg_resources . Однако с появлением в стандартной библиотеке Python 3.7 importlib.resources теперь есть один стандартный способ работы с ресурсными файлами.
Представляем importlib.resources
importlib.resources предоставляет доступ к ресурсам внутри пакетов. В этом контексте ресурс — это любой файл, находящийся в импортируемом пакете. Файл может соответствовать, а может и не соответствовать физическому файлу в файловой системе.
Здесь есть несколько преимуществ: при повторном использовании системы импорта получаем более последовательный способ работы с файлами внутри пакетов плюс более лёгкий доступ к ресурсным файлам в других пакетах. Вот что об этом сказано в документации:
Если вы можете импортировать пакет, то можете иметь доступ к ресурсам внутри этого пакета. (Источник.)
importlib.resources стали частью стандартной библиотеки в Python 3.7. А для более старых версий Python имеется бэкпорт importlib_resources . Чтобы задействовать бэкпорт, надо установить его из PyPI:
Бэкпорт совместим с Python 2.7, а также Python 3.4 и более поздними версиями.
При работе с importlib.resources есть одно условие: ресурсные файлы должны быть доступны внутри обычного пакета. Пакеты пространства имён не поддерживаются. На практике это означает, что файл должен находиться в каталоге, содержащем файл __init__.py .
В качестве первого примера предположим, что у нас в пакете есть такие ресурсы:
__init__.py — это просто пустой файл, необходимый для указания на то, что books (книги) — это обычный пакет.
Затем можем использовать open_text() и open_binary() для открытия текстовых и бинарных файлов соответственно:
open_text() и open_binary() эквивалентны встроенному open() с параметром mode , имеющим значения rt и rb соответственно. Также доступны в виде read_text() и read_binary() удобные функции для чтения текстовых или двоичных файлов. Ещё больше узнать можно в официальной документации.
Примечание: чтобы полностью перейти на бэкпорт для старых версий Python, импортируем importlib.resources :
Больше узнать об этом можно в разделе «Полезные советы» этой статьи. Далее в этой части статьи покажем несколько сложных примеров работы с ресурсными файлами на практике.
Файлы данных
В качестве более полного примера работы с файлами данных рассмотрим, как можно реализовать программу викторины, основанную на демографических данных Организации Объединенных Наций. Сначала создаём пакет data и загружаем WPP2019_TotalPopulationBySex.csv с веб-сайта ООН:
Откроем файл CSV и посмотрим на данные:
В каждой строке мы видим данные о населении страны за определённый год и вариант, указывающий на соответствующий прогнозный сценарий. В файле содержатся прогнозы численности населения по странам мира до 2100 года.
Следующая функция считывает этот файл и выдаёт общую численность населения той или иной страны за конкретный year (год) и variant (вариант):
Выделенные жирным шрифтом строки показывают применение importlib.resources для открытия файла данных. Функция возвращает словарь с численностью населения:
Имея такой словарь с данными по численности населения, можно сделать много чего интересного, например анализ и визуализации. Ну а мы создадим игру-викторину, в которой участников просят определить, какая страна в наборе имеет самую большую численность населения. Вот как будет выглядеть эта игра:
Вдаваться в подробности этой реализации не будем, так как они совершенно не имеют отношения к предмету рассмотрения нашей статьи. Однако полный исходный код мы можем показать.
Исходный код демографической викторины:
Демографическая викторина состоит из двух функций: одна считывает данные по численности населения (как мы это делали чуть выше), а другая запускает саму викторину:
Обратите внимание: здесь в строке 24 мы проверяем, что LocID меньше 900 . LocID , равный 900 и выше, указывает не на страновые данные, а на данные по миру, частям света, такие как World , Asia и т.д.
Пример: значки и Tkinter
При создании графических пользовательских интерфейсов (ГПИ) часто требуется включать ресурсные файлы, такие как значки. На следующем примере научимся делать это с помощью importlib.resources . В итоге приложение будет выглядеть довольно просто, но со вкусом благодаря оригинальному значку и оформлению кнопки Goodbye:
В примере используется пакет ГПИ Tkinter, доступный в стандартной библиотеке. Он основан на оконной системе Tk, изначально разработанной для языка программирования Tcl. Существует множество других пакетов ГПИ, доступных для Python. Если вы используете один из них, то должны уметь добавлять значки в своё приложение с помощью идей, подобных тем, что представлены здесь.
В Tkinter изображения обрабатываются классом PhotoImage . Чтобы создать PhotoImage , передаём путь к файлу изображения.
При распространении пакета вовсе не гарантируется, что ресурсные файлы будут существовать в файловой системе как физические файлы. importlib.resources решает эту проблему с помощью path() . Эта функция вернёт путь к ресурсному файлу, создав при необходимости временный файл.
Чтобы убедиться, что все временные файлы очищены правильно, задействуем path() в качестве менеджера контекста, используя ключевое слово with :
Для полного примера предположим, что у нас есть следующая файловая иерархия:
Хотите попробовать пример самостоятельно? Скачайте эти файлы вместе с остальным исходным кодом, приведённым в этой статье, перейдя по ссылке ниже:
Получить исходный код: Нажмите здесь и получите исходный код, используемый для изучения системы импорта Python в этой статье.
Код хранится в файле со специальным именем __main__.py . Это имя указывает на то, файл является точкой входа для пакета. Благодаря файлу __main__.py наш пакет может выполняться с python -m :
ГПИ определяется в классе Hello . Обратите внимание, что для получения пути к файлам изображений используется importlib.resources :
Официальная документация содержит хороший список ресурсов, с которого можно начать изучение. Ещё один отличный ресурс — это «Руководство по TkDocs», которое показывает, как использовать Tk в других языках.
Примечание: единственное, что может вызывать неудобство при работе с изображениями в Tkinter, так это то, что здесь нужно следить за тем, чтобы изображения не удалялись механизмом автоматического управления памятью. Из-за того, как Python и Tk взаимодействуют, сборщик мусора в Python (по крайней мере, в CPython) не регистрирует, что .iconphoto() и Button используют изображения.
Чтобы убедиться, что изображения сохраняются, нужно вручную добавлять ссылку на них. В нашем коде это было сделано в строках 18 и 31.
Динамический импорт
Одна из отличительных особенностей Python в том, что это очень динамичный язык. Можно много чего сделать с программой Python во время её выполнения (хотя иногда делать этого не стоит), например добавлять атрибуты к классу, переопределять методы или изменять строку документации модуля. Мы можем изменить print() так, чтобы он ничего не делал:
На самом деле, мы не переопределяем print() . Мы определяем другой print() , который затеняет встроенный print() . Для возвращения к исходному print() удаляем наш пользовательский print() с помощью del print . Так можно затенить любой объект Python, встроенный в интерпретатор.
Обратите внимание: в приведенном выше примере мы переопределяем print() с помощью лямбда-функции. Также можно было бы использовать определение обычной функции:
В этой части статьи мы ещё узнаем, как выполнять динамический импорт в Python. Освоив его, вы избавитесь от необходимости решать, что импортировать во время выполнения программы.
importlib
До сих пор мы использовали ключевое слово import для явного импорта модулей и пакетов в Python. Однако весь механизм импорта доступен в пакете importlib , что позволяет нам выполнять импорт более динамично. Следующий скрипт запрашивает у пользователя имя модуля, импортирует этот модуль и выводит строку его документации:
import_module() возвращает объект модуля, который можно привязать к любой переменной. После чего мы можем обращаться с этой переменной как с обычным импортируемым модулем. Этот скрипт можно использовать вот так:
В каждом случае модуль импортируется динамически с помощью import_module() .
Фабричный метод с пакетами пространства имён
Вернёмся к примеру с сериализаторами. Благодаря serializers , реализованным в качестве пакета пространства имён, у нас появилась возможность добавлять пользовательские сериализаторы. Сериализаторы создаются с помощью фабрики сериализаторов. Попробуем сделать это, использовав importlib .
Добавим в наш локальный пакет пространства имён serializers следующий код:
Фабрика get_serializer() может создать сериализаторы динамически на основе параметра format , а затем serialize() может применить сериализатор к любому объекту, реализующему метод .serialize() .
Фабрика делает строгие предположения об именовании модуля и класса, которые содержат конкретные сериализаторы. Далее в статье мы узнаем об архитектуре плагинов, которая придаёт больше гибкости.
А пока воссоздадим предыдущий пример вот таким образом:
В этом случае нам больше не нужно выполнять явный импорт каждого сериализатора. Имя сериализатора указываем со строкой. Строка может быть даже выбрана пользователем во время выполнения.
Обратите внимание: в обычном пакете мы бы, наверное, реализовали get_serializer() и serialize() в файле __init__.py . Так мы могли бы просто импортировать serializers , а затем вызвать serializers.serialize() .
Но пакеты пространства имён не могут использовать __init__.py , поэтому нужно реализовать эти функции в отдельном модуле.
Последний пример показывает, что мы получаем соответствующее сообщение об ошибке, если пытаемся сериализоваться в формат, который не был реализован.
Пакет плагинов
Рассмотрим ещё один пример использования динамического импорта. Мы можем использовать следующий модуль для настройки гибкой архитектуры плагинов в коде. Это похоже на то, что было в предыдущем примере, в котором мы могли подключить сериализаторы для различных форматов, добавив новые модули.
Эскпериментальное средство визуализации Glue — это одно из приложений, эффективно использующих плагины. Оно сходу может читать множество различных форматов данных. Если всё-таки нужный формат данных не поддерживается, можно написать собственный пользовательский загрузчик данных.
Просто добавляется функция, которая декорируется и помещается в специальное место, чтобы Glue было легче её найти. И никакую часть исходного кода Glue менять не надо. Все детали смотрите в документации.
Мы можем настроить аналогичную архитектуру плагина для использования в своих проектах. В этой архитектуре два уровня:
- Пакет плагинов — это набор связанных плагинов, соответствующих пакету Python.
- Плагин — это пользовательское поведение, доступное в модуле Python.
Модуль plugins , который предоставляет архитектуру плагина, имеет следующие функции:
Фабричные функции используются для удобного добавления функциональности в пакеты плагинов. Вскоре увидим примеры того, как это происходит.
Рассматривать код во всех деталях не будем: это выходит за рамки статьи. Если вам интересно, можем показать реализацию ниже.
В следующем коде показана реализация plugins.py , описанная выше:
Эта реализация немного упрощена. Так, она не выполняет явной обработки ошибок. Более полная реализация доступна по ссылке на проект PyPlugs.
_import() использует importlib.import_module() для динамической загрузки плагинов. А _import_all() использует importlib.resources.contents() для перечисления всех доступных плагинов в данном пакете.
Рассмотрим несколько примеров использования плагинов. Первый пример — это пакет greeter , который можно использовать для добавления различных приветствий в приложение. Полная архитектура плагинов здесь определённо избыточна, но она показывает, как работают плагины. Представьте, что у вас такой пакет greeter :
Каждый модуль greeter определяет функцию, которая принимает один аргумент name . Посмотрите, как с помощью декоратора @register все они регистрируются в качестве плагинов:
Обратите внимание: для упрощения обнаружения и импорта плагинов имя каждого плагина содержит не имя функции, а имя модуля, в котором он находится. Поэтому на каждый файл может быть только один плагин.
В завершение настройки greeter как пакета плагинов можно использовать фабричные функции в plugins для добавления функциональности в сам пакет greeter :
Теперь мы можем использовать greetings() и greet() вот так:
Заметьте, что greetings() автоматически обнаруживает все плагины, доступные в пакете.
Мы также можем более динамически выбирать, какой плагин вызывать. В следующем примере выбираем плагин случайным образом. Плагин также можно выбрать на основе конфигурационного файла или пользовательских данных:
Для обнаружения и вызова различных плагинов их нужно импортировать. Остановимся ненадолго на том, как plugins работают с импортом. Всё самое главное происходит в следующих двух функциях внутри plugins.py :
_import() внешне кажется простым. Для импорта модуля он использует importlib . Но здесь происходит ещё кое-что:
- Система импорта Python гарантирует, что каждый плагин импортируется только один раз.
- Декораторы @register , определённые внутри каждого модуля plugin, регистрируют каждый импортированный плагин.
- В полной реализации для работы с отсутствующими плагинами будет обработка ошибок.
_import_all() обнаруживает все плагины в пакете. Вот как это работает:
- contents() из importlib.resources выводит список всех файлов внутри пакета.
- Результаты фильтруются для поиска потенциальных плагинов.
- Каждый файл Python, не начинающийся с подчеркивания, импортируется.
- Плагины в любом из файлов обнаруживаются и регистрируются.
Завершим эту часть статьи финальной версией пакета пространства имён. Одной из нерешённых проблем было то, что фабрика get_serializer() делала строгие предположения об именовании классов сериализатора. С помощью плагинов можно сделать их более гибкими.
Первым делом добавляем строку, регистрирующую каждый из сериализаторов. Вот пример того, как это делается в сериализаторе yaml :
Затем обновляем get_serializers() для использования plugins :
Мы реализуем get_serializer() с помощью call_factory() , так как это автоматически инстанцирует каждый сериализатор. При таком рефакторинге сериализаторы работают точно так же, как и раньше. Но теперь у нас больше гибкости в именовании классов сериализаторов.
Ещё больше об использовании плагинов можно узнать в PyPlugs на PyPI и презентации Плагины: добавление гибкости приложениям из PyCon 2019.
Установка библиотек и окружения Python
Ранее мы уже познакомились с порядком подключения дополнительных модулей и пакетов, входящих в состав стандартной библиотеки. Однако в Python имеется возможность расширения ядра и за счет использования сторонних библиотек. А это более 90 000 модулей и пакетов, которые могут быть достаточно легко установлены из раздела Python Package Index (PyPI) официального сайта с помощью утилиты pip .
(от англ. Package Installer for Python ) – это свободно распространяемая консольная утилита, которая используется для установки и управления сторонними программными пакетами и библиотеками, написанными на Python .
Следует отметить, что включение pip в состав большинства последних дистрибутивов Python , начиная с версии 3.4 , дефакто сделало его стандартным менеджером пакетов языка. И даже несмотря на отсутствие графической оболочки, данная утилита интуитивно понятна и довольно проста в использовании. Полную документацию по данному менеджеру пакетов можно посмотреть на соответствующей странице его официального сайта. Здесь же мы рассмотрим лишь несколько основных моментов, дающих наглядное представление о порядке его использования.
Начнем с просмотра информации о версии менеджера, входящего в текущий дистрибутив Python (см. пример №1 ).
Пример №1. Просмотр версии менеджера пакетов pip.
Как видим, для доступа к pip из скрипта мы использовали метод os.system() , передав ему имя менеджера и через пробел добавив требуемую команду (в нашем случае это —version ). Аналогичным образом можно запускать на выполнение и другие команды менеджера. Перечислим наиболее востребованные из них.
- —version – вывести текущую версию pip .
- help – показать справку по доступным командам.
- install —upgrade pip – обновить утилиту.
- install package_name – установить пакет последней версии. Если нужна конкретная версия пакета, необходимо указывать ее в формате install package_name==specific_version , например, install numpy==1.23.4 . Можно также указывать минимально допустимую версию, тогда нужно использовать формат install ‘package_name>=minimum_version’ , например, install ‘numpy>=1.23.4’ .
- show package_name – показать информацию о пакете.
- list – показать список уже установленных пакетов (самостоятельно можете посмотреть их в домашнем каталоге Питона в lib\site-packages ).
- uninstall package_name – деинсталлировать пакет.
- install —force-reinstall package_name – принудительно переустановить пакет (либо установить, если он отсутствует).
- freeze > requirements.txt – команда создает обычный текстовый документ requirements.txt , в котором по одному в строке перечисляются все установленные и необходимые для работы данного python -приложения программные пакеты.
- install -r requirements.txt – команда устанавливает в текущее окружение (обычно активированное виртуальное окружение) все перечисленные в файле зависимости проекта программные пакеты. Обычно это необходимо при переносе проекта на другую машину (подробнее об этом чуть ниже).
Находясь в командной оболочке текущей операционной системы, вместо префикса pip3 к командам лучше использовать префиксы python3 -m pip для ОС Ubuntu или python -m pip для ОС Windows , поскольку запуск менеджера в качестве исполняемого файла Python позволит избежать возможных проблем с правами доступа, например, при попытке обновления самого менеджера.
Не смотря на то, что список команд менеджера получился неполный, этих возможностей вполне хватит для управления установкой из PyPI практически любых сторонних пакетов и библиотек (см. пример №2 ).
Пример №2. Использование pip в скриптах.
Обратите внимание, что по умолчанию менеджер устанавливает библиотеки в общесистемное окружение. В нашем случае установка производилась в каталог c:\python\lib\site-packages ( ОС Windows ). Если же за компьютером работает несколько человек и возникает необходимость в установке библиотек в какое-то конкретное пользовательское окружение, следует использовать после основной команды опцию —user . Так при использовании инструкции ‘install —user Pillow’ , мой интерпретатор установил библиотеку в каталог моего окружения c:\users\petr\appdata\roaming\python\python310\site-packages . Далее нас будут больше интересовать виртуальные окружения, при активации которых все пакеты будут устанавливаться не в системное, а в текущее активное виртуальное окружение. В любом случае, после успешного добавления все сторонние библиотеки и пакеты становятся доступны в целевом окружении для импортирования инструкцией import как самые обычные модули стандартной библиотеки.
Готовый скрипт для установки и управления сторонними библиотеками вам предстоит написать в качестве задания в разделе «Простейшие скрипты и программы» нашего сборника задач и упражнений по языку программирования Python .
Использование виртуального окружения
В ходе разработки python -приложений практически каждый разработчик время от времени сталкивается с рядом проблем, связанных с использованием различных наборов версий интерпретатора и сопутствующих библиотек. Дело в том, что приложения могут быть рассчитаны на использование отличных друг от друга наборов версий и, кроме того, для многих приложений такой набор изначально подразумевается статическим. Однако библиотеки из общесистемного или пользовательского окружения постоянно и неравномерно обновляются, а значит рано или поздно избежать конфликтов версий уже не получится. Именно для таких случаев и предусмотрена возможность создания так называемых виртуальных окружений.
(от англ. virtual environment) – это изолированная среда для разработки python -проектов, использующая собственный набор из необходимой версии интерпретатора Python и сопутствующих библиотек.
Начиная с версии 3.3 в раздел « Software Packaging and Distribution » стандартной библиотеки Python был добавлен модуль venv, позволяющий без особых хлопот создавать виртуальные окружения для наших проектов (см. пример №3 ).
Пример №3. Создание вируальных сред с помощью модуля venv.
В результате выполнения скрипта примера в каталоге проекта my_prj будет создан подкаталог виртуального окружения venv с необходимым наборов файлов для его функционирования. Наиболее важными из них являются:
- \lib\site-packages\ (для ОС Windows ) или /lib/python*.*/site-packages/ (для ОС Ubuntu ) – используются для хранения устанавливаемых в виртуальное окружение пакетов. Только что созданное окружение обычно включает установленный пакет менеджера pip (если создание окружения выполнялось с параметром with_pip=True ) и пакет Setuptools . Далее, когда виртуальное окружение будет активировано, менеджер pip будет автоматически устанавливать все пакеты именно в данный каталог, а не в системный.
- \Scripts\ (для ОС Windows ) или /bin/ (для ОС Ubuntu ) – здесь располагается копия интерпретатора python , копия исполняемого файла pip , а также скрипты для активации и деактивации виртуального окружения.
Создавать виртуальные окружения можно и при помощи командной строки. Из нее также довольно просто активировать и деактивировать виртуальные окружения. Для этого в ОС Windows используются следующие команды:
- python -m venv venv_path или py -*.* -m venv venv_path (если установлена утилита « Python Launcher ») – создает виртуальное окружение по пути venv_path .
- venv_path\Scripts\activate.bat – активирует созданное виртуальное окружение.
- deactivate – деактивирует текущее активное виртуальное окружение (см. пример №4 ).
Пример №4. Работа с виртуальным окружением в Windows.
В примере мы создали виртуальное окружение для проекта my_prj , состоящего всего из одного файла main.py , в котором мы прописали инструкции для вывода пути к файлу интерпретатора ( print(sys.executable) ), а также информации об используемой версии Python ( print(sys.version_info) ). Данный файл мы запускали до активации виртуального окружения, во время активного состояния окружения (в самом начале командных строк стала появляться подсказка (venv) , свидетельствующая о том, что активировано виртуальное окружение) и после деактивации виртуального окружения. Соответственно ситуации менялся и результат выполнения скрипта: вне виртуального окружения вся выводимая информация указывала на системный интерпретатор (у меня по умолчанию используется Python 3.11 ), а при активном состоянии виртуального окружения – на интерпретатор виртуального окружения проекта, при создании которого использовался Python 3.9 .
Для ОС Ubuntu команды будут несколько отличаться (при этом модуль venv предварительно должен быть установлен отдельной командой sudo apt install python3-venv ):
- python3 -m venv venv_path – создает виртуальное окружение по пути venv_path , например, python3 -m venv ./venv .
- source venv_path/bin/activate – активирует созданное виртуальное окружение, например, source ./venv/bin/activate .
- deactivate – деактивирует текущее активное виртуальное окружение (см. пример №5 ).
Пример №5. Работа с виртуальным окружением в Ubuntu.
Как видим, в Линуксе все довольно похоже, но, например, не стоит забывать, что в командной строке вне виртуального окружения здесь стоит использовать команду python3 (или python3.* , если нужна какая-то конкретная установленная версия), хотя при активном виртуальном окружении достаточно использовать команду python , поскольку автоматически будет использоваться интерпретатор виртуального окружения той версии, под которой оно было создано.
Вовсе необязательно активировать созданное виртуальное окружение каждый раз, когда требуется запустить проект. В обеих операционных системах можно прописать путь к интерпретатору своего виртуального окружения в первой строке запускаемого скрипта. Делается это с помощью shebang -строки в формате #!evn_path\Script\python.exe для ОС Windows и #!evn_path\bin\python для ОС Ubuntu (см. пример №6 ).
Пример №6. Использование shebang-строки в python-скрипте.
Здесь важно помнить, что формат конца строк в этих системах отличается, а это может привести к неработоспособности всего скрипта. Кроме того, такие файлы из командной строки нужно запускать напрямую без использования команды запуска интерпретатора, указав лишь путь к файлу (и сделав их исполняемыми при необходимости). При чем в ОС Ubuntu , находясь в каталоге скрипта, нужно указывать помимо имени файла еще и текущую директорию в формате ./file_name.py (см. пример №7 ).
Пример №7. Запуск python-скриптов с shebang-строкой.
Если запускать скрипт с shebang -строкой не из консоли, а обычным двойным кликом мыши по ярлыку, запускаться также будет интерпретатор виртуального окружения, а не системный интерпретатор. Тот же эффект будет получен и при использовании консольной команды start main.py в ОС Windows .
Автоматизировать процесс запуска проекта в своем окружении можно и при помощи создания скриптов-оберток, которые будут активировать виртуальное окружение и запускать в нем главный файл проекта. Для ОС Windows следует использовать командный файл *.bat , а для ОС Ubuntu – bash -скрипт.
Что касается переноса проекта с виртуальным окружением на другую машину, то здесь необходимо придерживаться следующей последовательности действий.
- Активируем виртуальное окружение проекта.
- Сохраняем все зависимости командой python -m pip freeze > requirements.txt .
- Сам каталог виртуального окружения удаляем (именно поэтому не стоит хранить файл requirements.txt в этом каталоге).
- На новом месте виртуальное окружение проекта устанавливаем заново, не забыв использовать для него требуемую версию Python .
- Активируем виртуальное окружение проекта.
- Восстановливаем все зависимости, установив их командой python -m pip install -r requirements.txt .
- Если никаких работ внутри окружения не предвидится, деактивируем его.
Готовую учебную программу «Консольный менеджер проектов» вам предстоит разобрать в качестве задания в разделе « Python :: Коды, программы, скрипты ». Данный менеджер – это отличная практическая возможность закрепить теоретические знания по работе с виртуальными окружениями, которые далее будут присутствовать практически в любом разрабатываемом вами проекте.
Краткие итоги параграфа
- Для подключения дополнительных модулей и пакетов, не входящих в состав стандартной библиотеки Python , широко используется менеджер пакетов pip , который довольно просто позволяет устанавливать пакеты из раздела Python Package Index официального сайта. Если он успешно установлен, обратиться к нему из командной строки можно через python -m pip для ОС Windows или python3 -m pip для ОС Ubuntu добавив через пробел необходимую команду. Перечислим некоторые из них:
- —version – вывести текущую версию pip .
- help – показать справку по доступным командам.
- install —upgrade pip – обновить утилиту.
- install package_name – установить пакет последней версии. Если нужна конкретная версия пакета, необходимо указывать ее в формате install package_name==specific_version , например, install numpy==1.23.4 . Можно также указывать минимально допустимую версию, тогда нужно использовать формат install ‘package_name>=minimum_version’ , например, install ‘numpy>=1.23.4’ .
- show package_name – показать информацию о пакете.
- list – показать список уже установленных пакетов (самостоятельно можете посмотреть их в домашнем каталоге Питона в lib\site-packages ).
- uninstall package_name – деинсталлировать пакет.
- install —force-reinstall package_name – принудительно переустановить пакет (либо установить, если он отсутствует).
- freeze > requirements.txt – команда создает обычный текстовый документ requirements.txt , в котором по одному в строке перечисляются все установленные и необходимые для работы данного python -приложения программные пакеты.
- install -r requirements.txt – команда устанавливает в текущее окружение (обычно активированное виртуальное окружение) все перечисленные в файле зависимости проекта программные пакеты. Обычно это необходимо при переносе проекта на другую машину (подробнее об этом чуть ниже).
- python -m venv venv_path или py -*.* -m venv venv_path – создает виртуальное окружение по пути venv_path (во втором случае должна быть установлена утилита « Python Launcher »).
- venv_path\Scripts\activate.bat – активирует созданное виртуальное окружение.
- deactivate – деактивирует текущее активное виртуальное окружение.
- python3 -m venv venv_path – создает виртуальное окружение по пути venv_path .
- source venv_path/bin/activate – активирует созданное виртуальное окружение.
- deactivate – деактивирует текущее активное виртуальное окружение.
Вопросы и задания для самоконтроля
1. Для чего используется менеджер пакетов pip ? Показать решение.
Ответ. Менеджер пакетов pip используется для установки и управления сторонними программными пакетами и библиотеками, написанными на Python . А это более 90 000 модулей и пакетов, которые могут быть достаточно легко установлены из раздела PyPI официального сайта.
2. Какую команду менеджера нужно использовать, чтобы установить пакет последней версии? Удалить его? Показать решение.
Ответ. Для установки пакета последней версии предназначена команда install package_name . Если нужна конкретная версия пакета, необходимо указывать ее в формате install package_name==specific_version . Можно также указывать минимально допустимую версию, тогда нужно использовать формат install ‘package_name>=minimum_version’ . Деинсталлировать установленный пакет можно командой uninstall package_name .
3. Напишите полную консольную команду для сохранения зависимостей текущего окружения в файл requirements.txt , а также для установки их обратно из файла. Показать решение.
Ответ. В ОС Ubuntu : python3 -m pip freeze > requirements.txt (туда) и python3 -m pip install -r requirements.txt (обратно). В ОС Windows : python -m pip freeze > requirements.txt (туда) и python -m pip install -r requirements.txt (обратно). Если все установлено правильно, то сработают также общие для обеих систем команды pip3 freeze > requirements.txt (туда) и pip3 install -r requirements.txt (обратно).
4. Что представляет из себя виртуальное окружение? Показать решение.
Ответ. Виртуальное окружение Python – это изолированная среда для разработки python -проектов, использующая собственный набор из необходимой версии интерпретатора Python и сопутствующих библиотек.
5. Напишите команду для создания виртуального окружения в подкаталоге virt , зная, что в командной оболочке вы находитесь в корневом каталоге проекта. Используйте для этого Python 3.8 . Показать решение.
Ответ. В ОС Windows : py -3.8 -m venv .\virt . В ОС Ubuntu : python3.8 -m venv ./virt .
6. Как создать виртуальное окружение из скрипта, использовав для этого модуль venv стандартной библиотеки? Показать решение.
Ответ. Необходимо импортировать модуль venv , а затем воспользоваться методом venv.create или классом venv.EnvBuilder и его методом create (посмотрите еще раз пример №3 ).
7. Как активировать и деактивировать виртуальное окружение, находясь в командной оболочке в корневом каталоге проекта и зная, что виртуальное окружение было установлено в каталог prj_venv ? Показать решение.
Ответ. Для активации виртуального окружения необходимо выполнить команду .\prj_venv\Scripts\activate.bat для ОС Windows или source ./prj_venv/bin/activate для ОС Ubuntu . Деактивация производится общей командой deactivate .
8. Как запустить проект в своем виртуальном окружении без его предварительной активации? Показать решение.
Ответ. Чтобы не активировать созданное виртуальное окружение каждый раз, когда требуется запустить проект, в обеих операционных системах можно прописать путь к интерпретатору своего виртуального окружения в первой строке запускаемого скрипта. Делается это с помощью shebang -строки в формате #!evn_path\Script\python.exe для ОС Windows и #!evn_path\bin\python для ОС Ubuntu (здесь следует быть внимательным с форматом конца строк, т.к. он отличается в этих системах, что может привести к неработоспособности всего скрипта). Также можно создать скрипты-обертки, которые будут активировать виртуальное окружение и запускать в нем главный файл проекта. Для ОС Windows следует использовать командный файл *.bat , а для ОС Ubuntu – bash -скрипт.
9. Назовите основные этапы переноса проекта с виртуальным окружением на другой компьютер? Показать решение.
Ответ. При переносе проекта на другой компьютер все зависимости проекта предварительно сохраняются в файле requirements.txt , а сам каталог с виртуальным окружением удаляется. На новом месте совершается обратный процесс: заново устанавливается виртуальное окружение для заданной версии Python , а также восстанавливаются все зависимости из файла requirements.txt .
10. Дополнительные упражнения и задачи по теме расположены в разделе «Утилита pip и виртуальные окружения» нашего сборника задач и упражнений по языку программирования Python .
# Что такое библиотеки?
Библиотека или модуль — это набор готовых функций, объединенных общей темой. Например, в библиотеке math собраны функции для подсчёта математических величин.
Чтобы получить доступ к этим функциям, нужно командой import (англ. «импорт») в начале программы импортировать библиотеку. Это ещё называется «подключить модуль». В случае math пишут import math . Вот вызов извлекающей квадратный корень функции sqrt() из этой библиотеки:
Уже знакомая вам функция randint() из модуля random выбирает случайное целое число в заданном диапазоне. Но есть и другие, например:
- random.choice(список) вернёт случайный элемент из списка
- random.random() вернёт случайное дробное число от 0.0 до 1.0 (не включительно)
Если вам не нужны все функции библиотеки, можно подключить только нужные конструкцией from random import choice (из библиотеки random подключить функцию choice ).
Вот код для выбора подарка ребёнку. После явного подключения функции choice её можно использовать напрямую, без упоминания имени библиотеки.
Запустите этот код: результат может быть совсем другим!
Подключая библиотеку, можно присвоить ей новое имя. Например, если не хочется при каждом вызове писать полное имя: