乐趣区

关于python:抬抬小手学Python-Python-Poetry-进行依赖管理图文

jiezi

摘要：在本教程中，您摸索了如何创立新的 Python Poetry 我的项目以及如何将 Poetry 增加到现有我的项目中。

当您的 Python 我的项目依赖于内部包时，您须要确保应用每个包的正确版本。更新后，软件包可能无奈像更新前那样工作。Python Poetry 之 类的依赖项管理器可帮忙您指定、装置和解析我的项目中的内部包。通过这种形式，您能够确保始终在每台机器上应用正确的依赖版本。

应用 Poetry 将帮忙您启动新我的项目、保护现有我的项目并把握 依赖项治理。您将筹备好应用 pyproject.toml 文件，这将是在 Python 我的项目中定义构建需要的规范。

要实现本教程并充分利用它，您应该对虚拟环境、模块和包以及 pip.

尽管本教程侧重于依赖项治理，但 Poetry 还能够帮忙您构建和打包我的项目。如果您想分享您的工作，那么您甚至能够将您的 Poetry 我的项目公布到 Python Packaging Index (PyPI)。

留神先决条件

在深入研究 Python Poetry 的细节之前，您须要理解一些先决条件。首先，您将浏览本教程中将遇到的术语的简短概述。接下来，您将装置 Poetry 自身。

相干术语

如果您已经 import 在 Python 脚本中应用过语句，那么您就曾经应用过 modules。其中一些模块可能是您本人编写的 Python 文件。其余可能是 内置 模块，例如 datetime。然而，有时 Python 提供的还不够。那时您可能会转向内部的打包模块。当您的 Python 代码依赖于内部模块时，您能够说这些 包是您我的项目的 依赖 项。

您能够在 PyPI 中找到不属于 Python 规范库的包。在理解其工作原理之前，您须要在零碎上装置 Poetry。

Python Poetry 装置

要在命令行中应用 Poetry，您应该在零碎范畴内装置它。如果您只是想尝试一下，那么您能够应用 pip. 然而您应该审慎尝试这种办法，因为 Poetry 将装置本人的依赖项，这可能会与您在我的项目中应用的其余包抵触。

装置 Poetry 的举荐办法是应用官网 install-poetry 脚本。您能够手动下载并运行此​​Python 文件，也​能够在下方抉择您的操作系统以应用相应的命令：

  • 视窗
  • Linux + macOS
PS C:\\> (Invoke-WebRequest -Uri https://raw.githubusercontent.com/python-poetry/poetry/master/install-poetry.py -UseBasicParsing).Content | python -

如果您应用的是 Windows，那么您能够应用 Invoke-Webrequest 带有 -UseBasicParsing 选项的 cmdlet 将申请的 URL 的内容下载到 规范输入流 (stdout)。随着管道字符（|），你移交输入到 规范输出流（规范输出） 的 python。在这种状况下，您将的内容通过管道 install-poetry.py 传输到 Python 解释器。

留神： 有些用户在 Windows 10 上应用 PowerShell 命令时会报告谬误。

在输入中，您应该看到装置实现的音讯。您能够 poetry –version 在终端中运行以查看是否 poetry 无效。此命令将显示您以后的 Poetry 版本。如果要更新 Poetry，则能够运行 poetry self update.

Python Poetry 入门

装置 Poetry 后，是时候看看 Poetry 是如何工作的了。在本节中，您将学习如何开始一个新的 Poetry 我的项目以及如何将 Poetry 增加到现有我的项目中。您还将看到我的项目构造并查看 pyproject.toml 文件。

创立一个新的 Poetry 我的项目

您能够应用 new 命令和项目名称作为参数来创立新的 Poetry 我的项目。在本教程中，该我的项目称为 rp-poetry. 创立我的项目，而后进入新创建的目录：

$ poetry new rp-poetry  
$ cd rp-poetry

通过运行 poetry new rp-poetry，您能够创立一个名为 的新文件夹 rp-poetry/。当您查看文件夹外部时，您会看到一个构造：

rp-poetry/  
│  
├── rp\_poetry/  
│   └── \_\_init\_\_.py  
│  
├── tests/  
│   ├── \_\_init\_\_.py  
│   └── test\_rp\_poetry.py  
│  
├── README.rst  
└── pyproject.toml

Poetry 会主动为您规范化包名。它将 - 项目名称中的破折号 () 转换 \_为文件夹名称中的下划线 () rp\_poetry/。否则，Python 中将不容许应用该名称，因而您无奈将其作为模块导入。为了更好地管制创立包名称，您能够应用该 –name 选项以不同于我的项目文件夹的形式命名：

$ poetry new rp-poetry --name realpoetry

如果您更喜爱将源代码存储在额定的 src/ 父文件夹中，那么 Poetry 能够让您应用以下 –src 标记来恪守该约定：

$ poetry new --src rp-poetry  
$ cd rp-poetry

通过增加 –src 标记，您创立了一个名为 的文件夹 src/，其中蕴含您的 rp\_poetry/ 目录：

rp-poetry/  
│  
├── src/  
│   │  
│   └── rp\_poetry/  
│       └── \_\_init\_\_.py  
│  
├── tests/  
│   ├── \_\_init\_\_.py  
│   └── test\_rp\_poetry.py  
│  
├── README.rst  
└── pyproject.toml

创立新的 Poetry 我的项目时，您将立刻收到一个根本的文件夹构造。

查看我的项目构造

该 rp\_poetry/ 子文件夹自身是不是很壮观呢。在这个目录中，你会找到一个 \_\_init\_\_.py 蕴含你的包版本的文件：

\# rp\_poetry/\_\_init\_\_.py  
\_\_version\_\_ = "0.1.0"

当您跳到 tests/ 文件夹并关上 时 test\_rp\_poetry.py，您会留神到它 rp\_poetry 曾经是可导入的：

\# tests/test\_rp\_poetry.py  
from rp\_poetry import \_\_version\_\_  
def test\_version():  
    assert \_\_version\_\_ == "0.1.0"

Poetry 还为该我的项目增加了第一个测试。该 test\_version()函数查看 的 \_\_version\_\_变量是否 rp\_poetry/\_\_init\_\_.py 蕴含预期的版本。然而，该 \_\_init\_\_.py 文件并不是您定义包版本的惟一地位。另一个地位是 pyproject.toml 文件。

应用 pyproject.toml 文件

应用 Poetry 最重要的文件之一是 pyproject.toml 文件。这个文件不是 Poetry 的创造。这是 PEP 518 中定义的 配置文件 规范：

此 PEP 指定 Python 软件包应如何指定它们具备的构建依赖项以执行其抉择的构建零碎。作为本标准的一部分，为软件包引入了一个新的配置文件，用于指定它们的构建依赖项（冀望雷同的配置文件将用于将来的配置细节）。（起源）

作者思考了下面援用中提到的“新配置文件”的几种文件格式。最初，他们决定采纳 TOML 格局，即 Tom’s Obvious Minimal Language 的缩写。在他们看来，TOML 足够灵便，比其余选项（YAML、JSON、CFG 或 INI）具备更好的可读性和更少的复杂性。要查看 TOML 的外观，请关上 pyproject.toml 文件：

 1# pyproject.toml  
 2  
 3\[tool.poetry\]  
 4name = "rp-poetry"  
 5version = "0.1.0"  
 6description = ""7authors = \["Philipp <philipp@realpython.com>"\]  
 8  
 9\[tool.poetry.dependencies\]  
10python = "^3.9"  
11  
12\[tool.poetry.dev-dependencies\]  
13pytest = "^5.2"  
14  
15\[build-system\]  
16requires = \["poetry-core>=1.0.0"\]  
17build-backend = "poetry.core.masonry.api"

您能够在 pyproject.toml 文件中看到四个局部。这些局部称为 表。它们蕴含诸如 Poetry 之类的工具辨认和用于 依赖项治理 或构建例程的 指令。

如果表名是特定于工具的，则必须以 tool. 为前缀。通过应用这样的 子表 ，您能够为我的项目中的不同工具增加阐明。在这种状况下，只有 tool.poetry. 然而，你可能会看到这样的例子[tool.pytest.ini\_options] 为 pytest 在其余我的项目中。

在 [tool.poetry] 下面第 3 行的子表中，您能够存储无关您的 Poetry 我的项目的个别信息。您的可用键由 Poetry 定义。尽管有些键是可选的，但您必须指定四个键：

  1. name: 你的包名
  2. version: 包的版本，最好遵循语义版本控制
  3. description：您的包裹的简短形容
  4. authors: 作者列表，格局 name <email>

第 [tool.poetry.dependencies]9 行和[tool.poetry.dev-dependencies] 第 12 行的子表对于您的依赖项治理至关重要。在下一部分向 Poetry 我的项目增加依赖项时，您将理解无关这些子表的更多信息。当初，重要的是要意识到的包相关性和倒退依赖之间的区别。

该 pyproject.toml 文件的最初一个表位于第[build-system]15 行。该表定义了 Poetry 和其余构建工具能够应用的数据，但因为它不是特定于工具的，因而它没有前缀。Poetry 创立了 pyproject.toml 具备两个键的文件：

  1. requires：构建包所需的依赖项列表，使此键成为必须
  2. build-backend：用于执行构建过程的 Python 对象

如果您想更多地理解 pyproject.toml 文件的这一部分，那么您能够通过浏览 PEP 517 中的源代码树来理解更多信息。

当您应用 Poetry 开始一个新我的项目时，这就是 pyproject.toml 您开始的文件。随着工夫的推移，您将增加无关您的包和您正在应用的工具的配置详细信息。随着 Python 我的项目的增长，您的 pyproject.toml 文件也会随之增长。对于子表 [tool.poetry.dependencies] 和[tool.poetry.dev-dependencies]. 在下一节中，您将理解如何扩大这些子表。

应用 Python Poetry

一旦你设置了一个 Poetry 我的项目，真正的工作就能够开始了。一旦 Poetry 到位，您就能够开始编码。在此过程中，您将理解 Poetry 如何为您提供 虚拟环境 并解决您的依赖项。

应用 Poetry 的虚拟环境

当您开始一个新的 Python 我的项目时，创立一个虚拟环境是一种很好的做法。否则，您可能会混同来自不同我的项目的不同依赖项。应用虚拟环境是 Poetry 的外围性能之一，它永远不会烦扰您的全局 Python 装置。

然而，Poetry 不会在您启动我的项目时立刻创立虚拟环境。您能够通过让 Poetry 列出连贯到以后我的项目的所有虚拟环境来确认 Poetry 尚未创立虚拟环境。如果你还没有，cd 进入 rp-poetry/ 而后运行一个命令：

$ poetry env list

目前，不应该有任何输入。

当您运行某些命令时，Poetry 会一路创立一个虚拟环境。如果您想更好地管制虚拟环境的创立，那么您可能决定明确通知 Poetry 您要为其应用哪个 Python 版本，而后从那里开始：

$ poetry env use python3

应用此命令，您将应用与装置 Poetry 雷同的 Python 版本。应用 python3 的作品，当你在你的 Python 可执行程序 PATH。

留神：或者，您能够将绝对路径传递给 Python 可执行文件。它应该与您能够在 pyproject.toml 文件中找到的 Python 版本束缚相匹配。如果没有，那么您可能会遇到麻烦，因为您应用的 Python 版本与我的项目所需的版本不同。在您的环境中运行的代码在另一台机器上可能有问题。

更蹩脚的是，内部包通常依赖于特定的 Python 版本。因而，安装包的用户可能会收到谬误音讯，因为您的依赖项版本与其 Python 版本不兼容。

当你运行时 env use，你会看到一条音讯：

Creating virtualenv rp-poetry-AWdWY-py3.9 in ~/Library/Caches/pypoetry/virtualenvs  
Using virtualenv: ~/Library/Caches/pypoetry/virtualenvs/rp-poetry-AWdWY-py3.9

如您所见，Poetry 为您的我的项目环境构建了一个惟一名称。该名称蕴含项目名称和 Python 版本。两头看似随机的字符串是您的父目录的哈希值。通过两头的这个惟一字符串，Poetry 能够解决零碎上具备雷同名称和雷同 Python 版本的多个我的项目。这很重要，因为默认状况下，Poetry 在同一个文件夹中创立所有虚拟环境。

Poetry 无需任何其余配置，在 virtualenvs/Poetry缓存目录 的文件夹中创立虚拟环境：

如果要更改默认缓存目录，则能够编辑 Poetry 的配置。当您曾经在应用 virtualenvwrapper 或其余第三方工具来治理您的虚拟环境时，这会很有用。要查看以后配置，包含已配置的 cache-dir，您能够运行以下命令：

$ poetry config --list

通常，您不用更改此门路。如果您想理解无关与 Poetry 的虚拟环境交互的更多信息，那么 Poetry 文档蕴含无关治理环境的一章。

只有您在我的项目文件夹中，Poetry 就会应用与之关联的虚拟环境。如果您有疑难，能够 env list 再次运行以下命令查看虚拟环境是否已激活：

$ poetry env list

这将显示相似 rp-poetry-AWdWY-py3.9 (Activated). 有了激活的虚拟环境，您就能够开始治理一些依赖项并看到 Poetry 的魅力了。

申明你的依赖

Poetry 的一个要害元素是它对依赖项的解决。在开始之前，先看一下文件中的两个依赖表 pyproject.toml：

\# rp\_poetry/pyproject.toml (Excerpt)  
\[tool.poetry.dependencies\]  
python = "^3.9"  
\[tool.poetry.dev-dependencies\]  
pytest = "^5.2"

以后为您的我的项目申明了两个依赖项。一个是 Python 自身。另一个是 pytest，一个宽泛应用的测试框架。正如您之前看到的，您的我的项目蕴含一个 tests/ 文件夹和一个 test\_rp\_poetry.py 文件。应用 pytest 作为依赖项，Poetry 能够在装置后立刻运行您的测试。

留神：在编写本教程时，pytest 应用 Python 3.10 运行 Poetry 不起作用。Poetry 装置了一个与 Python 3.10 不兼容的 pytest 版本。

Poetry 开发人员曾经意识到这个问题，它将随着 Poetry 1.2 的公布而失去修复。

确保您在 rp-poetry/ 我的项目文件夹中并运行命令：

$ poetry install

应用该 install 命令，Poetry 查看您的 pyproject.toml 文件中的依赖项，而后解析并装置它们。当您有许多依赖项须要应用不同版本的不同第三方包时，解析局部尤其重要。在装置任何包之前，Poetry 会确定哪个版本的包满足其余包设置为其要求的版本限度。

除了 pytest 它的要求之外，Poetry 还装置了我的项目自身。这样，您能够立刻导入 rp\_poetry 到您的测试中：

\# tests/test\_rp\_poetry.py  
from rp\_poetry import \_\_version\_\_  
def test\_version():  
    assert \_\_version\_\_ == "0.1.0"

装置我的项目包后，您能够导入 rp\_poetry 测试并查看 \_\_version\_\_字符串。随着 pytest 装置，您能够应用 poetry run 命令来执行测试：

 1$ poetry run pytest  
 2========================= test session starts ==========================  
 3platform darwin -- Python 3.9.1, pytest-5.4.3, py-1.10.0, pluggy-0.13.1  
 4rootdir: /Users/philipp/Real Python/rp-poetry  
 5collected 1 item  
 6  
 8  
 9========================== 1 passed in 0.01s ===========================

您以后的测试已胜利运行，因而您能够释怀地持续编码。然而，如果您仔细观察第 3 行，就会发现有些奇怪。它说 pytest-5.4.3，5.2 不像 pyproject.toml 文件中所说的那样。接得好！

回顾一下，文件中的 pytest 依赖项 pyproject.toml 如下所示：

\# rp\_poetry/pyproject.toml (Excerpt)  
\[tool.poetry.dev-dependencies\]  
pytest = "^5.2"

^ 后面的插入符号 ()5.2 具备特定的含意，它是 Poetry 提供的版本束缚之一。这意味着 Poetry 能够装置与版本字符串最右边的非零数字匹配的任何版本。这意味着 5.4.3 容许应用。版本 6.0 将不被容许。

当 Poetry 尝试解析依赖版本时，像插入符号这样的符号将变得很重要。如果只有两个要求，这并不太难。你申明的依赖越多，它就越简单。让咱们看看 Poetry 如何通过将新包装置到您的我的项目中来解决这个问题。

装置带有 Poetry 的包

您 pip 之前可能应用过装置不属于 Python 规范库的包。如果您 pip install 应用包名作为参数运行，则 pip 在 Python Package Index 上查找包。您能够以同样的形式应用 Poetry。

如果你想在 requests 你的我的项目中增加一个内部包，那么你能够运行一个命令：

$ poetry add requests

通过运行 poetry add requests，您正在将最新版本的 requests 库增加到您的我的项目中。您能够应用版本束缚，requests<=2.1 或者 requests==2.24 如果您想更具体。当您不增加任何束缚时，Poetry 将始终尝试装置最新版本的软件包。

有时，您只想在开发环境中应用某些包。应用 pytest，您曾经发现其中之一。另一种常见的库包含一个代码格式化像彩色，一个文档生成等斯芬克斯，和相似的一个动态剖析工具 pylint 的，Flake8，mypy，或 coverage.py。

要明确通知 Poetry 一个包是一个开发依赖项，您能够 poetry add 应用该 –dev 选项运行。您还能够应用速记 - D 选项，它与以下内容雷同 –dev：

$ poetry add black -D

您增加 requests 为我的项目依赖项和 black 开发依赖项。Poetry 在后盾为您做了一些事件。一方面，它将您申明的依赖项增加到 pyproject.toml 文件中：

\# rp\_poetry/pyproject.toml (Excerpt)  
\[tool.poetry.dependencies\]  
python = "^3.9"  
requests = "^2.26.0"  
\[tool.poetry.dev-dependencies\]  
pytest = "^5.2"  
black = "^21.9b0"

Poetry 将该 requests 包作为我的项目依赖项增加到 tool.poetry.dependencies 表中，同时将其 black 作为开发依赖项增加到 tool.poetry.dev-dependencies.

辨别我的项目依赖项和开发依赖项能够避免装置用户不须要运行程序的需要。开发依赖项仅与您的包的其余开发人员相干，他们心愿 pytest 应用 black. 当用户装置您的软件包时，他们只会装置 requests 它。

留神： 您能够更进一步并申明 可选的依赖项。当您想让用户抉择装置一个不须要但加强您的包的特定数据库适配器时，这会很不便。您能够在 Poetry 文档 中理解无关可选依赖项的更多信息。

除了对 pyproject.toml 文件的更改之外，Poetry 还创立了一个名为 poetry.lock. 在此文件中，Poetry 会跟踪您在我的项目中应用的所有包和确切版本。

解决 poetry.lock

当您运行该 poetry add 命令时，Poetry 会自动更新 pyproject.toml 并固定 poetry.lock 文件中的已解析版本。然而，您不用让 Poetry 实现所有工作。您能够手动向 pyproject.toml 文件增加依赖项并在之后锁定它们。

引脚依赖关系 poetry.lock

如果您想应用 Python 构建网络爬虫，那么您可能须要应用 Beautiful Soup 来解析您的数据。将其增加到文件中的 tool.poetry.dependencies 表中 pyproject.toml：

\# rp\_poetry/pyproject.toml (Excerpt)  
\[tool.poetry.dependencies\]  
python = "^3.9"  
requests = "^2.26.0"  
beautifulsoup4 = "4.10.0"

通过增加 beautifulsoup4 = “4.10.0”，您通知 Poetry 它应该完全安装这个版本。当您向 pyproject.toml 文件增加需要时，它尚未装置。只有 poetry.lock 你的我的项目中没有文件存在，你就能够 poetry install 在手动增加依赖后运行，因为 Poetry 会先查找 poetry.lock 文件。如果没有找到，Poetry 将解析 pyproject.toml 文件中列出的依赖项。

一旦 poetry.lock 文件存在，Poetry 将依赖该文件来装置依赖项。仅运行 poetry install 会触发正告，提醒两个文件不同步并会产生谬误，因为 Poetry 尚不晓得 beautifulsoup4 我的项目中的任何版本。

要将 pyproject.toml 文件中手动增加的依赖项固定到 poetry.lock，您必须首先运行以下 poetry lock 命令：

$ poetry lock  
Updating dependencies  
Writing lock file

通过运行 poetry lock，Poetry 解决 pyproject.toml 文件中的所有依赖项并将它们锁定到 poetry.lock 文件中。诗歌并不止于此。运行时 poetry lock，Poetry 还会递归遍历并锁定您的间接依赖项的所有依赖项。

留神：poetry lock 如果有适宜您的版本限度的新版本可用，该命令还会更新您现有的依赖项。如果您不想更新 poetry.lock 文件中已有的任何依赖项，则必须将 –no-update 选项增加到 poetry lock 命令中：

$ poetry lock --no-update

在这种状况下，Poetry 仅解析新的依赖项，但 poetry.lock 不会更改文件中的任何现有依赖项版本。

当初您曾经固定了所有依赖项，是时候装置它们以便您能够在您的我的项目中应用它们。

装置依赖项 poetry.lock

如果您依照上一节中的步骤操作，那么您曾经装置 pytest 并 black 应用了该 poetry add 命令。您还锁定了 beautifulsoup4，但您还没有装置 Beautiful Soup。要验证 beautifulsoup4 尚未装置，请应用以下命令关上Python 解释器poetry run：

$ poetry run python3

执行 poetry run python3 将在 Poetry 的环境中关上一个交互式 REPL 会话。首先，尝试导入 requests. 这应该白璧无瑕。而后尝试 importing bs4，这是 Beautiful Soup 的模块名称。这应该会引发谬误，因为尚未装置 Beautiful Soup：

\>>>  
\>>> import requests  
\>>> import bs4  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
ModuleNotFoundError: No module named 'bs4'

正如预期的那样，您能够 requests 毫无艰难地导入，并且 bs4 找不到模块。通过键入 exit()并点击退出交互式 Python 解释器 Enter。

应用 poetry lock 命令锁定依赖项后，您必须运行该 poetry install 命令，以便您能够在我的项目中理论应用它们：

$ poetry install  
Installing dependencies from lock file  
Package operations: 2 installs, 0 updates, 0 removals  
  • Installing soupsieve (2.2.1)  
  • Installing beautifulsoup4 (4.10.0)  
Installing the current project: rp-poetry (0.1.0)

通过运行 poetry install，Poetry 读取 poetry.lock 文件并装置其中申明的所有依赖项。当初，bs4 已筹备好在您的我的项目中应用。要对此进行测试，请输出 poetry run python3 并导入 bs4Python 解释器：

\>>>  
\>>> import bs4  
\>>> bs4.\_\_version\_\_  
'4.10.0'

完满的！这次没有谬误，并且您领有您申明的确切版本。这意味着 Beautiful Soup 已正确固定在您的 poetry.lock 文件中，已装置在您的我的项目中，并且能够应用了。要列出我的项目中的可用包并查看它们的详细信息，您能够应用该 show 命令。当您应用 –help 标记运行它时，您将看到如何应用它：

$ poetry show --help

要查看包，您能够应用 show 包名称作为参数，也能够应用 –tree 选项将所有依赖项以树的模式列出。这将帮忙您查看我的项目的嵌套需要。

更新依赖

为了更新您的依赖项，Poetry 依据两种状况提供了不同的选项：

  1. 更新版本束缚内的依赖项。
  2. 更新版本束缚之外的依赖项。

您能够在 pyproject.toml 文件中找到版本限度。当新版本的依赖项依然满足您的版本限度时，您能够应用以下 update 命令：

$ poetry update

该 update 命令将在版本限度内更新所有包及其依赖项。之后，Poetry 将更新您的 poetry.lock 文件。

如果你想更新一个或多个特定的包，那么你能够将它们作为参数列出：

$ poetry update requests beautifulsoup4

应用此命令，Poetry 将搜寻满足文件中列出的版本限度的新版本 requests 和新版本。而后它将解析您我的项目的所有依赖项并将版本固定到您的文件中。您的文件将放弃不变，因为列出的束缚依然无效。beautifulsoup4pyproject.tomlpoetry.lockpyproject.toml

如果要应用比 pyproject.toml 文件中定义的版本更高的版本来更新依赖项，则须要 pyproject.toml 当时调整文件。另一种抉择是 add 应用版本束缚或 latest 标签运行命令：

$ poetry add pytest@latest --dev

当您运行 add 带有 latest 标记的命令时，它会查找包的最新版本并更新您的 pyproject.toml 文件。蕴含 latest 标签或版本束缚对于应用该 add 命令至关重要。如果没有它，您会收到一条音讯，表明该包已存在于您的我的项目中。另外，不要遗记 –dev 为开发依赖项增加标记。否则，您会将包增加到惯例依赖项中。

增加新版本后，您必须运行 install 您在上一节中学到的命令。只有这样，您的更新才会被锁定到 poetry.lock 文件中。

如果您不确定更新会为您的依赖项引入哪些基于版本的更改，您能够应用该 –dry-run 标记。此标记实用于命令 update 和 add 命令。它在您的终端中显示操作而不执行任何操作。这样，您能够平安地发现版本更改并决定哪种更新计划最适宜您。

辨别 pyproject.toml 和 poetry.lock

尽管 pyproject.toml 文件中的版本要求可能很宽松，但 Poetry 会锁定您在 poetry.lock 文件中理论应用的版本。这就是为什么在应用 Git 时应该提交此文件的起因。通过 poetry.lock 在 Git 存储库中 提供文件，您能够确保所有开发人员都将应用所需软件包的雷同版本。当您遇到蕴含 poetry.lock 文件的存储库时，最好应用 Poetry。

应用 poetry.lock，您能够确保您应用的版本与其余开发人员应用的版本完全相同。如果其余开发人员不应用 Poetry，您能够将其增加到未应用 Poetry 设置的现有我的项目中。

将 poetry 增加到现有我的项目

很有可能，您的我的项目不是从 poetry new 命令开始的。或者，您可能继承了一个不是用 Poetry 创立的我的项目，但当初您想应用 Poetry 进行依赖治理。在这些类型的状况下，您能够将 Poetry 增加到现有的 Python 我的项目中。

增加 pyproject.toml 到脚本文件夹

如果您的我的项目只蕴含一些 Python 文件，那么您依然能够增加 Poetry 作为将来构建的根底。在这个例子中，只有一个文件，hello.py：

\# rp-hello/hello.py  
print("Hello World!")

这个脚本惟一能做的就是输入字符串 ”Hello World!”。但兴许这只是一个雄伟我的项目的开始，因而您决定将 Poetry 增加到您的我的项目中。poetry new 您将应用以下 poetry init 命令，而不是应用之前的命令：

$ poetry init  
This command will guide you through creating your pyproject.toml config.  
Package name \[rp-hello\]: rp-hello  
Version \[0.1.0\]:  
Description \[\]: My Hello World Example  
Author \[Philipp <philipp@realpython.com>, n to skip\]:  
License \[\]:  
Compatible Python versions \[^3.9\]:  
Would you like to define your main dependencies interactively? (yes/no) \[yes\] no  
Would you like to define your development dependencies interactively? (yes/no) \[yes\] no  
Generated file

该 poetry init 命令将启动交互式会话以创立 pyproject.toml 文件。Poetry 为您提供了大多数须要设置的配置的倡议，您能够按下 Enter 以应用它们。当您不申明任何依赖项时，pyproject.tomlPoetry 创立的文件如下所示：

\# rp-hello/pyproject.toml  
\[tool.poetry\]  
name = "rp-hello"  
version = "0.1.0"  
description = "My Hello World Example"  
authors = \["Philipp <philipp@realpython.com>"\]  
\[tool.poetry.dependencies\]  
python = "^3.9"  
\[tool.poetry.dev-dependencies\]  
\[build-system\]  
requires = \["poetry-core>=1.0.0"\]  
build-backend = "poetry.core.masonry.api"

内容看起来与您在前几节中经验的示例类似。

当初您能够应用 Poetry 我的项目提供的所有命令。有了 pyproject.toml 文件，您当初能够运行脚本：

$ poetry run python3 hello.py  
Creating virtualenv rp-simple-UCsI2-py3.9 in ~/Library/Caches/pypoetry/virtualenvs  
Hello World!

因为 Poetry 没有找到任何能够应用的虚拟环境，所以它在执行您的脚本之前创立了一个新环境。执行此操作后，它会显示您的 Hello World! 音讯而没有任何谬误。这意味着您当初有一个正在运行的 Poetry 我的项目。

应用现有 requirements.txt 文件

有时您的我的项目曾经有一个 requirements.txt 文件。看看 requirements.txt 这个 Python 网络爬虫的文件：

$ cat requirements.txt  
beautifulsoup4==4.9.3  
certifi==2020.12.5  
chardet==4.0.0  
idna==2.10  
requests==2.25.1  
soupsieve==2.2.1  
urllib3==1.26.4

应用该 cat 实用程序，您能够读取文件并将内容写入 规范输入。在本例中，它显示了网络爬虫我的项目的依赖项。应用 创立 Poetry 我的项目后 poetry init，您能够将该 cat 实用程序与以下 poetry add 命令联合应用：

$ poetry add \`cat requirements.txt\`  
Creating virtualenv rp-require-0ubvZ-py3.9 in ~/Library/Caches/pypoetry/virtualenvs  
Updating dependencies  
Writing lock file  
Package operations: 7 installs, 0 updates, 0 removals  
  • Installing certifi (2020.12.5)  
  • Installing chardet (4.0.0)  
  • Installing idna (2.10)  
  • Installing soupsieve (2.2.1)  
  • Installing urllib3 (1.26.4)  
  • Installing beautifulsoup4 (4.9.3)  
  • Installing requests (2.25.1)

当需要文件像这样简略时，应用 poetry add 和 cat 能够为您节俭一些手动工作。

requirements.txt 然而，有时文件会更简单一些。在这些状况下，您能够执行测试运行并查看后果，或者手动将需要增加到文件中的 [tool.poetry.dependencies] 表中 pyproject.toml。要查看您的构造 pyproject.toml 是否无效，您能够在 poetry check 之后运行。

创立 requirements.txt 自 poetry.lock

在某些状况下，您必须有一个 requirements.txt 文件。例如，兴许您想在 Heroku 上托管您的 Django 我的项目。对于这种状况，Poetry 提供了 export 命令。如果你有一个 Poetry 我的项目，你能够 requirements.txt 从你的 poetry.lock 文件中创立一个文件：

$ poetry export --output requirements.txt

poetry export 以这种形式应用该命令会创立一个 requirements.txt 蕴含散列和环境标记的文件。这意味着您能够确保解决与 poetry.lock 文件内容相似的十分严格的要求。如果您还想蕴含您的开发依赖项，您能够增加 –dev 到命令中。要查看所有可用选项，您能够选中 poetry export –help。

命令参考

本教程向您介绍了 Poetry 的依赖治理。在此过程中，您应用了一些 Poetry 的命令行界面 (CLI) 命令：

您能够查看 Poetry CLI 文档以理解无关上述命令和 Poetry 提供的其余命令的更多信息。您还能够 poetry –help 间接在终端中运行以查看信息！

论断

在本教程中，您摸索了如何创立新的 Python Poetry 我的项目以及如何将 Poetry 增加到现有我的项目中。Poetry 的一个要害局部是 pyproject.toml 文件。与 联合应用 poetry.lock，您能够确保装置我的项目所需的每个包的确切版本。当您跟踪 poetry.lockGit 存储库中的文件时，您还要确保我的项目中的所有其余开发人员在他们的机器上装置雷同的依赖项版本。

退出移动版