Edit this page
Toggle table of contents sidebar
Usually, pip is automatically installed if you are:
-
working in a
virtual environment -
using Python downloaded from python.org
-
using Python that has not been modified by a redistributor to remove
ensurepip
Supported Methods#
If your Python environment does not have pip installed, there are 2 mechanisms
to install pip supported directly by pip’s maintainers:
-
ensurepip
-
get-pip.py
ensurepip
#
Python comes with an ensurepip
module[1], which can install pip in
a Python environment.
Linux
$ python -m ensurepip --upgrade
MacOS
$ python -m ensurepip --upgrade
Windows
C:> py -m ensurepip --upgrade
More details about how ensurepip
works and how it can be used, is
available in the standard library documentation.
get-pip.py
#
This is a Python script that uses some bootstrapping logic to install
pip.
-
Download the script, from https://bootstrap.pypa.io/get-pip.py.
-
Open a terminal/command prompt,
cd
to the folder containing the
get-pip.py
file and run:
More details about this script can be found in pypa/get-pip’s README.
Standalone zip application#
Note
The zip application is currently experimental. We test that pip runs correctly
in this form, but it is possible that there could be issues in some situations.
We will accept bug reports in such cases, but for now the zip application should
not be used in production environments.
In addition to installing pip in your environment, pip is available as a
standalone zip application.
This can be downloaded from https://bootstrap.pypa.io/pip/pip.pyz. There are
also zip applications for specific pip versions, named pip-X.Y.Z.pyz
.
The zip application can be run using any supported version of Python:
If run directly:
Linux
$ python -m pip.pyz --help
MacOS
$ python -m pip.pyz --help
Windows
then the currently active Python interpreter will be used.
Alternative Methods#
Depending on how you installed Python, there might be other mechanisms
available to you for installing pip such as
using Linux package managers.
These mechanisms are provided by redistributors of pip, who may have modified
pip to change its behaviour. This has been a frequent source of user confusion,
since it causes a mismatch between documented behaviour in this documentation
and how pip works after those modifications.
If you face issues when using Python and pip installed using these mechanisms,
it is recommended to request for support from the relevant provider (eg: Linux
distro community, cloud provider support channels, etc).
Upgrading pip
#
Upgrade your pip
by running:
Linux
$ python -m pip install --upgrade pip
MacOS
$ python -m pip install --upgrade pip
Windows
C:> py -m pip install --upgrade pip
Compatibility#
The current version of pip works on:
-
Windows, Linux and MacOS.
-
CPython 3.7, 3.8, 3.9, 3.10 and latest PyPy3.
pip is tested to work on the latest patch version of the Python interpreter,
for each of the minor versions listed above. Previous patch versions are
supported on a best effort approach.
Other operating systems and Python versions are not supported by pip’s
maintainers.
Users who are on unsupported platforms should be aware that if they hit issues, they may have to resolve them for themselves. If they received pip from a source which provides support for their platform, they should request pip support from that source.
Что представляют собой пакеты и модули, откуда их брать и что с ними делать.
https://gbcdn.mrgcdn.ru/uploads/post/1340/og_cover_image/a9b1c9e84cf2c603aa80f227403c4177
Прежде чем что-то устанавливать, давайте разберёмся, что такое пакет, чем он отличается от модуля, и как с ним работать. У слова «пакет» применительно к Python два значения.
C одной стороны, пакеты Python — это Py-приложения, дополнения или утилиты, которые можно установить из внешнего репозитория: Github, Bitbucket, Google Code или официального Python Package Index. На сервере пакеты хранятся в .zip и .tar архивах, либо в дополнительной упаковке — «яйцах» (.egg, старый формат) или «колесах» (.whl). В составе пакета, как правило, есть сценарий установки setup.py, который хранит сведения о зависимостях — других пакетах и модулях, без которых пакет работать не будет.
С другой стороны, если речь об архитектуре Python-приложения, пакет — это каталог, внутри которого файл __init__.py и, опционально, другие каталоги и файлы .py. Так большую Python-программу разбивают на пакеты и модули. Модуль — файл с исходным кодом, который можно использовать в других приложениях: как «заготовку» для будущих проектов или как часть библиотеки/фреймворка. Но к теме статьи это прямого отношения не имеет, поэтому дальше мы будем говорить только о пакетах из репозиториев.
Чтобы за секунды устанавливать пакеты со всеми зависимостями, используют менеджер пакетов pip или модуль easy_install. В большинстве случаев рекомендуется использовать pip. И только если у вас есть инфраструктура на пакетах .egg, которые pip не открывает, нужен easy_install.
Установка PIP для Python 3 и 2
Если вы используете виртуальные окружения на базе venv или virtualenv, pip уже установлен. Начиная с Python 3.4 (для Python 2 — с версии 2.7.9) pip поставляется вместе с интерпретатором. Для более ранних версий устанавливать менеджер пакетов нужно вручную. Вариантов два:
-
C помощью скрипта get_pip.py — быстро.
-
Через setuptools — кроме pip сможем использовать easy_install.
Вариант 1. Скачиваем скрипт get_pip.py и запускаем в консоли. Для этого открываем терминал через Win+R>»cmd»>OK и пишем:
python get_pip.py
Остальное установщик сделает сам: если нужно, попутно установит wheel (для распаковки .whl-колес) и setuptools. Чтобы запретить инсталляцию дополнительных инструментов, можно добавить в строку ключи —no-setuptools и/или —no-wheels.
Если возникает ошибка, путь к Python не прописан в переменной среды $PATH. Нужно либо найти эту переменную в системном реестре и задать её значение, либо каждый раз указывать полный путь до python.exe, а за ним уже имя исполняемого Py-файла:
C:/python32/python.exe get_pip.py
Полный путь полезен и в том случае, если у вас на компьютере несколько версий Python и вы ставите пакет для одной из них.
Вариант 2. Скачиваем архив с setuptools из PYPI и распаковываем в отдельный каталог. В терминале переходим в директорию setuptools c файлом setup.py и пишем:
python setup.py install
Обновить pip для Python в Windows можно так:
python pip install -U pip
Если это не работает, нужно добавить путь к папке с pip в $PATH.
Установка пакета в pip
Пора запустить pip в Python и начать устанавливать пакеты короткой командой из консоли:
pip install имя_пакета
При установке в Windows, перед pip нужно добавить «python -m».
Обновить пакет не сложнее:
pip install имя_пакета -U
Если у вас последняя версия пакета, но вы хотите принудительно переустановить его:
pip install --force-reinstall
Посмотреть список установленных пакетов Python можно с помощью команды:
pip list
Найти конкретный пакет по имени можно командой «pip search». О других командах можно прочесть в справке, которая выдается по команде «pip help».
Удаление пакета Python
Когда пакет больше не нужен, пишем:
pip uninstall имя_пакета
Как установить пакеты в Python без pip
Формат .egg сейчас используют не часто, поэтому pip его не поддерживает. Модуль easy_install умеет устанавливать как .egg, так и обычные пакеты, но есть у него важные минусы:
-
он не удаляет пакеты,
-
он может пытаться установить недозагруженный пакет.
Использовать easy_install можно сразу после установки setuptools. Хранится модуль в папке Scripts вашего интерпретатора. Если у вас в $PATH верно прописан путь, ставить пакеты из PYPI можно короткой командой:
easy_install имя_пакета
Для обновления после install и перед именем пакета нужно ставить ключ -U. Откатиться до нужной версии можно так:
easy_install имя_пакета=0.2.3
Если нужно скачать пакет из альтернативного источника, вы можете задать URL или локальный адрес на компьютере:
easy_install http://адрес_репозитория.ру/директория/пакет-1.1.2.zip
Чтобы узнать об опциях easy_install, запустим его с ключом -h:
easy_install -h
Список пакетов, установленных через easy_install, хранится в файле easy-install.pth в директории /libs/site-packages/ вашего Python.
К счастью, удалять установленные через easy_install пакеты можно с помощью pip. Если же его нет, потребуется удалить пакет вручную и стереть сведения о нем из easy-install.pth.
Теперь вы умеете ставить и удалять пакеты для вашей версии Python.
Кстати, для тех, кто изучает Python, мы подготовили список полезных и практичных советов.
В процессе разработки программного обеспечения на Python часто возникает необходимость воспользоваться пакетом, который в данный момент отсутствует на вашем компьютере. О том, откуда взять нужный вам пакет и как его установить, вы узнаете из этого урока.
- Где взять отсутствующий пакет?
- Менеджер пакетов в Python – pip
- Установка pip
- Обновление pip
- Использование pip
- Установка пакета
- Удаление пакета
- Обновление пакетов
- Просмотр установленных пакетов
- Поиск пакета в репозитории
- Где еще можно почитать про работу с pip?
Где взять отсутствующий пакет?
Необходимость в установке дополнительного пакета возникнет очень быстро, если вы решите поработать над задачей, за рамками базового функционала, который предоставляет Python. Например: работа с web, обработка изображений, криптография и т.п. В этом случае, необходимо узнать, какой пакет содержит функционал, который вам необходим, найти его, скачать, разместить в нужном каталоге и начать использовать. Все эти действия можно сделать вручную, но этот процесс поддается автоматизации. К тому же скачивать пакеты с неизвестных сайтов может быть довольно опасно.
К счастью для нас, в рамках Python, все эти задачи решены. Существует так называемый Python Package Index (PyPI) – это репозиторий, открытый для всех Python разработчиков, в нем вы можете найти пакеты для решения практически любых задач. Там также есть возможность выкладывать свои пакеты. Для скачивания и установки используется специальная утилита, которая называется pip.
Менеджер пакетов в Python – pip
Pip – это консольная утилита (без графического интерфейса). После того, как вы ее скачаете и установите, она пропишется в PATH и будет доступна для использования.
Эту утилиту можно запускать как самостоятельно:
> pip <аргументы>
так и через интерпретатор Python:
> python -m pip <аргументы>
Ключ -m означает, что мы хотим запустить модуль (в данном случае pip). Более подробно о том, как использовать pip, вы сможете прочитать ниже.
Установка pip
При развертывании современной версии Python (начиная с Python 2.7.9 и Python 3.4),
pip устанавливается автоматически. Но если, по какой-то причине, pip не установлен на вашем ПК, то сделать это можно вручную. Существует несколько способов.
Универсальный способ
Будем считать, что Python у вас уже установлен, теперь необходимо установить pip. Для того, чтобы это сделать, скачайте скрипт get-pip.py
> curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
и выполните его.
> python get-pip.py
При этом, вместе с pip будут установлены setuptools и wheels. Setuptools – это набор инструментов для построения пакетов Python. Wheels – это формат дистрибутива для пакета Python. Обсуждение этих составляющих выходит за рамки урока, поэтому мы не будем на них останавливаться.
Способ для Linux
Если вы используете Linux, то для установки pip можно воспользоваться имеющимся в вашем дистрибутиве пакетным менеджером. Ниже будут перечислены команды для ряда Linux систем, запускающие установку pip (будем рассматривать только Python 3, т.к. Python 2 уже морально устарел, а его поддержка и развитие будут прекращены после 2020 года).
Fedora
Fedora 21:
> sudo yum install python3 python3-wheel
Fedora 22:
> sudo dnf install python3 python3-wheel
openSUSE
> sudo zypper install python3-pip python3-setuptools python3-wheel
Debian/Ubuntu
> sudo apt install python3-venv python3-pip
Arch Linux
> sudo pacman -S python-pip
Обновление pip
Если вы работаете с Linux, то для обновления pip запустите следующую команду.
> pip install -U pip
Для Windows команда будет следующей:
> python -m pip install -U pip
Использование pip
Далее рассмотрим основные варианты использования pip: установка пакетов, удаление и обновление пакетов.
Установка пакета
Pip позволяет установить самую последнюю версию пакета, конкретную версию или воспользоваться логическим выражением, через которое можно определить, что вам, например, нужна версия не ниже указанной. Также есть поддержка установки пакетов из репозитория. Рассмотрим, как использовать эти варианты.
Установка последней версии пакета
> pip install ProjectName
Установка определенной версии
> pip install ProjectName==3.2
Установка пакета с версией не ниже 3.1
> pip install ProjectName>=3.1
Установка Python пакета из git репозитория
> pip install -e git+https://gitrepo.com/ProjectName.git
Установка из альтернативного индекса
> pip install --index-url http://pypackage.com/ ProjectName
Установка пакета из локальной директории
> pip install ./dist/ProjectName.tar.gz
Удаление пакета
Для того, чтобы удалить пакет воспользуйтесь командой
> pip uninstall ProjectName
Обновление пакетов
Для обновления пакета используйте ключ –upgrade.
> pip install --upgrade ProjectName
Просмотр установленных пакетов
Для вывода списка всех установленных пакетов применяется команда pip list.
> pip list
Если вы хотите получить более подробную информацию о конкретном пакете, то используйте аргумент show.
> pip show ProjectName
Поиск пакета в репозитории
Если вы не знаете точное название пакета, или хотите посмотреть на пакеты, содержащие конкретное слово, то вы можете это сделать, используя аргумент search.
> pip search "test"
Где ещё можно прочитать про работу с pip?
В сети довольно много информации по работе с данной утилитой.
Python Packaging User Guide – набор различных руководств по работе с пакетами в Python
Документация по pip.
Статья на Geekbrains.
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
<<< Python. Урок 15. Итераторы и генераторы Python. Урок 17. Виртуальные окружения>>>
User Guide
Running pip
pip is a command line program. When you install pip, a pip
command is added
to your system, which can be run from the command prompt as follows:
.. tab:: Unix/macOS .. code-block:: shell python -m pip <pip arguments> ``python -m pip`` executes pip using the Python interpreter you specified as python. So ``/usr/bin/python3.7 -m pip`` means you are executing pip for your interpreter located at ``/usr/bin/python3.7``.
.. tab:: Windows .. code-block:: shell py -m pip <pip arguments> ``py -m pip`` executes pip using the latest Python interpreter you have installed. For more details, read the `Python Windows launcher`_ docs.
Installing Packages
pip supports installing from PyPI, version control, local projects, and
directly from distribution files.
The most common scenario is to install from PyPI using :ref:`Requirement
Specifiers`
.. tab:: Unix/macOS .. code-block:: shell python -m pip install SomePackage # latest version python -m pip install SomePackage==1.0.4 # specific version python -m pip install 'SomePackage>=1.0.4' # minimum version
.. tab:: Windows .. code-block:: shell py -m pip install SomePackage # latest version py -m pip install SomePackage==1.0.4 # specific version py -m pip install 'SomePackage>=1.0.4' # minimum version
For more information and examples, see the :ref:`pip install` reference.
Basic Authentication Credentials
This is now covered in :doc:`topics/authentication`.
netrc Support
This is now covered in :doc:`topics/authentication`.
Keyring Support
This is now covered in :doc:`topics/authentication`.
Using a Proxy Server
When installing packages from PyPI, pip requires internet access, which
in many corporate environments requires an outbound HTTP proxy server.
pip can be configured to connect through a proxy server in various ways:
- using the
--proxy
command-line option to specify a proxy in the form
scheme://[user:passwd@]proxy.server:port
- using
proxy
in a :ref:`config-file` - by setting the standard environment-variables
http_proxy
,https_proxy
andno_proxy
. - using the environment variable
PIP_USER_AGENT_USER_DATA
to include
a JSON-encoded string in the user-agent variable used in pip’s requests.
Requirements Files
«Requirements files» are files containing a list of items to be
installed using :ref:`pip install` like so:
.. tab:: Unix/macOS .. code-block:: shell python -m pip install -r requirements.txt
.. tab:: Windows .. code-block:: shell py -m pip install -r requirements.txt
Details on the format of the files are here: :ref:`requirements-file-format`.
Logically, a Requirements file is just a list of :ref:`pip install` arguments
placed in a file. Note that you should not rely on the items in the file being
installed by pip in any particular order.
Requirements files can also be served via a URL, e.g.
http://example.com/requirements.txt besides as local files, so that they can
be stored and served in a centralized place.
In practice, there are 4 common uses of Requirements files:
-
Requirements files are used to hold the result from :ref:`pip freeze` for the
purpose of achieving :doc:`topics/repeatable-installs`. In
this case, your requirement file contains a pinned version of everything that
was installed whenpip freeze
was run... tab:: Unix/macOS .. code-block:: shell python -m pip freeze > requirements.txt python -m pip install -r requirements.txt
.. tab:: Windows .. code-block:: shell py -m pip freeze > requirements.txt py -m pip install -r requirements.txt
-
Requirements files are used to force pip to properly resolve dependencies.
pip 20.2 and earlier doesn’t have true dependency resolution, but instead simply uses the first
specification it finds for a project. E.g. ifpkg1
requires
pkg3>=1.0
andpkg2
requirespkg3>=1.0,<=2.0
, and ifpkg1
is
resolved first, pip will only usepkg3>=1.0
, and could easily end up
installing a version ofpkg3
that conflicts with the needs ofpkg2
.
To solve this problem, you can placepkg3>=1.0,<=2.0
(i.e. the correct
specification) into your requirements file directly along with the other top
level requirements. Like so:pkg1 pkg2 pkg3>=1.0,<=2.0
-
Requirements files are used to force pip to install an alternate version of a
sub-dependency. For example, supposeProjectA
in your requirements file
requiresProjectB
, but the latest version (v1.3) has a bug, you can force
pip to accept earlier versions like so:ProjectA ProjectB<1.3
-
Requirements files are used to override a dependency with a local patch that
lives in version control. For example, suppose a dependency
SomeDependency
from PyPI has a bug, and you can’t wait for an upstream
fix.
You could clone/copy the src, make the fix, and place it in VCS with the tag
sometag
. You’d reference it in your requirements file with a line like
so:git+https://myvcs.com/some_dependency@sometag#egg=SomeDependency
If
SomeDependency
was previously a top-level requirement in your
requirements file, then replace that line with the new line. If
SomeDependency
is a sub-dependency, then add the new line.
It’s important to be clear that pip determines package dependencies using
install_requires metadata,
not by discovering requirements.txt
files embedded in projects.
See also:
- :ref:`requirements-file-format`
- :ref:`pip freeze`
- «setup.py vs requirements.txt» (an article by Donald Stufft)
Constraints Files
Constraints files are requirements files that only control which version of a
requirement is installed, not whether it is installed or not. Their syntax and
contents is a subset of :ref:`Requirements Files`, with several kinds of syntax
not allowed: constraints must have a name, they cannot be editable, and they
cannot specify extras. In terms of semantics, there is one key difference:
Including a package in a constraints file does not trigger installation of the
package.
Use a constraints file like so:
.. tab:: Unix/macOS .. code-block:: shell python -m pip install -c constraints.txt
.. tab:: Windows .. code-block:: shell py -m pip install -c constraints.txt
Constraints files are used for exactly the same reason as requirements files
when you don’t know exactly what things you want to install. For instance, say
that the «helloworld» package doesn’t work in your environment, so you have a
local patched version. Some things you install depend on «helloworld», and some
don’t.
One way to ensure that the patched version is used consistently is to
manually audit the dependencies of everything you install, and if «helloworld»
is present, write a requirements file to use when installing that thing.
Constraints files offer a better way: write a single constraints file for your
organisation and use that everywhere. If the thing being installed requires
«helloworld» to be installed, your fixed version specified in your constraints
file will be used.
Constraints file support was added in pip 7.1. In :ref:`Resolver
changes 2020` we did a fairly comprehensive overhaul, removing several
undocumented and unsupported quirks from the previous implementation,
and stripped constraints files down to being purely a way to specify
global (version) limits for packages.
Same as requirements files, constraints files can also be served via a URL,
e.g. http://example.com/constraints.txt, so that your organization can store and
serve them in a centralized place.
Installing from Wheels
«Wheel» is a built, archive format that can greatly speed installation compared
to building and installing from source archives. For more information, see the
Wheel docs , PEP 427, and PEP 425.
pip prefers Wheels where they are available. To disable this, use the
:ref:`—no-binary <install_—no-binary>` flag for :ref:`pip install`.
If no satisfactory wheels are found, pip will default to finding source
archives.
To install directly from a wheel archive:
.. tab:: Unix/macOS .. code-block:: shell python -m pip install SomePackage-1.0-py2.py3-none-any.whl
.. tab:: Windows .. code-block:: shell py -m pip install SomePackage-1.0-py2.py3-none-any.whl
To include optional dependencies provided in the provides_extras
metadata in the wheel, you must add quotes around the install target
name:
.. tab:: Unix/macOS .. code-block:: shell python -m pip install './somepackage-1.0-py2.py3-none-any.whl[my-extras]'
.. tab:: Windows .. code-block:: shell py -m pip install './somepackage-1.0-py2.py3-none-any.whl[my-extras]'
Note
In the future, the path[extras]
syntax may become deprecated. It is
recommended to use PEP 508 syntax wherever possible.
For the cases where wheels are not available, pip offers :ref:`pip wheel` as a
convenience, to build wheels for all your requirements and dependencies.
:ref:`pip wheel` requires the wheel package to be installed, which provides the
«bdist_wheel» setuptools extension that it uses.
To build wheels for your requirements and all their dependencies to a local
directory:
.. tab:: Unix/macOS .. code-block:: shell python -m pip install wheel python -m pip wheel --wheel-dir=/local/wheels -r requirements.txt
.. tab:: Windows .. code-block:: shell py -m pip install wheel py -m pip wheel --wheel-dir=/local/wheels -r requirements.txt
And then to install those requirements just using your local directory of
wheels (and not from PyPI):
.. tab:: Unix/macOS .. code-block:: shell python -m pip install --no-index --find-links=/local/wheels -r requirements.txt
.. tab:: Windows .. code-block:: shell py -m pip install --no-index --find-links=/local/wheels -r requirements.txt
Uninstalling Packages
pip is able to uninstall most packages like so:
.. tab:: Unix/macOS .. code-block:: shell python -m pip uninstall SomePackage
.. tab:: Windows .. code-block:: shell py -m pip uninstall SomePackage
pip also performs an automatic uninstall of an old version of a package
before upgrading to a newer version.
For more information and examples, see the :ref:`pip uninstall` reference.
Listing Packages
To list installed packages:
.. tab:: Unix/macOS .. code-block:: console $ python -m pip list docutils (0.9.1) Jinja2 (2.6) Pygments (1.5) Sphinx (1.1.2)
.. tab:: Windows .. code-block:: console C:> py -m pip list docutils (0.9.1) Jinja2 (2.6) Pygments (1.5) Sphinx (1.1.2)
To list outdated packages, and show the latest version available:
.. tab:: Unix/macOS .. code-block:: console $ python -m pip list --outdated docutils (Current: 0.9.1 Latest: 0.10) Sphinx (Current: 1.1.2 Latest: 1.1.3)
.. tab:: Windows .. code-block:: console C:> py -m pip list --outdated docutils (Current: 0.9.1 Latest: 0.10) Sphinx (Current: 1.1.2 Latest: 1.1.3)
To show details about an installed package:
.. tab:: Unix/macOS .. code-block:: console $ python -m pip show sphinx --- Name: Sphinx Version: 1.1.3 Location: /my/env/lib/pythonx.x/site-packages Requires: Pygments, Jinja2, docutils
.. tab:: Windows .. code-block:: console C:> py -m pip show sphinx --- Name: Sphinx Version: 1.1.3 Location: /my/env/lib/pythonx.x/site-packages Requires: Pygments, Jinja2, docutils
For more information and examples, see the :ref:`pip list` and :ref:`pip show`
reference pages.
Searching for Packages
pip can search PyPI for packages using the pip search
command:
.. tab:: Unix/macOS .. code-block:: shell python -m pip search "query"
.. tab:: Windows .. code-block:: shell py -m pip search "query"
The query will be used to search the names and summaries of all
packages.
For more information and examples, see the :ref:`pip search` reference.
Configuration
This is now covered in :doc:`topics/configuration`.
Config file
This is now covered in :doc:`topics/configuration`.
Environment Variables
This is now covered in :doc:`topics/configuration`.
Config Precedence
This is now covered in :doc:`topics/configuration`.
Command Completion
pip comes with support for command line completion in bash, zsh and fish.
To setup for bash:
python -m pip completion --bash >> ~/.profile
To setup for zsh:
python -m pip completion --zsh >> ~/.zprofile
To setup for fish:
python -m pip completion --fish > ~/.config/fish/completions/pip.fish
To setup for powershell:
python -m pip completion --powershell | Out-File -Encoding default -Append $PROFILE
Alternatively, you can use the result of the completion
command directly
with the eval function of your shell, e.g. by adding the following to your
startup file:
eval "`pip completion --bash`"
Installing from local packages
In some cases, you may want to install from local packages only, with no traffic
to PyPI.
First, download the archives that fulfill your requirements:
.. tab:: Unix/macOS .. code-block:: shell python -m pip download --destination-directory DIR -r requirements.txt
.. tab:: Windows .. code-block:: shell py -m pip download --destination-directory DIR -r requirements.txt
Note that pip download
will look in your wheel cache first, before
trying to download from PyPI. If you’ve never installed your requirements
before, you won’t have a wheel cache for those items. In that case, if some of
your requirements don’t come as wheels from PyPI, and you want wheels, then run
this instead:
.. tab:: Unix/macOS .. code-block:: shell python -m pip wheel --wheel-dir DIR -r requirements.txt
.. tab:: Windows .. code-block:: shell py -m pip wheel --wheel-dir DIR -r requirements.txt
Then, to install from local only, you’ll be using :ref:`—find-links
<install_—find-links>` and :ref:`—no-index <install_—no-index>` like so:
.. tab:: Unix/macOS .. code-block:: shell python -m pip install --no-index --find-links=DIR -r requirements.txt
.. tab:: Windows .. code-block:: shell py -m pip install --no-index --find-links=DIR -r requirements.txt
«Only if needed» Recursive Upgrade
pip install --upgrade
now has a --upgrade-strategy
option which
controls how pip handles upgrading of dependencies. There are 2 upgrade
strategies supported:
eager
: upgrades all dependencies regardless of whether they still satisfy
the new parent requirementsonly-if-needed
: upgrades a dependency only if it does not satisfy the new
parent requirements
The default strategy is only-if-needed
. This was changed in pip 10.0 due to
the breaking nature of eager
when upgrading conflicting dependencies.
It is important to note that --upgrade
affects direct requirements (e.g.
those specified on the command-line or via a requirements file) while
--upgrade-strategy
affects indirect requirements (dependencies of direct
requirements).
As an example, say SomePackage
has a dependency, SomeDependency
, and
both of them are already installed but are not the latest available versions:
pip install SomePackage
: will not upgrade the existingSomePackage
or
SomeDependency
.pip install --upgrade SomePackage
: will upgradeSomePackage
, but not
SomeDependency
(unless a minimum requirement is not met).pip install --upgrade SomePackage --upgrade-strategy=eager
: upgrades both
SomePackage
andSomeDependency
.
As an historic note, an earlier «fix» for getting the only-if-needed
behaviour was:
.. tab:: Unix/macOS .. code-block:: shell python -m pip install --upgrade --no-deps SomePackage python -m pip install SomePackage
.. tab:: Windows .. code-block:: shell py -m pip install --upgrade --no-deps SomePackage py -m pip install SomePackage
A proposal for an upgrade-all
command is being considered as a safer
alternative to the behaviour of eager upgrading.
User Installs
With Python 2.6 came the «user scheme» for installation,
which means that all Python distributions support an alternative install
location that is specific to a user. The default location for each OS is
explained in the python documentation for the site.USER_BASE variable.
This mode of installation can be turned on by specifying the :ref:`—user
<install_—user>` option to pip install
.
Moreover, the «user scheme» can be customized by setting the
PYTHONUSERBASE
environment variable, which updates the value of
site.USER_BASE
.
To install «SomePackage» into an environment with site.USER_BASE
customized to
‘/myappenv’, do the following:
.. tab:: Unix/macOS .. code-block:: shell export PYTHONUSERBASE=/myappenv python -m pip install --user SomePackage
.. tab:: Windows .. code-block:: shell set PYTHONUSERBASE=c:/myappenv py -m pip install --user SomePackage
pip install --user
follows four rules:
- When globally installed packages are on the python path, and they conflict
with the installation requirements, they are ignored, and not
uninstalled. - When globally installed packages are on the python path, and they satisfy
the installation requirements, pip does nothing, and reports that
requirement is satisfied (similar to how global packages can satisfy
requirements when installing packages in a--system-site-packages
virtualenv). - pip will not perform a
--user
install in a--no-site-packages
virtualenv (i.e. the default kind of virtualenv), due to the user site not
being on the python path. The installation would be pointless. - In a
--system-site-packages
virtualenv, pip will not install a package
that conflicts with a package in the virtualenv site-packages. The —user
installation would lack sys.path precedence and be pointless.
To make the rules clearer, here are some examples:
From within a --no-site-packages
virtualenv (i.e. the default kind):
.. tab:: Unix/macOS .. code-block:: console $ python -m pip install --user SomePackage Can not perform a '--user' install. User site-packages are not visible in this virtualenv.
.. tab:: Windows .. code-block:: console C:> py -m pip install --user SomePackage Can not perform a '--user' install. User site-packages are not visible in this virtualenv.
From within a --system-site-packages
virtualenv where SomePackage==0.3
is already installed in the virtualenv:
.. tab:: Unix/macOS .. code-block:: console $ python -m pip install --user SomePackage==0.4 Will not install to the user site because it will lack sys.path precedence
.. tab:: Windows .. code-block:: console C:> py -m pip install --user SomePackage==0.4 Will not install to the user site because it will lack sys.path precedence
From within a real python, where SomePackage
is not installed globally:
.. tab:: Unix/macOS .. code-block:: console $ python -m pip install --user SomePackage [...] Successfully installed SomePackage
.. tab:: Windows .. code-block:: console C:> py -m pip install --user SomePackage [...] Successfully installed SomePackage
From within a real python, where SomePackage
is installed globally, but
is not the latest version:
.. tab:: Unix/macOS .. code-block:: console $ python -m pip install --user SomePackage [...] Requirement already satisfied (use --upgrade to upgrade) $ python -m pip install --user --upgrade SomePackage [...] Successfully installed SomePackage
.. tab:: Windows .. code-block:: console C:> py -m pip install --user SomePackage [...] Requirement already satisfied (use --upgrade to upgrade) C:> py -m pip install --user --upgrade SomePackage [...] Successfully installed SomePackage
From within a real python, where SomePackage
is installed globally, and
is the latest version:
.. tab:: Unix/macOS .. code-block:: console $ python -m pip install --user SomePackage [...] Requirement already satisfied (use --upgrade to upgrade) $ python -m pip install --user --upgrade SomePackage [...] Requirement already up-to-date: SomePackage # force the install $ python -m pip install --user --ignore-installed SomePackage [...] Successfully installed SomePackage
.. tab:: Windows .. code-block:: console C:> py -m pip install --user SomePackage [...] Requirement already satisfied (use --upgrade to upgrade) C:> py -m pip install --user --upgrade SomePackage [...] Requirement already up-to-date: SomePackage # force the install C:> py -m pip install --user --ignore-installed SomePackage [...] Successfully installed SomePackage
Ensuring Repeatability
This is now covered in :doc:`../topics/repeatable-installs`.
Fixing conflicting dependencies
This is now covered in :doc:`../topics/dependency-resolution`.
Using pip from your program
As noted previously, pip is a command line program. While it is implemented in
Python, and so is available from your Python code via import pip
, you must
not use pip’s internal APIs in this way. There are a number of reasons for this:
- The pip code assumes that it is in sole control of the global state of the
program.
pip manages things like the logging system configuration, or the values of
the standard IO streams, without considering the possibility that user code
might be affected. - pip’s code is not thread safe. If you were to run pip in a thread, there
is no guarantee that either your code or pip’s would work as you expect. - pip assumes that once it has finished its work, the process will terminate.
It doesn’t need to handle the possibility that other code will continue to
run after that point, so (for example) calling pip twice in the same process
is likely to have issues.
This does not mean that the pip developers are opposed in principle to the idea
that pip could be used as a library — it’s just that this isn’t how it was
written, and it would be a lot of work to redesign the internals for use as a
library, handling all of the above issues, and designing a usable, robust and
stable API that we could guarantee would remain available across multiple
releases of pip. And we simply don’t currently have the resources to even
consider such a task.
What this means in practice is that everything inside of pip is considered an
implementation detail. Even the fact that the import name is pip
is subject
to change without notice. While we do try not to break things as much as
possible, all the internal APIs can change at any time, for any reason. It also
means that we generally won’t fix issues that are a result of using pip in an
unsupported way.
It should also be noted that installing packages into sys.path
in a running
Python process is something that should only be done with care. The import
system caches certain data, and installing new packages while a program is
running may not always behave as expected. In practice, there is rarely an
issue, but it is something to be aware of.
Having said all of the above, it is worth covering the options available if you
decide that you do want to run pip from within your program. The most reliable
approach, and the one that is fully supported, is to run pip in a subprocess.
This is easily done using the standard subprocess
module:
subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'my_package'])
If you want to process the output further, use one of the other APIs in the module.
We are using freeze here which outputs installed packages in requirements format.:
reqs = subprocess.check_output([sys.executable, '-m', 'pip', 'freeze'])
If you don’t want to use pip’s command line functionality, but are rather
trying to implement code that works with Python packages, their metadata, or
PyPI, then you should consider other, supported, packages that offer this type
of ability. Some examples that you could consider include:
packaging
— Utilities to work with standard package metadata (versions,
requirements, etc.)setuptools
(specificallypkg_resources
) — Functions for querying what
packages the user has installed on their system.distlib
— Packaging and distribution utilities (including functions for
interacting with PyPI).
Changes to the pip dependency resolver in 20.3 (2020)
pip 20.3 has a new dependency resolver, on by default for Python 3
users. (pip 20.1 and 20.2 included pre-release versions of the new
dependency resolver, hidden behind optional user flags.) Read below
for a migration guide, how to invoke the legacy resolver, and the
deprecation timeline. We also made a two-minute video explanation
you can watch.
We will continue to improve the pip dependency resolver in response to
testers’ feedback. Please give us feedback through the resolver
testing survey.
Watch out for
The big change in this release is to the pip dependency resolver
within pip.
Computers need to know the right order to install pieces of software
(«to install x
, you need to install y
first»). So, when Python
programmers share software as packages, they have to precisely describe
those installation prerequisites, and pip needs to navigate tricky
situations where it’s getting conflicting instructions. This new
dependency resolver will make pip better at handling that tricky
logic, and make pip easier for you to use and troubleshoot.
The most significant changes to the resolver are:
- It will reduce inconsistency: it will no longer install a
combination of packages that is mutually inconsistent. In older
versions of pip, it is possible for pip to install a package which
does not satisfy the declared requirements of another installed
package. For example, in pip 20.0,pip install "six<1.12"
does the wrong thing, “successfully” installing
"virtualenv==20.0.2"
six==1.11
, even thoughvirtualenv==20.0.2
requires
six>=1.12.0,<2
(defined here).
The new resolver, instead, outright rejects installing anything if it
gets that input. - It will be stricter — if you ask pip to install two packages with
incompatible requirements, it will refuse (rather than installing a
broken combination, like it did in previous versions).
So, if you have been using workarounds to force pip to deal with
incompatible or inconsistent requirements combinations, now’s a good
time to fix the underlying problem in the packages, because pip will
be stricter from here on out.
This also means that, when you run a pip install
command, pip only
considers the packages you are installing in that command, and may
break already-installed packages. It will not guarantee that your
environment will be consistent all the time. If you pip install x
and then pip install y
, it’s possible that the version of y
you get will be different than it would be if you had run pip
in a single command. We are considering changing this
install x y
behavior (per :issue:`7744`) and would like your thoughts on what
pip’s behavior should be; please answer our survey on upgrades that
create conflicts.
We are also changing our support for :ref:`Constraints Files`,
editable installs, and related functionality. We did a fairly
comprehensive overhaul and stripped constraints files down to being
purely a way to specify global (version) limits for packages, and so
some combinations that used to be allowed will now cause
errors. Specifically:
- Constraints don’t override the existing requirements; they simply
constrain what versions are visible as input to the resolver (see
:issue:`9020`) - Providing an editable requirement (
-e .
) does not cause pip to
ignore version specifiers or constraints (see :issue:`8076`), and if
you have a conflict between a pinned requirement and a local
directory then pip will indicate that it cannot find a version
satisfying both (see :issue:`8307`) - Hash-checking mode requires that all requirements are specified as a
==
match on a version and may not work well in combination with
constraints (see :issue:`9020` and :issue:`8792`) - If necessary to satisfy constraints, pip will happily reinstall
packages, upgrading or downgrading, without needing any additional
command-line options (see :issue:`8115` and :doc:`development/architecture/upgrade-options`) - Unnamed requirements are not allowed as constraints (see :issue:`6628` and :issue:`8210`)
- Links are not allowed as constraints (see :issue:`8253`)
- Constraints cannot have extras (see :issue:`6628`)
Per our :ref:`Python 2 Support` policy, pip 20.3 users who are using
Python 2 will use the legacy resolver by default. Python 2 users
should upgrade to Python 3 as soon as possible, since in pip 21.0 in
January 2021, pip dropped support for Python 2 altogether.
How to upgrade and migrate
-
Install pip 20.3 with
python -m pip install --upgrade pip
. -
Validate your current environment by running
pip check
. This
will report if you have any inconsistencies in your set of installed
packages. Having a clean installation will make it much less likely
that you will hit issues with the new resolver (and may
address hidden problems in your current environment!). If you run
pip check
and run into stuff you can’t figure out, please ask
for help in our issue tracker or chat. -
Test the new version of pip.
While we have tried to make sure that pip’s test suite covers as
many cases as we can, we are very aware that there are people using
pip with many different workflows and build processes, and we will
not be able to cover all of those without your help.- If you use pip to install your software, try out the new resolver
and let us know if it works for you withpip install
. Try:- installing several packages simultaneously
- re-creating an environment using a
requirements.txt
file - using
pip install --force-reinstall
to check whether
it does what you think it should - using constraints files
- the «Setups to test with special attention» and «Examples to try» below
- If you have a build pipeline that depends on pip installing your
dependencies for you, check that the new resolver does what you
need. - Run your project’s CI (test suite, build process, etc.) using the
new resolver, and let us know of any issues. - If you have encountered resolver issues with pip in the past,
check whether the new resolver fixes them, and read :ref:`Fixing
conflicting dependencies`. Also, let us know if the new resolver
has issues with any workarounds you put in to address the
current resolver’s limitations. We’ll need to ensure that people
can transition off such workarounds smoothly. - If you develop or support a tool that wraps pip or uses it to
deliver part of your functionality, please test your integration
with pip 20.3.
- If you use pip to install your software, try out the new resolver
-
Troubleshoot and try these workarounds if necessary.
- If pip is taking longer to install packages, read :doc:`Dependency
resolution backtracking <topics/dependency-resolution>` for ways to
reduce the time pip spends backtracking due to dependency conflicts. - If you don’t want pip to actually resolve dependencies, use the
--no-deps
option. This is useful when you have a set of package
versions that work together in reality, even though their metadata says
that they conflict. For guidance on a long-term fix, read
:ref:`Fixing conflicting dependencies`. - If you run into resolution errors and need a workaround while you’re
fixing their root causes, you can choose the old resolver behavior using
the flag--use-deprecated=legacy-resolver
. This will work until we
release pip 21.0 (see
:ref:`Deprecation timeline for 2020 resolver changes`).
- If pip is taking longer to install packages, read :doc:`Dependency
-
Please report bugs through the resolver testing survey.
Setups to test with special attention
- Requirements files with 100+ packages
- Installation workflows that involve multiple requirements files
- Requirements files that include hashes (:ref:`hash-checking mode`)
or pinned dependencies (perhaps as output frompip-compile
within
pip-tools
) - Using :ref:`Constraints Files`
- Continuous integration/continuous deployment setups
- Installing from any kind of version control systems (i.e., Git, Subversion, Mercurial, or CVS), per :doc:`topics/vcs-support`
- Installing from source code held in local directories
Examples to try
Install:
- tensorflow
hacking
pycodestyle
pandas
tablib
elasticsearch
andrequests
togethersix
andcherrypy
togetherpip install flake8-import-order==0.17.1 flake8==3.5.0 --use-feature=2020-resolver
pip install tornado==5.0 sprockets.http==1.5.0 --use-feature=2020-resolver
Try:
pip install
pip uninstall
pip check
pip cache
Tell us about
Specific things we’d love to get feedback on:
- Cases where the new resolver produces the wrong result,
obviously. We hope there won’t be too many of these, but we’d like
to trap such bugs before we remove the legacy resolver. - Cases where the resolver produced an error when you believe it
should have been able to work out what to do. - Cases where the resolver gives an error because there’s a problem
with your requirements, but you need better information to work out
what’s wrong. - If you have workarounds to address issues with the current resolver,
does the new resolver let you remove those workarounds? Tell us!
Please let us know through the resolver testing survey.
Deprecation timeline
We plan for the resolver changeover to proceed as follows, using
:ref:`Feature Flags` and following our :ref:`Release Cadence`:
- pip 20.1: an alpha version of the new resolver was available,
opt-in, using the optional flag
--unstable-feature=resolver
. pip defaulted to legacy
behavior. - pip 20.2: a beta of the new resolver was available, opt-in, using
the flag--use-feature=2020-resolver
. pip defaulted to legacy
behavior. Users of pip 20.2 who want pip to default to using the
new resolver can runpip config set global.use-feature
(for more on that and the alternate
2020-resolver
PIP_USE_FEATURE
environment variable option, see issue
8661). - pip 20.3: pip defaults to the new resolver in Python 3 environments,
but a user can opt-out and choose the old resolver behavior,
using the flag--use-deprecated=legacy-resolver
. In Python 2
environments, pip defaults to the old resolver, and the new one is
available using the flag--use-feature=2020-resolver
. - pip 21.0: pip uses new resolver by default, and the old resolver is
no longer supported. It will be removed after a currently undecided
amount of time, as the removal is dependent on pip’s volunteer
maintainers’ availability. Python 2 support is removed per our
:ref:`Python 2 Support` policy.
Since this work will not change user-visible behavior described in the
pip documentation, this change is not covered by the :ref:`Deprecation
Policy`.
Context and followup
As discussed in our announcement on the PSF blog, the pip team are
in the process of developing a new «dependency resolver» (the part of
pip that works out what to install based on your requirements).
We’re tracking our rollout in :issue:`6536` and you can watch for
announcements on the low-traffic packaging announcements list and
the official Python blog.
Using system trust stores for verifying HTTPS
This is now covered in :doc:`topics/https-certificates`.
Содержание:развернуть
- Pip или pip3?
- Если pip не установлен
-
Windows
-
Linux (Ubuntu и Debian)
-
MacOS
- Как обновить PIP
- Команды PIP
- Пример работы с пакетами
PIP — это менеджер пакетов. Он позволяет устанавливать и управлять пакетами на Python.
Представьте себе ситуацию: вы собираете проект и подключаете множество сторонних библиотек для реализации своей задачи. Если это делать вручную, процесс выглядит примерно так:
- вы заходите на сайт, выбираете нужную версию пакета;
- скачиваете ее, разархивируете, перекидываете в папку проекта;
- подключаете, прописываете пути, тестируете.
Вполне вероятно, что эта версия библиотеки вообще не подходит, и весь процесс повторяется заново. А если таких библиотек 10? Устанавливать их вручную?
Нет 🙅🏻♂️
Менеджер пакетов PIP — решает данную проблему. Весь процесс установки пакета сводится к выполнению консольной команды pip install package-name
. Несложно представить, сколько времени это экономит.
Если вы работали с другими языками программирования, концепция pip может показаться вам знакомой. Pip похож на npm (в Javascript), composer (в PHP) или gem (в Ruby).
Pip является стандартным менеджером пакетов в Python
Pip или pip3?
В зависимости от того, какая версия Python установлена в системе, может потребоваться использовать pip3 вместо pip.
Если вы не знаете какая версия Python установлена на вашей системе, выполните следующие команды:
python --version
— для Python 2.xpython3 --version
— для Python 3.xpython3.8 --version
— для Python 3.8.x
Советуем использовать версию Python 3.6 и выше
Если команда «python» не найдена, установите Python по инструкции из предыдущей статьи.
Далее нужно убедиться, что сам PIP установлен и работает корректно. Узнать это поможет команда:
pip --version
Команда отобразит в консоли версию pip, путь до pip и версию python, для которой в дальнейшем будут устанавливаться пакеты:
pip 19.2.3 from /usr/local/lib/python3.8/site-packages/pip (python 3.8)
☝️ Важный момент: в зависимости от того, какую версию Python вы будете использовать, команда может выглядеть как pip
, pip3
или pip3.8
Альтернативный вариант вызова pip:
python3.7 -m pip install package-name
Флаг -m
сообщает Python-у запустить pip как исполняемый модуль.
Если pip не установлен
Pip поставляется вместе с Python, и доступен после его установки. Если по какой-то причине pip не установлен на вашей системе, установить его будет не сложно.
Windows
- Скачайте файл get-pip.py и сохраните у себя на компьютере.
- Откройте командную строку и перейдите в папку, в которой сохранен
get-pip.py
. - В командной строке выполните команду:
python get-pip.py
илиpython3 get-pip.py
. - PIP установлен 🎉!
Linux (Ubuntu и Debian)
Прежде, чем перейти к непосредственному описанию, хотим отметить, что все команды, описанные ниже, используются от имени root пользователя. Если же вы являетесь обычным пользователем на компьютере, то потребуется использовать команду sudo
, чтобы получить привилегии root.
Для Питона 2-й версии, выполните команду:
apt-get install python-pip
Для Питона 3-ей версии:
apt-get install python3-pip
MacOS
- скачайте файл
get-pip.py
командойcurl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
; - запустите скачанный файл командой:
python get-pip.py
илиpython3 get-pip.py
.
Должна появиться запись Successfully Installed. Процесс закончен, можно приступать к работе с PIP на MacOS!
Как обновить PIP
Иногда, при установке очередного пакета, можно видеть сообщение о том, что доступна новая версия pip.
WARNING: You are using pip version 19.2.3, however version 19.3.1 is available.
А в следующей за ней строке
You should consider upgrading via the 'python -m pip install --upgrade pip' command.
указана команда для обновления pip:
python -m pip install --upgrade pip
Команды PIP
Синтаксис pip выглядит следующим образом: pip + команда + доп. опции
pip <command> [options]
Со всеми командами pip можно ознакомиться, выполнив pip help . Информацию по конкретной команде выведет pip help <command>
.
Рассмотрим команды pip:
pip install package-name
— устанавливает последнюю версию пакета;pip install package-name==4.8.2
— устанавливает пакет версии 4.8.2;pip install package-name --upgrade
— обновляет версию пакета;pip download
— скачивает пакеты;pip uninstall
— удаляет пакеты;pip freeze
— выводит список установленных пакетов в необходимом формате ( обычно используется для записи вrequirements.txt
);pip list
— выводит список установленных пакетов;pip list --outdated
— выводит список устаревших пакетов;pip show
— показывает информацию об установленном пакете;pip check
— проверяет установленные пакеты на совместимость зависимостей;pip search
— по введенному названию, ищет пакеты, опубликованные в PyPI;pip wheel
— собирает wheel-архив по вашим требованиям и зависимостям;pip hash
— вычисляет хеши архивов пакетов;pip completion
— вспомогательная команда используется для завершения основной команды;pip help
— помощь по командам.
Пример работы с пакетами
PIP позволяет устанавливать, обновлять и удалять пакеты на компьютере. Ниже попробуем разобраться с работой менеджера pip на примере парсинга названий свежих статей на сайте habr.com.
- установим нужные пакеты;
- импортируем пакет в свой скрипт;
- разберемся, что такое
requirements.txt
; - обновим/удалим установленные пакеты.
Приступим 🙎🏻♂️
Шаг #1 Установка.
Для начала, нам необходимо установить beautifulsoup4 — библиотеку для парсинга информации с веб-сайтов.
pip3 install beautifulsoup4
pip найдет последнюю версию пакета в официальном репозитории pypi.org. После скачает его со всеми необходимыми зависимостями и установит в вашу систему. Если вам нужно установить определенную версию пакета, укажите её вручную:
pip3 install beautifulsoup4==4.8.2
Данная команда способна даже перезаписать текущую версию на ту, что вы укажите.
Также для работы beautifulsoup нам понадобится пакет lxml:
pip install lxml
☝️ Важный момент: по умолчанию pip устанавливает пакеты глобально. Это может привести к конфликтам между версиями пакетов. На практике, чтобы изолировать пакеты текущего проекта, создают виртуальное окружение (virtualenv).
Шаг #2 Импортирование в скрипте.
Для того чтобы воспользоваться функционалом установленного пакета, подключим его в наш скрипт, и напишем простой парсер:
from urllib.request import urlopen
from bs4 import BeautifulSoup
# скачиваем html
page = urlopen("https://habr.com/ru/top/")
content = page.read()
# сохраняем html в виде объекта BeautifulSoup
soup = BeautifulSoup(content, "lxml")
# Находим все теги "a" с классом "post__title_link"
all_a_titles = soup.findAll("a", { "class" : "post__title_link" })
# Проходим по каждому найденному тегу и выводим на экран название статьи
for a_title in all_a_titles:
print(a_title.text)
Шаг #3 requirements.txt.
Если вы просматривали какие-либо проекты Python на Github или где-либо еще, вы, вероятно, заметили файл под названием requirements.txt. Этот файл используется для указания того, какие пакеты необходимы для запуска проекта (в нашем случае beautifulsoup4 и lxml).
Файл requirements.txt
создается командой:
pip freeze > requirements.txt
и выглядит следующим образом:
beautifulsoup4==4.8.2
lxml==4.4.2
soupsieve==1.9.5
Теперь ваш скрипт вместе с файлом requirements.txt можно сохранить в системе контроля версий (например git).
Для работы парсера в новом месте (например на компьютере другого разработчика или на удаленном сервере) необходимо затянуть файлы из системы контроля версий и выполнить команду:
pip install -r requirements.txt
Шаг #4 Обновление/удаление установленных пакетов.
Команда pip list --outdated
выведет список всех устаревших пакетов. Обновить отдельно выбранный пакет поможет команда:
pip install package-name --upgrade
Однако бывают ситуации, когда нужно обновить сразу все пакеты из requirements.txt. Достаточно выполнить команду:
pip install -r requirements.txt --upgrade
Для удаления пакета выполните:
pip uninstall package-name
Для удаления всех пакетов из requirements.txt:
pip uninstall -r requirements.txt -y
Мы разобрали основы по работе с PIP. Как правило, этого достаточно для работы с большей частью проектов.