为-Python-开发优化-VSCode-二-为 Python 开发优化 VSCode（二）三、设置环境和测试 VS

为 Python 开发优化 VSCode（二）

原文：Optimizing Visual Studio Code for Python Development

协议：CC BY-NC-SA 4.0

三、设置环境和测试

VS 代码包括多种用于构建和调试任何应用程序的便捷工具。尤其是在启用了 Python 扩展的情况下，VS 代码对于 Python 开发人员来说变成了一个非常方便的、梦幻般的工作环境。本章讨论了 Python 环境以及如何利用它们，如何在 VS 代码上配置 Python 项目以充分利用它，以及如何使用 Jupyter 生态系统，这对于中等 it 素养的用户来说是一个强大的工具。本章还介绍了如何使用 Jupyter 笔记本扩展。

设置您的环境

Python 中的环境代表 Python 程序运行的周围环境，由一个解释器和许多您选择的其他安装包组成。VS 代码的 Python 扩展为处理不同的环境提供了平滑的集成特性。

默认情况下，您安装的任何 Python 解释器都在它自己的全局环境中运行，这并不特定于任何一个项目。例如，如果您在一个新的命令提示符下运行 python(在 Windows 上)或 python3(在 macOS 和 Linux 上),那么您就是在该解释器的全局环境中运行。因此，您安装或卸载的任何软件包都会对全局环境以及在该环境中运行的所有程序产生影响。值得注意的是，Python 扩展版本 2018.8.1 和之后的所有其他版本都会自动更新环境。

尽管在全局环境中管理项目是一种简单的开始方式，但是随着时间的推移，这个环境将会变得混乱不堪，因为已经为不同的项目安装了许多不同的包。这种混乱使得针对一组特定的模块化版本的包彻底测试应用程序变得复杂，而这正是您需要在构建服务器或 web 服务器上设置的环境。

因此，开发人员通常会为项目创建一个虚拟环境。虚拟环境代表项目中的一个子文件夹，其中有一个特定解释器的副本。激活虚拟环境后，您安装的任何软件包都将只安装在该环境的子文件夹中。当您在那个环境中运行 Python 程序时，您知道它只针对那些特定的包运行。同时，如果没有使用虚拟环境，并且安装了多个 Python 版本并在 path 变量中进行了设置，则可能需要指定 Python 解释器，以便在终端中将软件包安装到全局环境中。虽然可以将虚拟环境文件夹作为工作空间打开，但不建议这样做，因为这可能会导致使用 Python 扩展时出现问题。

另一种需要提到的环境是 Conda 环境。Conda 环境是一个虚拟环境，使用 Conda 包管理器进行设计和管理。

Conda 因创建具有相关依赖关系以及二进制集合的环境而广为人知。与为特定项目创建的虚拟环境不同，Conda 环境可在任何给定设备上为任何项目全球提供。这种可用性使修改几个不同的 Conda 功能变得容易，然后为任何工作选择合适的功能。

如前所述，如果环境有 Python 解释器，Python 扩展会自动识别现有的 Conda 环境。举例来说，下面的命令使用 Python 3.4 解释器和几个库创建了一个 Conda 环境，然后 VS 代码显示在可用解释器的列表中:

conda create -n env-01 python=3.4 scipy=0.15.0 astroid babel

相反，如果您没有及时地指定一个解释器，就像 conda create - name env-00 一样，环境将不会出现在列表中。

另外，如果在 VS 代码运行时创建新的 Conda 环境，使用 Reload Window 命令刷新用 Python 显示的环境列表:Select Interpreter 否则，你可能看不到那里的环境。可能需要很短的时间才会出现；尝试等待 15 秒钟，然后再次使用该命令。

为了确保从 shell 的角度正确设置环境，一种选择是在激活的环境中使用 Anaconda 提示符来启动 VS 代码。命令。此时，使用命令面板或单击状态栏来选择解释器。即使 VS 代码的 Python 扩展还没有与 Conda environment.yml 文件直接集成，VS 代码本身也可以作为一个伟大的 YAML 编辑器。如果默认 shell 设置为 PowerShell，则无法在 VS 代码集成终端中自动激活 Conda 环境。如果你想改变外壳，你应该检查集成终端配置菜单。

您可以手动确定用于激活的 Conda 可执行文件的路径(版本 4.4 以上)。为此，打开命令选项板(Ctrl+Shift+P)并输入 Preferences: Open User Settings。然后用 python.condaPath 设置合适的路径，它在用户设置的 python 扩展部分。

手动指定解释器

如果您看到 VS 代码没有自动找到您需要使用的解释器，您可以在您的工作区设置 settings.json 文件中手动设置它的路径。使用后面的任何条目，您可以将该行作为同级添加到其他现有设置中。选择文件(macOS 上的代码)➤首选项➤设置菜单命令(Ctrl+，)打开您的设置，然后选择工作区。然后执行以下任一步骤:

使用 python 可执行文件的完整路径创建或编辑 python.pythonPath 的现有条目(如果直接编辑 settings.json，请添加以下行作为设置):

对于 Windows:
对于 macOS 和 Linux:

"python.pythonPath": "c:/python36/python.exe",

"python.pythonPath": "/home/python36/python",

您还可以使用 python.pythonPath 来表示虚拟环境，例如:

视窗:
MAC/Linux:

"python.pythonPath": "c:/dev/ala/venv/Scripts/python.exe",

"python.pythonPath": "/home/abc/dev/ala/venv/bin/python",

您可以使用语法${env:VARIABLE}在 path 设置中使用环境变量。例如，如果您添加了一个名为 PYTHON_INSTALL_LOC 的变量，并带有一个解释器的路径，那么您可以应用以下设置值:

"python.pythonPath": "${env:PYTHON_INSTALL_LOC}",

同时，由于变量替换仅在 VS 代码设置文件中受支持，因此在中不起作用。环境文件。

通过使用环境变量，您可以轻松地在路径不同的操作系统之间转移项目。只要确保首先在操作系统上设置环境变量。

要创建虚拟环境，请写下以下命令，其中。venv "是环境文件夹的名称:

# macOS and Linux
# You might need to run sudo apt-get install python3-venv first
python3 -m venv .venv

# Windows
# You can also use py -3 -m venv .venv
python -m venv .venv

创建新的虚拟环境后，将显示一个提示，让您为工作区选择它。如果您注意到 active 命令生成消息“Activate.ps1 没有数字签名。您不能在当前系统上运行该脚本。，那么您必须临时更改 PowerShell 执行策略以允许脚本运行。

Python 环境提示将新虚拟环境中 Python 解释器的路径添加到常规工作空间设置中。然后，在通过 Python 扩展安装软件包和运行代码时，将应用该环境。这将在第四章详细讨论，涵盖 Django 和 Flask 项目。

选择和激活环境

默认情况下，Python 扩展会搜索并使用它在系统路径中找到的第一个 Python 解释器。如果它不能识别任何解释器，它会发出警告。在 macOS 上，如果您使用 OS 安装的 Python 解释器，该扩展也会发出警告，因为您通常希望使用直接安装的解释器。在这两种情况下，都可以通过在用户设置中将 python . disableinstallationcheck 设置为 true 来禁用这些警告。

要选择特定的环境，应该使用命令面板中的 Python: Select Interpreter 命令(Ctrl+Shift+P)。您可以随时在两种环境之间切换；如果需要用不同的解释器或库版本测试项目的不同部分，切换环境也很有帮助。

Python: Select Interpreter 命令附带了一个可用全局环境、Conda 环境和虚拟环境的列表。还需要注意的是，在 Windows 上，VS 代码可能需要一点时间来检测可用的 Conda 环境。在此过程中，在环境路径准备好之前，您可能会看到“(缓存)”。标签表明 VS 代码目前正在处理该环境的缓存信息。

从列表中选择一个解释器，为 python.pythonPath 添加一个条目，并在您的工作区设置中添加解释器的路径。因为路径是工作区设置的一部分，所以在您打开该工作区时，应该已经选择了相同的环境。如果您需要为您的应用程序设置一个默认的解释器，您可以在您的用户设置中手动包含一个 python.pythonPath 条目。为此，请打开命令选项板(Ctrl+Shift+P)并输入 Preferences: Open User Settings。之后，您可以使用适当的解释器设置 python.pythonPath，它位于用户设置的 python 扩展部分。

Python 扩展使用 Python: Run Python File in Terminal 命令利用所选环境运行 Python 代码，提供标准语言服务，如在编辑器中打开. py 文件时自动完成、语法检查、林挺和格式化，以及使用 Terminal:Create New Integrated Terminal 命令打开终端。在后一种情况下，VS 代码被期望自动激活所选择的环境。

环境和终端窗口

使用 Python: Select Interpreter 后，当右键单击一个文件并选择 Python: Run Python File in Terminal 时，将应用该解释器。除非将 python . Terminal . activate environment 设置更改为 false，否则在您使用“终端:创建新的集成终端”命令时，该环境也会自动激活。然而，从激活了某个 Python 环境的 shell 中启动 VS 代码并不会在默认的集成终端中自动激活该环境。使用终端:在 VS 代码运行后创建新的集成终端命令。此外，如果 PowerShell 被设置为集成外壳，则 Conda 环境不能在集成终端中自动运行。为了改变外壳，您应该看到集成的终端配置。

您对终端中已激活的环境所做的任何更改都将是永久的。例如，在激活了 Conda 环境的终端上使用 Conda install 将软件包永久安装到该环境中。同时，在激活了虚拟环境的终端中使用 pip install 将软件包添加到该环境中。

使用 Python: Select Interpreter 命令更改解释器不会对已经打开的终端面板产生任何影响。因此，您可以在拆分的终端中激活单独的环境:只需选择第一个解释器，为它创建一个终端，选择一个不同的解释器，然后使用终端标题栏中的拆分按钮(Ctrl+Shift+5)。

选择调试环境

默认情况下，python.pythonPath 设置决定了应用哪个 python 解释器进行调试。但是，如果在 launch.json 的调试配置中有一个 pythonPath 属性，则应用该解释器。更准确地说，在决定使用哪个解释器进行调试时，VS 代码使用以下优先顺序:

launch.json 中所选调试配置的 pythonPath 属性
工作空间 settings.json 中的 python.pythonPath 设置
user settings.json 中的 python.pythonPath 设置

扩展会在给定的位置自动搜索口译员:

标准安装路径，如/usr/local/bin、/usr/sbin、/sbin、c:\python27、c:\python36
直接位于工作区(项目)文件夹下的虚拟环境
位于由 python.venvPath 设置标识的文件夹中的虚拟环境，它可以包含多个虚拟环境。该扩展在 venvPath 的第一级子文件夹中查找虚拟环境
虚拟环境位于~/中。virtualenvwrapper 的 virtualenvs 文件夹
pyenv 安装的解释器
位于由 WORKON_HOME 标识的路径中并由 virtualenvwrapper 使用的虚拟环境

Conda 环境应该包括一个 Python 解释器。通常，VS 代码不会显示没有解释器的 Conda 环境。解释器安装在工作区(或项目)文件夹下的. direnv 文件夹中。如果 VS 代码没有自动定位解释器，您也可以手动定义一个解释器。

环境变量定义文件

环境变量定义文件是一个普通的文本文件，它包括格式为 environment_variable=value 的键值对，其中#用于注释。不支持多行值，但是这些值可以引用系统中或文件中已包含的任何其他环境变量。环境变量定义文件可以应用于调试和工具执行(包括 linters、formatters、IntelliSense 和测试工具)等场景，但不能应用于终端。

默认情况下，Python 扩展首先查找并加载一个名为。env，然后应用这些定义。该文件由默认条目“python.envFile”识别:“${workspaceFolder}/。env”在您的用户常规设置中。您可以随时修改 python.envFile 设置以应用不同的定义文件。

调试配置有一个令人羡慕的属性，它也默认为。当前工作空间中的 env 文件。此函数允许您轻松地设置用于调试目的的变量，以替换默认变量。环境文件。例如，在开发 web 应用程序时，您可能希望在开发服务器和生产服务器之间快速切换。您可以为每个 URL 使用单独的定义文件，而不是直接将不同的 URL 和其他设置编码到您的应用程序中。

变量替换

在定义文件中确定环境变量时，可以使用以下常规语法使用任何现有环境变量的值:

<VARIABLE>=...${env:EXISTING_VARIABLE}...

在哪里...代表值中使用的任何其他文本，大括号是必需的。在此语法的限制中，以下规则直接适用:

变量按照它们在。env 文件，因此您可以使用该文件前面包含的任何变量。
单引号或双引号对替换值没有影响，并且包含在定义值中。例如，如果 VAR1 的值是 abcefg，那么 VAR2='${env:VAR1} '将值' abcefg '赋给 VAR2。
$字符可以用反斜杠省略，如在\$ 中。
您可以应用递归替换，例如 python path = ${ env:PROJ _ 目录}:$ {env:PYTHONPATH}(其中 PROJ _ 目录是任何其他环境变量)。
您只能应用简单的替换；不支持 ${_$ {env:VAR1}_EX}之类的嵌套。

不支持语法的条目保持不变。

使用 PYTHONPATH 变量

PYTHONPATH 环境变量标识了 Python 解释器应该寻找模块的附加位置。在 VS 代码中，PYTHONPATH 可以通过终端设置(如 terminal.integrated.env.*)进行设置，并在。环境文件。

如果您正在应用终端设置，PYTHONPATH 将开始影响用户在终端中运行的任何工具，以及扩展为用户执行的通过终端完成的任何操作，比如调试。然而在这种情况下，当扩展正在执行不通过终端路由的动作时，例如使用 linter 或 formatter，那么这个设置将不会对模块前景有任何影响。

当 PYTHONPATH 使用。env 文件，它将影响扩展为您所做的一切以及调试器所完成的操作，但是它不会影响终端中运行的任何工具。如果有必要，可以使用这两种方法来设置 PYTHONPATH。

何时使用 PYTHONPATH 的一个很好的例子是，在 src 文件夹中有源代码，在 tests 文件夹中有测试。然而，当运行测试时，这些测试通常不能访问 src 中的模块，除非您硬编码相对路径。为了防止这个问题，一定要将 src 的路径添加到 PYTHONPATH 中。

PYTHONPATH 的值可以保存在由 os.pathsep 分隔的多个位置:分号(；)在 Windows 上，冒号(:)在 Linux 和 macOS 上。无效路径通常会被忽略。如果您发现 PYTHONPATH 的值没有按预期运行，请确保在操作系统的位置之间添加了正确的分隔符。例如，在 Windows 上向不同的位置添加冒号，或者在 Linux 和 macOS 上向不同的位置添加分号，都会导致 PYTHONPATH 的值无效，这是被忽略的。PYTHONPATH 不指定 Python 解释器本身的路径，不应与 python.pythonPath 设置一起使用。

下一节将描述如何运行我们的 Python 项目。

运行您的项目

首先，通过运行标准命令来验证机器上的 Python 安装:

Linux/macOS: python3 --version
Windows: py -3 --version

您现在已经准备好在一个项目(工作区)文件夹中开始 VS 代码了(图 3-1 )。

img/514155_1_En_3_Fig1_HTML.jpg

图 3-1

在 VS 代码中运行 Python 项目

使用命令提示符或终端，建立一个名为“hello”的空文件夹，导航到该文件夹，并通过输入以下命令打开该文件夹中的 VS 代码:

mkdir hello
cd hello
code

此时，确保您使用的是 Anaconda 命令提示符。通过在一个文件夹中启动 VS 代码，这个文件夹就变成了您的工作区。VS 代码将属于特定工作区的设置存储在。vscode/settings.json，它们独立于全局存储的用户设置。或者，您可以通过操作系统用户界面运行 VS 代码，方法是访问文件➤打开文件夹以打开项目文件夹。

选择 Python 解释器

默认情况下，Python 是一种解释型语言，为了运行 Python 代码并获得 Python IntelliSense，您必须向 VS 代码指定要应用哪个解释器。

从 VS 代码内部，通过打开命令调板(Ctrl+Shift+P)选择一个 Python 3 解释器，然后开始输入 Python: Select Interpreter 命令进行搜索；之后，选择命令。如果可用，您还可以使用状态栏上的选择 Python 环境功能(它可能已经显示了所选解释器的信息)。

该命令提供了 VS 代码可以自动找到的可用解释器选项，包括虚拟环境。如果您没有看到您正在寻找的解释器，请尝试在配置 Python 环境中搜索。您还应该注意，当使用 Anaconda 发行版时，正确的解释器通常会有后缀(' base':conda):例如，Python 3.7.3 64 位(' base':conda)。

选择解释器会将工作空间设置中的 python.pythonPath 值设置为解释器的路径。要查看该设置，请选择文件➤首选项➤设置(macOS 的代码➤首选项➤设置)，然后单击工作区设置选项卡。同时，如果在没有打开工作区文件夹的情况下选择解释器，VS 代码会在用户设置中设置 python.pythonPath，这通常会激活 VS 代码的默认解释器。用户设置使您能够始终拥有 Python 项目的默认解释器。换句话说，工作区设置允许您覆盖用户设置。

创建 Python Hello World 源代码文件

从文件资源管理器工具栏中，选择 hello 文件夹上的“新建文件”按钮。将文件命名为 hello.py，它会自动在编辑器中打开:文件资源管理器 hello.py。py 文件扩展名，您让 VS 代码将这个文件解释为 Python 程序，这样它就可以使用 Python 扩展名和您选择的解释器来读取内容。同一个文件资源管理器工具栏还允许您在工作区内创建文件夹，以帮助您排序和组织代码。为此，您可以使用“新建文件夹”按钮轻松创建文件夹。

在工作区中设置代码文件后，在 hello.py 中输入以下源代码:

msg = "Hello World"
print(msg)

当您开始键入时，您应该能够观察到 IntelliSense 如何显示自动完成选项。IntelliSense 和自动完成功能适用于标准 Python 模块以及安装在所选 Python 解释器环境中的其他包。它还为对象类型上可用的方法提供了完成功能。例如，因为 msg 变量包含一个字符串，所以 IntelliSense 提供字符串方法供您键入它们。

对于其类型提供方法的变量，也会出现 IntelliSense。您可以自由地体验 IntelliSense 并尝试更多的功能，但是总是建议您恢复您的更改，这样您就只有 msg 变量和 print 调用，并保存文件(Ctrl+S)。

运行 Hello World

用 Python 运行 hello.py 非常简单:点击编辑器右上角的在终端播放中运行 Python 文件按钮。该按钮访问一个终端面板，在该面板中 Python 解释器被自动激活，然后开始运行 python3 hello.py (macOS 和 Linux)或 python hello.py (Windows)。

在 VS 代码中运行 Python 代码还有另外三个选项:

右键单击编辑器窗口中的任意位置，然后选择在终端中运行 Python 文件(这会自动保存文件)。
在 Python 编辑器的终端命令中运行 Python 文件。应选择一条或多条线，然后按 Shift+Enter 或右键单击并选择在 Python 终端中运行选择/线。该命令适用于测试文件的不同部分。
使用命令选项板(Ctrl+Shift+P)。选择 Python: Start REPL 命令为当前选择的 Python 解释器打开 REPL 终端。在 REPL 中，您应该一行一行地输入并运行代码。

运行 Python 调试器

运行 Hello World 程序的调试过程的过程也非常简单。您首先需要配置和初始化它，然后定义变量。接下来的两节解释了如何操作。

配置和初始化调试器

通过将光标放在打印调用上并单击 F9，在 hello.py 的第 2 行设置一个断点。或者，你可以点击编辑器左边的行编号旁边的空白处；一旦设置了断点，一个红色的圆圈就会出现在槽中。

接下来，为了初始化调试器，请按 F5。由于这是您第一次调试该文件，将从命令面板中打开一个配置菜单，让您选择要为活动文件运行的调试配置类型。重要的是要知道 VS 代码使用 JSON 文件进行各种配置；launch.json 是具有调试配置的文件的标准名称。

这些不同的配置方法在调试配置中有完整的解释。如果您不熟悉这个过程，请选择 Python File，这是使用当前选择的 Python 解释器运行编辑器中显示的当前文件的配置。调试器将在文件断点的第一行停止。当前行在左边用黄色箭头标识。如果您此时检查“局部变量”窗口，您可以看到如何定义 msg 变量显示在“局部”窗格中。

定义变量

调试工具栏出现在顶部，从左到右显示以下命令:继续(F5)、单步跳过(F10)、单步进入(F11)、单步退出(Shift+F11)、重新启动(Ctrl+Shift+F5)和停止(Shift+F5)。

状态栏也可以改变颜色(大多数主题为橙色)来表明您处于调试模式。Python 调试控制台也自动出现在右下面板中，显示正在运行的命令以及程序输出。若要继续运行程序，请选择“调试”工具栏上的“继续”命令(F5 ),调试器将运行程序到最后。

安装和使用软件包

本节说明如何运行包。在 Python 中，包让您获得许多有用的代码库，通常来自 PyPI。对于这个例子，我们将尝试使用 matplotlib 和 NumPy 包来组成一个图形，就像数据科学中通常所做的那样。

Python 开发人员的最佳实践是避免将包安装到全局解释器环境中。相反，您应该使用一个特定于项目的虚拟环境，它有一个全局解释器的副本。当您激活该环境时，您随后安装的任何软件包都将与其他环境分开。这种隔离防止了由于包版本冲突而导致的许多复杂情况。为了创建虚拟环境并安装所需的软件包，请根据您的操作系统输入以下命令:

对于 Windows:

py -3 -m venv .venv
.venv\scripts\activate

如果 activate 命令生成消息“Activate.ps1 未经数字签名。您不能在当前系统上运行该脚本。，那么您需要临时更改 PowerShell 执行策略以允许脚本运行。

对于 macOS 和 Linux:

python3 -m venv .venv
source .venv/bin/activate

您可以使用命令面板中的 Python: Select Interpreter 命令来选择您的新环境。但是当您创建一个新的虚拟环境时，VS 代码会提示您将其设置为工作区文件夹的默认环境。一旦选择，环境将在您访问新终端时自动激活。

安装软件包时，尽量不要将它用于 Anaconda 发行版，因为它们已经包含 matplotlib:

对于 macOS:
对于窗户(可能需要额外的高度):

python3 -m pip install matplotlib

python -m pip install matplotlib

# Linux (Debian) (you might need to run as sudo)
apt-get install python3-tk
python3 -m pip install matplotlib

稍后当您重新运行程序时(有或没有调试器),应该会出现一个绘图窗口，并显示输出:matplotlib 输出

完成后，不要忘记在终端窗口中键入 deactivate 来停用虚拟环境。

现在，我们将注意力转向 Jupyter 笔记本及其在 VS 代码中的用法。

支持 Jupyter

Jupyter Notebook 允许创建和共享包含实时代码、等式、文本和可视化的文件，由于其简单性和交互性，被认为是数据科学的最伟大的工具之一(图 3-2 )。

img/514155_1_En_3_Fig2_HTML.jpg

图 3-2

在 VSC 中使用 Python 的 Jupyter 笔记本

Jupyter 笔记本也用于除 Python 之外的其他编程语言，如 R、Julia 和 Scala。为了在其他语言中实现同样丰富的 Jupyter 笔记本体验，Jupyter 支持已经从 Python 扩展中重构到 Jupyter 扩展中。这样，通过建立对 Jupyter 扩展的依赖，可以更容易地为 Python 之外的语言构建新的 Jupyter 体验，而 Jupyter 扩展本身并不依赖于 Python 运行时或 Python 扩展。

Jupyter 扩展为当今 Jupyter 笔记本支持的任何语言内核提供了基本的笔记本支持。大多数语言内核无需任何修改就可以运行 Jupyter。但是，要启用高级功能，如完整的智能感知和调试，可能需要对 VS 代码语言扩展进行修改。

Jupyter(以前也称为 IPython Notebook)是一个开源项目，它使您能够在一个称为 Notebook 的平台上轻松地将 Markdown 文本和可执行 Python 源代码结合起来。VS 代码默认支持使用 Jupyter 笔记本，也支持通过 Python 代码文件。本节将介绍通过 Python 代码文件提供的支持，并说明如何使用类似 Jupyter 的代码单元、在 Python 交互式窗口中运行代码、使用变量浏览器和数据查看器检查和过滤变量，以及调试和导出 Jupyter 笔记本。为了使用 Jupyter 笔记本，您必须首先在 VS 代码中激活一个 Anaconda 环境或另一个安装了 Jupyter 包的 Python 环境。要选择环境，请使用命令面板中的 Python: Select Interpreter 命令(Ctrl+Shift+P)。

一旦激活了适当的环境，您就可以自由地设计和运行类似 Jupyter 的代码单元，连接到远程 Jupyter 服务器来运行代码单元，并将 Python 文件导出为 Jupyter 笔记本。

Jupyter 编码细胞

您可以使用# %%注释在 Python 代码中定义类似 Jupyter 的代码单元:

# %%
msg = "Hello World"
print(msg)

# %%
msg = "Hello again"
print(msg)

确保将上述代码保存在扩展名为. py 的文件中。

选择一个命令启动 Jupyter，然后在 Python 交互式窗口中运行适当的单元。也可以使用(Ctrl+Enter)或 Python:在 Python 终端命令中运行选择/行(Shift+Enter)来运行代码单元格。写下这个命令后，Python 扩展会自动将光标移动到下一个单元格。如果您在文件的最后一个单元格中，扩展会自动为新单元格插入另一个# %%分隔符，模仿 Jupyter 笔记本的行为。

您也可以单击行号左侧的空白区域来设置断点。然后，您可以使用调试单元来刷新该代码单元的调试会话。调试器在断点处停止执行，并允许您一次单步执行一行代码并检查变量。

附加命令和键盘快捷键

表 3-1 显示了使用代码单元格时支持的一些附加命令和键盘快捷键。 ¹

表 3-1

附加命令和快捷键

命令

键盘快捷键

| | --- | --- | | Python:转到下一个单元格 | Ctrl+Alt+] | | Python:转到上一个单元格 | Ctrl+Alt+[ | | Python:通过上面的单元格扩展选择 | Ctrl+Shift+Alt+[ | | Python:通过下面的单元格扩展选择 | Ctrl+Shift+Alt+] | | Python:上移所选单元格 | Ctrl+;在 | | Python:下移所选单元格 | Ctrl+;D | | Python:在上方插入单元格 | ctrl+；A | | Python:在下面插入单元格 | Ctrl+;B | | Python:在位置下方插入单元格 | ctrl+；S | | Python:删除所选单元格 | Ctrl+;X | | Python:将单元格改为代码 | Ctrl+;C | | Python:将单元格改为 Markdown | Ctrl+;M |

Python 交互式窗口

Python 交互式窗口可以用作具有任意代码(有或没有代码单元)的全功能控制台。要将窗口用作控制台，您必须使用命令面板中的 Jupyter:create Interactive Window 命令打开它，然后键入代码，使用 Enter 转到新行，并按 Shift+Enter 运行代码。要对文件使用窗口，您也可以应用 Jupyter，只需从命令面板运行 Python 交互式窗口中的当前文件命令。

绘图查看器

Python 交互式窗口具有完整的智能感知，包括代码完成、成员列表、方法快速信息和参数提示。这些功能允许您在 Python 交互式窗口中像在代码编辑器中一样高效地输入内容。

绘图查看器使您能够更深入地处理 IntelliSense 中的绘图。在查看器中，您可以在当前正在进行的会话中平移、缩放和导航地块。您也可以将图导出为 PDF、SVG 和 PNG 格式。

在 Python 交互式窗口中，双击任意图以在查看器中打开它，或选择图左上角的展开按钮。但是，Python 交互式窗口只支持使用 matplotlib 和 Altair 创建的渲染图。

Python 交互式实时共享

Python 交互式窗口还支持 Visual Studio Live Share 进行实时协作。Live Share 为您提供了在共享音频、服务器、终端、diffs、评论等内容时进行共同编辑和共同调试的选项。但是，这一特性要求在主机和来宾机器上都安装实时共享扩展。

变量浏览器和数据查看器

在 Python 交互式窗口中，可以查看、检查和过滤当前 Jupyter 会话中的变量。通过在运行代码和单元格后展开 Variables 部分，您可以浏览当前变量的列表，这些变量将随着代码中变量的使用而自动更新。

有关变量的更多信息，您可以双击某一行或使用 data viewer 设置中的“显示变量”,在 Data Viewer 中查看变量的更详细视图。打开后，您可以通过查看行来检查值。变量资源管理器在默认情况下处于启用状态，但可以通过 Python ➤数据科学:显示 Jupyter 变量资源管理器在设置中轻松关闭。

连接到远程 Jupyter 服务器

只需连接到远程 Jupyter 服务器，就可以将 Jupyter 笔记本中的密集计算转移到其他计算机上。连接后，代码单元运行在远程服务器上，而不是本地计算机上。

要连接到远程 Jupyter 服务器，请从命令面板(Ctrl+Shift+P)运行 Jupyter:为连接指定本地或远程 Jupyter 服务器命令，然后选择连接到 Jupyter 服务器的方式。

如果远程工作，请为服务器的 URI(主机名)提供包含在？提示时，token= URL 参数。如果您在 VS 代码终端中启动服务器并启用了身份验证令牌，那么带有令牌的 URL 通常会显示在终端输出中，您应该从这里复制它。同时，您应该在提供 URI 后指定用户名和密码。

Python 交互式窗口通过显示 URI 来指定代码的运行位置。为了获得更好的安全性，Microsoft 建议为您的 Jupyter 服务器配置安全预防措施，如 SSL 和令牌支持。这将有助于确保发送到 Jupyter 服务器的请求得到验证，并且到远程服务器的链接得到安全加密。

将 Jupyter 笔记本转换为 Python 代码文件

当您激活安装了 Jupyter 的环境时，您可以打开一个 Jupyter 笔记本文件(。ipynb ),然后将其转换为 Python 代码。一旦完成转换，您就可以像处理任何其他 Python 文件一样运行代码，还可以使用 VS 代码调试器。在 VS 代码中打开和调试笔记本是发现和解决代码错误的一种简单方法，而在 Jupyter 笔记本中直接这样做是相当不方便的。

每次打开笔记本文件，VS 代码都会自动在笔记本编辑器中打开。您可以使用工具栏上的转换图标来转换笔记本(。ipynb)文件转换为 Python 文件(。py)。一定要选择 convert 图标，后面跟着“Python 脚本”，等待几秒钟，然后 VS Code 将转换后的笔记本作为无标题文件打开。笔记本的单元格在 Python 文件中用# %%注释分隔；markdown 单元格被完全转换为以# %% [markdown]开头的注释，并在交互式窗口中与代码和其他输出(如图形和表格)一起呈现为 HTML。第一次运行 Python 文件中的代码单元时，Python 扩展会启动一个 Jupyter 服务器。服务器通常需要一些时间来获取数据，Python 交互式窗口也需要一些时间来显示代码的结果。

调试 Jupyter 笔记本

VS 代码调试器允许您分析您的代码，设置断点，检查其状态，并扫描问题。使用调试器是查找和纠正笔记本代码中错误的快速方法。

在 VS 代码中，激活一个安装了 Jupyter 的 Python 环境，如本章开头所述。导入笔记本的。ipynb 文件转换成 VS 代码，并使用以下选项之一启动调试器:

对于整个笔记本，打开命令面板(Ctrl+Shift+P)并在 Python 交互式窗口命令中运行 Jupyter: Debug 当前文件。
对于单个单元，应用出现在单元上方的调试单元功能。调试器专门从该单元格中的代码开始。默认情况下，调试单元只是进入用户代码。如果您需要进入非用户代码，您必须在 Python 扩展设置(Ctrl+，)中取消选中 Data Science: Debug Just My Code。
确保您熟悉 VS 代码的一般调试特性，例如检查变量、设置断点和其他活动

如果在此过程中出现任何问题，请停止调试器，更正代码，保存文件，然后再次启动调试器。当您对代码感到满意时，保存文件，然后导出笔记本。然后，您可以将笔记本上传到您的普通 Jupyter 环境中。

导出 Jupyter 笔记本

除了访问 Jupyter 笔记本之外，您还可以从命令面板(Ctrl+Shift+P)应用以下命令之一，将 VS 代码中的 Python 文件内容导出到 Jupyter 笔记本(使用。ipynb 扩展)。

Jupyter: 将当前 Python 文件导出为 Jupyter 记事本:从当前文件的内容创建一个 Jupyter 记事本，使用# %%和# %% [markdown]分隔符来指定它们各自的单元格类型。
Jupyter: 导出当前 Python 文件并输出为 Jupyter Notebook:从当前文件的内容创建一个 Jupyter Notebook，并包含代码单元格的输出。
Jupyter: 将交互窗口导出为 Jupyter 笔记本:从 Python 交互窗口的内容创建一个 Jupyter 笔记本。

导出内容后，VS 代码会显示一个提示，通过该提示您可以在浏览器中打开笔记本。Jupyter 在许多不同的位置存储不同的数据(比如配置、运行时)。可以设置环境变量，为每种文件类型的位置进行定制。Jupyter 将数据文件(nbextensions、kernelspecs)与运行时文件(日志、pid 文件、连接文件)和配置文件(config 文件、custom.js)分开保存。

配置文件

默认情况下，配置文件存储在~/中。朱庇特目录。JUPYTER_CONFIG_DIR 用于配置文件位置，JUPYTER_CONFIG_PATH 用于配置文件位置。

JUPYTER_CONFIG_DIR

您应该设置这个环境变量，以便为 Jupyter 配置文件使用一个特定的目录，而不是缺省目录。除了 JUPYTER_CONFIG_DIR 之外，可以通过 JUPYTER_CONFIG_PATH 指定要选择的其他目录。

JUPYTER_CONFIG_PATH

您可以设置此环境变量，为配置搜索路径提供额外的目录。

:envvar:`JUPYTER_CONFIG_PATH '应该包含一系列目录，用

OS . path sep ( ；在 Windows 上，:``在 Unix 上)。例如，如果笔记本或服务器扩展安装在自定义前缀中，则可以放置 JUPYTER_CONFIG_PATH。因为笔记本和服务器扩展是通过配置文件自动启用的，所以只有当自定义前缀的 etc/jupyter 目录包含在 jupyter 配置搜索路径中时，自动启用才会起作用。

除了用户配置目录，Jupyter 还有一个额外位置的搜索路径，配置文件将从这个位置加载。以下是要搜索的位置列表，按相关性排序:

对于 Unix:
对于 Windows:

JUPYTER_CONFIG_DIR
JUPYTER_CONFIG_PATH
{sys.prefix}/etc/jupyter/
/usr/local/etc/jupyter/ /etc/jupyter/

%PROGRAMDATA%\jupyter\

要列出当前正在使用的配置目录，您可以从命令行激活此命令:

jupyter –paths;

以下命令将专门显示配置目录:

jupyter --config-dir.

数据文件

Jupyter 利用搜索路径来寻找可安装的数据文件，比如内核规范和笔记本扩展。搜索资源时，代码将从第一个目录开始检查搜索路径，直到找到包含资源的位置。每个类别的文件都位于搜索路径的每个目录的子目录中。例如，内核规范放在内核子目录中。

JUPYTER_PATH 用于数据文件目录位置，JUPYTER_DATA_DIR 用于数据文件位置。

JUPYTER_PATH

您可以设置此环境变量，为数据搜索路径提供额外的目录。JUPYTER_PATH 应该约束一系列目录，用 OS . PATH sep(；在 Windows 上:在 Unix 上)。在 JUPYTER_PATH 中编写的目录会在其他位置之前被搜索。这是对其他条目的补充，而不是替换:

对于 Linux(和其他免费桌面):
对于 Mac:

JUPYTER_DATA_DIR or (if not set) ~/.local/share/jupyter/ (respects $XDG_DATA_HOME)
{sys.prefix}/share/jupyter/
/usr/local/share/jupyter /usr/share/jupyter

对于 Windows:

JUPYTER_DATA_DIR or (if not set) ~/Library/Jupyter

JUPYTER_DATA_DIR or (if not set) %APPDATA%\jupyter
%PROGRAMDATA\jupyter

Jupyter 数据文件的配置目录包含非瞬态、非配置文件。示例包括 kernelspecs、nbextensions 或 templates。

JUPYTER_DATA_DIR

您应该设置此环境变量以使用特定的目录，而不是默认目录，作为用户数据目录。如上所述，要列出当前正在使用的配置目录，可以从命令行运行以下命令:jupyter–paths；jupyter - data-dir 专门显示数据目录。

运行时文件

诸如连接文件之类的项目只适用于特定进程的生存期，它们有一个运行时目录。JUPYTER_RUNTIME_DIR 用于运行时文件位置。

在 Linux 和其他免费的桌面平台上，这些运行时文件默认位于＄XDG _ 运行时 _ 目录/jupyter 中。在其他平台上，它是用户数据目录的运行时/子目录。任何其他环境变量也可以用来设置运行时目录。

JUPYTER_RUNTIME_DIR

您可以设置它来覆盖 Jupyter 存储运行时文件的位置。如前所述，要列出当前正在使用的配置目录，可以使用命令 jupyter–paths，jupyter - runtime-dir 专门显示了运行时目录。

摘要

Jupyter 笔记本是目前可用的最用户友好、方便、资源丰富和稳定的交互式计算环境。它极大地结合了丰富的文本单元格，如 markdown、LaTeX 和 raw HTML、代码单元格，以及包含计算结果的丰富的高值数据。输出可以是网页可以显示的任何内容，从普通文本到动态可视化。因此，最好将它作为研究文件运行并保持清晰可读。

通常，用户应该能够通过 GitHub repo 上的链接打开 JupyterHub 中的笔记本，通过电子邮件收到的链接打开笔记本，通过将笔记本存储在 GitHub repo 上来访问笔记本，通过加密的 URL 来访问笔记本，以及访问网络驱动器来轻松地读取或写入数据。以下三种分享笔记本的方法是目前实践最多的:

通过 Git 共享
分享 NFS 万岁
通过 Docker NetApp 插件共享

我们已经介绍了很多关于 Jupyter 笔记本的内容。在下一章，我们将把注意力转向 Python 框架，如 Django 和 Flask。

Footnotes 1

VSC，“Python 交互窗口”， https://code.visualstudio.com/docs/python/jupyter-support-py ，2021 年 7 月 29 日访问。

四、使用 Python 框架

在前一章中，我们介绍了 Jupyter 笔记本的一些核心概念。在这一章中，我们将把注意力转向 Python 框架。因为 Python web 开发已经存在了很长一段时间，所以各种各样方便的 Python 框架被创建出来，使普通开发人员的生活变得更加容易。这正是我们描述 Python 用于 web 开发的方式。

Python 是众所周知的可读性很强的面向对象编程语言。由于其独特的语法，与 Java 甚至 C++等其他编程语言相比，学习和使用其基本特性要快得多。Python 框架提供了一种结构来帮助用户创建应用程序，而不必从头开始构建每一个项目。在本章中，我们将快速回顾 Python 框架生态系统，用 Django 和 Flask 框架在 VS 代码中创建简单的代码，然后在 VS 代码中探索一些基本的数据科学场景。

Python 框架生态系统一览

框架作为一种安排，旨在支持 web 应用程序和 web APIs 的开发。它提供了一种构建应用程序的标准方法，同时自动化了与 web 开发中执行的常见活动相关的开销。它具有许多可重用的特性，有两个主要目的:简化创建 web 应用程序的过程，以及尽可能获得最佳结果并节省您的时间。Python 框架也非常有用，原因有很多:

它们涵盖了诸如创建自动加载文件、会话文件和索引文件等基本内容。
它们为处理请求提供了更好的功能。
他们遵循最新的式样。
他们让你附加必要的第三方资源。

有许多 web 应用程序框架，决定哪一个是适合你的可能会变得令人困惑和具有挑战性。在选择 Python web 框架时，需要考虑几个因素。首先，你应该看看你的项目的复杂性。如果您正在开发一个较小的应用程序，您应该考虑应用微框架。另一方面，如果您正在创建一个具有各种特性和需求的大型应用程序项目，您可能会选择全栈框架。换句话说，决定应该来自于你对最终结果的理解和你想要解决的任务。另一件要记住的事情是，由于每个框架通常都有一定的局限性，所以有时 web 应用程序框架会阻碍 web 开发。你可以找到自己的工作方式，也可以完全抛弃这个框架，而不是去经历它。

web 框架是开发人员在过去几年中为 web 编写站点和应用程序时所学到的东西的结果。框架使得为常见的 HTTP 过程重新应用代码和构建项目变得更加容易，因此其他开发人员可以毫不费力地重新构建和维护应用程序。Web 框架是由 Django、Flask、Bottle、Pyramid、Morepath、TurboGears 和其他几个库实现的概念。框架在其代码中或通过扩展提供功能，以激活运行 web 应用程序所需的操作。这些融资业务包括:

路由 URL
输入表单处理和验证
HTML、XML、JSON 和其他输出格式
通过对象关系映射器(ORM)进行数据库连接配置和数据操作
防止跨站点请求伪造的 Web 安全(CSRF)、SQL 注入、跨站点脚本(XSS)
会话存储和检索

记住不是所有的 web 框架都包含所有这些功能的代码也是很好的。框架通常被放在从执行单一功能到提供所有已知 web 框架特征的范围内。

您是否需要在您的项目中使用 web 框架完全取决于您的 web 开发经验以及您正在运行的项目。如果您是一名初学程序员，并且只需要完成一个 web 应用程序作为学习项目，那么框架可以帮助您理解前面的概念，比如 URL 路由、数据操作和身份验证，这些都是大多数 web 应用程序的常见任务。另一方面，如果你已经有了丰富的 web 开发经验，你可能会觉得最小口径的框架不符合你的项目需求。在这种情况下，您可以用自己的代码试验开源库，比如 Werkzeug for WSGI plumbing，来创建自己的框架。尽管 Python 生态系统中有大量不同的项目可以满足 web 开发人员的需求，比如 Pyramid 和 Bottle，但本章主要关注 Django 和 Flask，这两个最常见和最通用的 Python 框架。

姜戈发展公司

Django 是为快速、安全和稳定的 web 开发而开发的高级 Python 框架(图 4-1 )。Django 还对 URL 路由、页面模板和数据处理提供了丰富的支持。

img/514155_1_En_4_Fig1_HTML.jpg

图 4-1

Django，一个流行的 Python 框架

在这一节中，我们将介绍如何在 VS 代码终端、编辑器和调试器中使用 Django。

装置

首先要确保安装了最新版本的 VS 代码。要成功完成本 Django 教程，您必须通过以下方式之一安装 Python 3 版本:

**适用于所有操作系统:**从 python.org 下载；通常使用页面上最先出现的下载 Python 3.9.1 按钮。
对于 Linux: 内置的 Python 3 安装工作良好，但是要下载其他 Python 包，您必须运行 sudo 在终端中安装 python3-pip。
对于 macOS: 在 macOS 上使用 brew install python3 通过 Homebrew 进行安装。

此外，无论您使用哪种操作系统，都要确保从 Anaconda 发行版下载，以用于数据科学目的。在 Windows 上，Python 解释器的位置必须包含在 PATH 环境变量中。您可以在命令提示符下运行 path 来检查位置。如果没有添加 Python 解释器的文件夹，请打开 Windows 设置，搜索“环境”，为您的帐户选择编辑环境变量，然后编辑路径变量以包含该文件夹。

完成该步骤后，您可以安装以下(免费)扩展:

**Python(微软发布):**对 Python 语言的全面支持。
Django Template: 用于模板文件源高亮显示。
**Django 片段:**为普通 Django 代码。或者，如果您愿意，可以安装 Djaniero-Django 代码片段。

不要忘记在扩展安装后重新加载 VS 代码。

为 Django 教程创建项目环境

创建一个安装 Django 的虚拟环境是重要的一步。使用虚拟环境可以避免将 Django 安装到全局 Python 环境中，并让您能够精确控制应用程序中的库。一个虚拟环境也使得覆盖环境的 requirements.txt 文件变得容易。

首先为本教程创建一个项目文件夹，比如您的文件系统上的 hello_django。在该文件夹中，使用以下命令(适用于您的计算机)基于您当前的解释器设计一个名为 env 的虚拟环境:

对于 Linux: python3 -m venv env
对于 macOS: python3 -m venv env
对于 Windows: python -m venv env

激活这些命令时，请确保使用普通 Python 安装。如果您从 Anaconda 安装中应用 python.exe，您会得到一个错误，因为 ensurepip 模块不可用，并且环境处于不完整的状态。

接下来，通过运行代码或运行 VS 代码并使用文件➤打开文件夹命令，在 VS 代码中打开项目文件夹。在 VS 代码中，通过查看➤命令调板或 Ctrl+Shift+P 打开命令调板，然后选择 Python: Select 解释器命令:Django 教程:在 VS 代码中打开命令调板。该命令将调用 VS 代码可以自动定位的可用解释器列表(您的列表会有所不同)。从列表中，转到项目文件夹中以开始的虚拟环境。/env 或。\env。

您还可以从命令面板创建新的集成终端(Ctrl+Shift+` ),这将生成一个终端，并通过运行其激活脚本自动激活虚拟环境。在 Windows 上，如果您的默认终端类型是 PowerShell，您可能会收到无法运行 activate.ps1 的错误，因为系统上禁用了运行脚本。该错误还应提供如何允许脚本的信息的链接。也可以使用 Terminal: Select Default Shell 将“命令提示符”或“Git Bash”设置为默认值。

选择的环境应该在 VS 代码状态栏的左侧弹出；请注意，“(venv)”指示器告诉您当前正在使用虚拟环境。此外，您可以通过以下命令修改您的环境:

**在虚拟环境中更新 pip:**python-m pip 安装-升级 pip
**在虚拟环境中安装 Django:**python-m pip 安装 Django

使用终端时 VS 代码自动激活环境:创建新的集成终端(Ctrl+Shift+`)。当您打开单独的命令提示符或终端时，通过运行 source env/bin/activate(Linux/MAC OS)或 env \ Scripts \ activate . PS1(Windows)来激活环境。当命令提示符在开头显示(env)时，您知道环境是活动的。现在，您已经有了一个可以编写 Django 代码的自我进化的环境。

创建和运行一个最小的 Django 应用程序

在 Django 术语中，Django 项目由几个站点级配置文件和一个或多个应用程序组成，您可以将这些应用程序部署到 web 主机上，以创建一个完整的 web 应用程序。一个 Django 项目可以产生多个 app，每个 app 通常在项目中有一个独立的功能，同一个 app 可以在不同的 Django 项目中。在这种情况下，一个应用程序只是一个 Python 包，具有 Django 期望的某些功能。

要创建一个最小的 Django 应用程序，有必要首先设计基本的 Django 项目作为应用程序的容器，然后继续创建应用程序本身。对于这两个过程，您应该应用 Django 管理实用程序或 Django-admin，它与 Django 包一起安装。

创建 Django 项目

在虚拟环境运行的 VS 代码终端中，插入以下命令:

Django-admin startproject web_project.

此启动命令假定(通过使用。最后)当前文件夹是您的项目文件夹，并在其中创建 manage.py，它代表项目的 Django 命令行管理实用程序。使用 python manage.py 运行项目的管理命令。作为子文件夹，您还有一个名为 web_project 的文件，其中包含以下文件:

【init _ _】。py: 一个空文件，通知 Python 这个文件夹是 Python 包。
**asgi . py:**兼容 ASGI 的 web 服务器为您的项目服务的入口点。您应该让这个文件保持原样，以保护生产 web 服务器的挂钩。
**settings . py:**包含 Django 项目的设置，您可以在开发 web app 的过程中对其进行修改。
**URLs . py:**包含 Django 项目的目录，您可以在开发过程中对其进行编辑。
**wsgi . py:**兼容 WSGI 的 web 服务器为您的项目服务的入口点。建议保持该文件不变，以便为生产 web 服务器提供挂钩。

T31

您还应该通过运行以下命令创建一个空的开发数据库:python manage.py migrate。当您第一次运行服务器时，它会在 DB.sqlite3 文件中生成一个默认的 SQLite 数据库，该数据库被认为是开发所必需的，但也可用于低容量 web 应用程序的生产中。要验证 Django 项目，请确保您的虚拟环境运行无误，然后使用命令 python manage.py runserver 启动 Django 的开发服务器。Django 的内置 web 服务器只是为本地开发目的而设计的。然而，当您添加 web 主机时，Django 将使用主机的 web 服务器。Django 项目中的 wsgi.py 和 asgi.py 模块负责进入生产服务器。

如果希望使用不同于默认 8000 的端口，应该在命令行上插入端口号，例如 python manage.py runserver 5000。按住 Ctrl 键并单击终端输出窗口中的 http://127.0.0.1:8000/ URL，打开默认浏览器访问该地址。如果 Django 安装正确，并且项目仍然是活动的，您将能够看到如下所示的默认页面。VS 代码终端输出窗口还显示服务器日志。完成后，关闭浏览器窗口，并在终端输出窗口中使用 Ctrl+C 在 VS 代码中停止服务器。

创建 Django 应用程序

在虚拟环境所在的 VS 代码终端中，运行项目文件夹(添加 manage.py 的位置)中管理实用程序的 start 命令:python manage . py startapp hello world。该命令将创建一个名为 helloworld 的文件夹，其中包含许多代码文件和一个子文件夹。这样，您可能最常使用 views.py(作为 web 应用程序的页面定义)和 models.py(包含定义数据对象的类)。Django 的管理实用程序使用 migrations 文件夹来管理数据库版本，这将在本章后面讨论。在同一个文件夹中，我们还可以看到文件 apps.py(用于应用程序配置)、admin.py(用于创建管理界面)和 tests.py(用于创建测试)。

您可以修改 helloworld/views.py 以匹配以下代码，并使用以下代码为应用程序的主页创建单个视图:from django . http import HttpResponse

def home(request):

 return HttpResponse("Hello, Django!")

这样，用下面的内容创建一个文件 hello/urls.py。在 urls.py 文件中，您可以确定将不同的 URL 路由到相应视图的模式。以下代码包含一个将应用程序的根 URL(" ")映射到刚才添加到 hello/views.py 的 views.home 函数的路径: ¹

from django.urls import path
from hello import views
urlpatterns = [
    path("", views.home, name="home"),
]

web_project 文件夹还有一个 urls.py 文件，这是 URL 路由实际所在的位置。打开 web_project/urls.py 并编辑它以匹配以下代码。这段代码使用 Django 获取应用程序的 hello/urls.py。URLs.include，它将应用程序的路线框在应用程序内。当一个项目有多个应用程序而不是一个应用程序时，使用此程序。最后一定要用 Ctrl+K S 保存所有修改过的文件。

创建调试器启动配置文件

幸运的是，有一种更简单的方法来运行服务器和测试应用程序，而无需每次都键入 python manage.py runserver。可以在 VS 代码中创建一个定制的启动概要文件，这也适用于不可避免的调试工作。

首先，切换到 VS 代码中的运行视图(使用左侧的活动栏或 F5)。您可能会得到消息“要自定义运行和调试，请创建一个 launch.json 文件。”这意味着您还没有包含调试配置的 launch.json 文件。一旦你点击创建一个 launch.json 文件链接，VS 代码可以为你创建。

选择 launch.json 链接，VS 代码将启动一个调试配置。从下拉列表中选择 Django，VS 代码将在 Django 运行配置中包含一个新的 launch.json 文件。launch.json 文件有许多不同的调试配置，其中每一个都是各种配置中不同的 json 对象。

之后，向下滚动，通过脚本检查名为“Python: Django”的配置: ²

{
    "name": "Python: Django",
    "type": "python",
    "request": "launch",
    "program": "${workspaceFolder}/manage.py",
    "args": [
        "runserver",
    ],
    "django": true
},

该配置使 VS 代码与所选的 Python 解释器和 args 列表中的参数一起运行“${workspaceFolder}/manage.py”。使用这种配置启动 VS 代码调试器与在 VS 代码终端中使用激活的虚拟环境运行 python manage.py runserver 具有相同的效果。“Django”:true 条目还允许 VS 代码启用 Django 页面模板的调试。

您可以通过选择运行➤启动调试菜单命令，或者单击列表旁边的绿色启动调试箭头(F5)，随时测试配置。然后，您应该按住 Ctrl 键并单击终端输出窗口中的 http://127.0.0.1:8000/ URL，打开浏览器并再次检查应用程序是否正常运行。

完成后，关闭浏览器并停止调试器。要停止调试器，请使用停止工具栏按钮(红色方块)或运行➤停止调试命令(Shift+F5)。你也可以随时按照运行➤开始调试来测试应用程序，这也有自动保存所有修改文件的好处。

探索调试器

调试使您有机会在指定的代码行暂停正在运行的程序。当程序暂停时，您可以签出变量，在调试控制台面板中运行代码，并在调试会话开始之前利用修改后的文件。

在开始之前，请确保在最后一个会话结束时，通过在终端中使用 Ctrl+C 停止了正在运行的应用程序。如果您让应用程序在一个终端上运行，它会继续使用该端口。因此，当您使用相同的端口在调试器中运行应用程序时，最初运行的应用程序会接受所有请求，您不会观察到正在调试的应用程序中的任何活动，程序也不会在断点处停止。简单来说，如果调试器似乎没有被激活，请确保应用程序的其他部分都没有运行。

首先在 helloworld/urls.py 中添加一个路由到 urlpatterns 列表:path("helloworld/ ")中，path 的第一个参数定义了一个路由“hello/”，其中包含一个名为 name 的变量字符串。该字符串被传递给参数第二部分中指定的 views.hello_world 函数。

因为 URL 路由是非常区分大小写的，如果您需要同一个视图函数来管理两者，您必须为每个变量定义路径。URL 路由中定义的 name 变量是作为 hello_there 函数的参数给出的。顺便说一下，你应该总是过滤用户提供的任意信息，以防止对你的应用程序的各种攻击发生。在这种情况下，代码过滤 name 参数，使其只包含字母，从而避免了控制字符、HTML 和其他字符的注入。

通过执行下列任一操作，可以在 hello_world 函数(now = DateTime.now())的第一行代码处设置断点:

将光标放在该行上，按 F9 键
选择“运行➤切换断点”菜单命令
直接在行号左边的空白处单击

断点在左边空白处显示为红点。通过选择“运行➤启动调试”菜单命令，或选择列表旁边的绿色启动调试箭头(F5)，启动调试器。VS 代码中还会弹出一个调试工具栏，其中包含按以下顺序排列的命令:暂停(或继续，F5)、单步跳过(F10)、单步进入(F11)、单步退出(Shift+F11)、重新启动(Ctrl+Shift+F5)和停止(Shift+F5)。命令输出出现在 Python 调试控制台终端中。你应该打开一个浏览器并导航到 http://127.0.0.1:8000/helloworld/VSCode 。在页面加载之前，VS 代码会在您设置的断点处暂停程序。断点上的黄色小箭头表明这是要运行的下一行代码。使用 Step Over 运行 now = DateTime.now()语句。

在 VS 代码窗口的左侧，您可以看到一个显示局部变量和参数的变量列表。下面列出了监视、调用堆栈和断点。在“局部变量”部分，尝试展开不同的值，并通过双击(或 F2)来修改它们。然而，改变变量会破坏程序。当代码在开始时没有产生正确的值时，开发人员通常只修改正确的值。

当程序暂停时，调试控制台面板允许您使用表达式进行试验，并使用程序的当前状态尝试不同的代码部分。例如，一旦跨过 now = DateTime.now()这一行，就可以尝试不同的日期/时间格式。在编辑器中，选择显示为 now.strftime 的代码(" %A，%d %B，%Y at %X ")，然后右键单击并选择 Debug: Evaluate，将该代码发送到调试控制台，其中显示:

now.strftime("%A, %d %B, %Y at %X")
'Friday, 07 June, 2021 at 12:43:32'

同时，调试控制台也有来自应用程序内部的异常，这些异常可能不会显示在终端中。例如，如果您在“运行”视图的“调用堆栈”区域看到“异常时暂停”消息，请切换到调试控制台查看异常消息。为了更容易地重复访问某个特定的 URL，如 http://127.0.0.1:8000/helloworld/VSCode ，在 views.py 这样的文件中的某个位置使用 print 语句输出该 URL。该 URL 出现在 VS 代码终端中，您可以使用 Ctrl+click 在浏览器中打开它。

完成后，请确保关闭浏览器，并使用“停止”工具栏按钮(红色方块)或“运行➤停止调试”命令(Shift+F5)停止调试器。

使用定义和查看定义命令

当您使用 Django 或任何其他库时，您需要不时地检查这些库中的代码。为此，VS Code 提供了两个方便的命令，它们直接指向任何代码中的类和其他对象的定义。

转到定义从您的代码转移到定义对象的代码。例如，在 views.py 中，右键单击 home 函数中的 HttpResponse 并选择 Go to Definition(或使用 F12 ),这将引导到 Django 库中的类定义。

Peek Definition(或 Alt+F12)用于直接在编辑器中显示类定义，在编辑器窗口中留出空间以避免干扰任何代码。要关闭 Peek 窗口，请按 Escape 或使用右上角的 x。

使用模板呈现页面

在 Django 中创建的第一个应用程序通常只有来自 Python 代码的纯文本网页。即使有可能直接在代码中获得 HTML，开发人员也很少这么做，因为这会让应用程序面临跨站点脚本(XSS)攻击。在最简单的 hello_there 函数中，人们可能会想到用代码编辑输出，内容如= "

Hello there，"+ clean_name +"！

，内容结果直接附加到浏览器。这个漏洞使得攻击者能够在 URL 中放置恶意 HTML，包括 JavaScript 代码，这些代码会变成 clean_name，从而最终在浏览器中运行。

通过使用模板将 HTML 完全排除在代码之外(这样您的代码只关心数据值)被认为是一个更好的实践。在 Django 中，模板是一个 HTML 文件，其中包含代码在运行时提供的值的占位符。然后，Django 模板引擎必须在呈现页面时进行替换，并提供自动转义来防止 XSS 攻击。因此，代码只关心数据值和标记。Django 模板提供了很好的选项，比如模板继承，它允许您用公共标记定义一个基础页面，然后在这个基础上使用不同的特定于页面的附加内容进行扩展。

首先，使用 web_project/settings.py 文件中的模板创建一个页面。首先，找到 INSTALLED_APPS 列表并添加以下条目，这确保项目熟悉应用程序并可以处理模板:“hello”。在 hello 文件夹中，创建一个名为 templates 的文件夹，然后创建另一个名为 hello 的子文件夹来匹配应用程序。

之后，在 templates/hello 文件夹中，创建一个名为 hello_there.html 的文件，内容如下。该模板必须有两个数据值占位符，名为“name”和“date”，用大括号{{ and }}隔开。所有其他文本也被认为是模板的一部分，连同格式化标记(例如**)。模板占位符也可以包含格式，比如管道|符号后面的表达式，在这种情况下使用 Django 内置的日期过滤器和时间过滤器。然后，代码只需要以如下方式传递日期时间值: ³**

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>This is Django</title>
    </head>
    <body>
        <strong>Hello people, {{ name }}!</strong> It's {{ date | date:"l, d F, Y" }} at {{ date | time:"H:i:s" }}
    </body>
</html>

在 views.py 的顶部，添加以下 import 语句:from django . shortcut s import render。

同样在 views.py 中，编辑 hello_world 函数以使用 Django.shortcuts.render 方法加载模板并提供模板上下文。这里的上下文代表模板中的一组变量。render 函数接受请求对象，后跟相对于 templates 文件夹的模板路径，然后是上下文对象:

def hello_there(request, name):

    return render(
        request,
        'helloworld/hello_world.html',
        {
            'name': name,
            'date': datetime.now()
        }
    )

请注意，这样代码看起来简单多了，并且只关心数据值，因为标记和格式都位于模板中。现在您可以启动程序(在调试器内部或外部，使用 Ctrl+F5)，导航到/hello/name URL，并观察结果。您还可以使用类似于

提供静态文件

静态文件表示您的 web 应用程序针对某些请求按原样返回的内容，例如级联样式表文件。提供静态文件需要 settings.py 中的 INSTALLED_APPS 列表包含 Django.contrib.staticfiles，这是默认包含的。

在部署到生产环境时，会使用静态文件服务。他们使用 Django 开发服务器，也使用 Gunicorn 这样的生产服务器。在生产中，还需要在 settings.py 中设置 DEBUG=False，这是使用容器时进行一些额外工作所必需的。

读取应用程序中的静态文件

要准备好应用程序，请在项目的 web_project/urls.py 中添加以下导入语句:from django . contrib . static files . URLs import static files _ URL patterns。在同一个文件中，在末尾包含以下行，该行包含项目识别的列表的标准静态文件 URL:URL patterns+= static files _ URL patterns()。

引用静态文件

要引用静态文件，请在 hello 文件夹中创建一个名为 static 的文件夹。在静态文件夹中，创建一个名为 hello 的子文件夹，与应用程序名称相匹配。这个额外的子文件夹的原因是，当您将 Django 项目部署到生产服务器时，您将所有的静态文件合并到一个单独的文件夹中，该文件夹由一个专用的静态文件服务器提供服务。static/hello 子文件夹可确保在合并应用程序的静态文件时，它们位于特定于应用程序的子文件夹中，不会与同一项目中其他应用程序的文件冲突。

然后，在 static/hello 文件夹中，创建一个名为 site.css 的文件，其内容如下。输入这段代码后，还可以看到 VS 代码为 CSS 文件提供的语法突出显示，包括颜色预览:

.message {
    font-weight: 600;
    color: blue;
}

在 templates/hello/hello _ there . html 中，在

element. The {% load static %} tag is a custom Django template tag set, which lets you use {% static %} to refer to a file like the stylesheet:<pre>{% load static %} <link rel="stylesheet" type="text/css" href="{% static 'helloworld/site.css' %}" /> </pre>

同样在 templates/hello/hello _ there . html 中，用以下标记替换 contents 元素，该标记使用消息样式而不是标记:

<span class="message">Hello, buddy {{ name }}!</span> It's {{ date | date:'l, d F, Y' }} at {{ date | time:'H:i:s' }}.

现在，当您运行应用程序时，导航到/hello/name URL，并注意到消息呈现为蓝色。完成后，不要忘记停止应用程序。

使用 Collectstatic 命令

出于生产目的，您需要使用 python manage.py collectstatic 命令将应用程序中的所有静态文件收集到一个文件夹中。然后你可以用一个专用的静态文件服务器来服务这些文件，因为大多数问题是更好的整体性能。下面的步骤展示了这个集合是如何产生的，即使在使用 Django development server 运行时并不使用这个集合。

在 web_project/settings.py 中，添加以下代码行，以标识应用 collectstatic 命令时收集静态文件的确切位置:

STATIC_ROOT = BASE_DIR / 'static_collected'

稍后，在终端中，尝试运行命令 python manage.py collectstatic，并注意 hello/site.css 与 manage.py 一起被复制到顶级 static_collected 文件夹中。

创建扩展基本模板的多个模板

因为大多数 web 应用程序有多个页面，并且这些页面通常共享许多公共项目，所以开发人员将这些公共项目拆分到一个基础页面模板中，然后其他页面模板可以扩展该模板。这个过程也称为模板继承，意味着扩展页面从基本页面继承元素。

此外，因为您很可能需要创建多个扩展同一模板的页面，所以在 VS 代码中创建一个代码片段非常有用，这样您可以更快地初始化新的页面模板。代码片段有助于防止繁琐且容易出错的操作。

创建基础页面模板和样式

Django 中的基本页面模板拥有一组页面的所有共享位，包括对脚本文件的引用。基本模板还定义了一个或多个块标记，其内容将被扩展模板覆盖。在基本模板和扩展模板中，块标记由{% block %}和{% endblock %}描述。

在 templates/hello 文件夹中，用内容创建一个名为 layout.html 的文件，该文件包含名为“标题”和“内容”的块。标记应该能够定义一个简单的 navbar 结构，其中包含指向主页、关于和联系人页面的链接。您可以使用 Django 的{% URL %}标记，通过相应 URL 模式的名称而不是相对路径来引用其他页面。此时您可以运行应用程序，但是因为您没有在任何地方使用基础模板，也没有更改任何代码文件，所以结果将是相同的。

创建代码片段

如果您发现自己正在创建多个扩展 layout.html 的页面，那么创建一个代码片段来初始化一个新的模板文件，并适当地引用基本模板，将会节省时间。代码片段保护来自单一来源的代码的一致部分，这防止了在使用来自活动代码的复制-粘贴时可能发生的错误。

要在 VS 代码中创建代码段，请选择文件(Windows 和 Linux)或代码(macOS)，菜单，然后选择首选项➤用户代码段。在出现的列表中，选择 HTML。如果您以前创建过代码段，该选项还可能在列表的“现有代码段”部分显示为“html.json”。

VS 代码打开 html.json 后，用 Ctrl+S 保存，现在。任何时候你开始输入代码段的前缀，比如 djext，VS Code 都会以自动完成的形式提供代码段。您也可以使用“插入代码段”命令从菜单中选择代码段。

使用数据、数据模型和迁移

许多 web 应用程序操作存储在数据库中的数据，Django 使得通过模型表示数据库中的项目变得非常简单。在 Django 中，模型是来自 Django 的 Python 类。DB.models.Model，代表特定的数据库对象，很可能是一个表，位于应用程序的 models.py 文件中。

使用 Django，您可以通过代码中定义的模型来管理数据库。随着时间的推移，当您修改模型时，Django 的迁移会自动处理底层数据库的所有细节。一般系统是这样的:

对 models.py 文件中的模型进行更改。
运行 python manage.py makemigrations 在 migrations 文件夹中创建脚本，将数据库从其当前条件迁移到新条件。
运行 python manage.py migrate 将脚本应用于基本数据库。

迁移脚本可以记录您对数据模型所做的所有增量更改。通过应用迁移，Django 使数据库适应您的需求。因为每个增量更改都有自己的脚本，Django 可以自动将数据库的任何先前版本迁移到新安装的版本。您只需要专注于 models.py 中的模型，而不是底层数据库系统或迁移脚本。

在代码中，您也只操作您的模型类来存储和收集数据，因为 Django 处理所有其他底层细节。只有一个例外，如果您使用 Django 管理实用程序 loaddata 命令，您可以将数据写入数据库。该命令通常用于在 migrate 命令初始化后启动数据集。

使用 DB.sqlite3 文件时，还可以使用 sqlite 浏览器等工具直接处理数据库。使用它可以在表中添加或删除记录，但最好避免对数据库模式进行更改，因为这样会与应用程序的模型不同步。最好是更改模型，运行 makemigrations，然后激活 migrate。

数据库的类型

默认情况下，Django 有一个用于开发工作的应用程序数据库的 DB.sqlite3 文件。SQLite 适用于每天点击量少于 100 K 的中低流量网站，但对于较高的流量来说不是最佳选择。 ^{4 因此，最好考虑使用生产级数据存储，如 PostgreSQL、MySQL 和 SQL Server。您还可以应用 Azure SDK for Python 来处理 Azure 存储服务，如表和 blobs。}

迁移数据库

当您通过编辑 models.py 来更改数据模型时，您将需要更新数据库本身。为此，在 VS 代码中打开一个终端，激活虚拟环境，导航到项目文件夹，然后运行以下命令:python manage.py makemigrations 和 python manage.py migrate。

如果您查看一下 migrations 文件夹，您现在应该能够看到 makemigrations 生成的脚本。您还可以查看数据库，查看模式是否已更新。如果您在运行命令时看到错误，请确保您没有使用之前步骤留下的调试终端，因为它们可能没有激活虚拟环境。

创建超级用户并启用管理界面

默认情况下，Django 为 web 应用程序提供了一个很好的管理界面，该界面受到身份验证的保护。该接口通过内置的 Django.contrib.admin 应用程序使用，该应用程序默认包含在项目的 INSTALLED_APPS 列表(settings.py)中，身份验证由内置的 Django.contrib.auth 应用程序管理，该应用程序也是内置的 INSTALLED_APPS。

您应该执行以下步骤来启用管理界面:首先，通过在虚拟环境的 VS 代码中打开一个终端，在应用程序中创建一个超级用户帐户，然后运行命令 python manage . py createsuperuser-username =-email =，使用您的个人信息替换和。当您运行该命令时，Django 会要求您输入并确认您的密码。请务必记住您的用户名和密码组合。这些是您使用应用程序进行身份验证所需的主要凭据。在项目级 urls.py(本教程中为 web_project/urls.py)中添加以下 URL 路由，以指向内置管理接口:

path("admin/", admin.site.URLs),

运行服务器，然后打开浏览器到 app 的/admin 页面(比如使用开发服务器时的 http://127.0.0.1:8000/admin )。登录页面出现后，输入您的用户凭据。

当您完全通过身份验证时，您会看到默认的管理页面，通过该页面您可以管理用户和组。您可以随意定制管理界面，甚至提供编辑和删除数据库中条目的功能。

烧瓶显影

Flask 是一个面向 web 应用的轻量级 Python 框架，为 URL 路由和页面呈现提供了基础(图 4-2 )。

img/514155_1_En_4_Fig2_HTML.jpg

图 4-2

Python web 开发框架 Flask

由于缺少表单验证、数据库抽象和身份验证等功能，Flask 通常被称为微框架。因此，这些特性由称为 Flask extensions 的特殊 Python 包提供。这些延伸与烧瓶设计无缝结合，使它们看起来就像是烧瓶本身的一部分。例如，Flask 没有页面模板引擎，但是下载 Flask 默认包含 Jinja 模板引擎。

在这个 Flask 部分，我们将回顾 VS 代码的许多特性，包括使用终端、编辑器、调试器、代码片段等等。

首先，成功安装 Python 3 的一个版本(本章前面提供了选项)。之后，您应该创建一个安装 Flask 的虚拟环境。使用虚拟环境可以避免将 Flask 安装到全局 Python 环境中，并使您能够精确控制应用程序中使用的库。虚拟环境还使得为环境建立 requirements.txt 文件变得容易。

在您的文件系统上，创建一个名为 hello_flask 的项目文件夹。在该文件夹中，使用以下命令(取决于您的计算机)基于您当前的解释器创建一个名为 env 的虚拟环境:

对于 Linux:
对于 macOS:

python3 -m venv env

对于 Windows:

python3 -m venv env

python -m venv env

确保在激活这些命令时使用普通 Python 安装。如果从 Anaconda 安装中使用 python.exe，将会得到一个错误，因为 ensurepip 模块不可用，并且环境处于未完成状态。

您可以通过运行代码或运行 VS 代码并使用文件➤打开文件夹命令，在 VS 代码中打开项目文件夹。在 VS 代码中，应该打开命令调板(查看➤命令调板或者(Ctrl+Shift+P))。然后点击 Python: Select Interpreter 命令。该命令将显示 VS 代码可以自动提供的可用解释器列表。从列表中，在您的项目文件夹中查找以开始的虚拟环境。/env 或。\env。

从命令面板创建新的集成终端(Ctrl+Shift+`)，它组成一个终端，并通过运行其激活脚本自动激活虚拟环境。但是，如果您使用的是 Windows，并且您的默认终端类型是 PowerShell，您可能会得到一个错误，即它无法运行 activate.ps1，因为系统上禁用了运行脚本。没有必要担心，因为该错误将提供一个链接，提供有关如何允许脚本的信息。否则，您可以使用 Terminal: Select Default Shell 将“命令提示符”或“Git Bash”设置为默认值。

所选的环境应该出现在 VS 代码状态栏的左侧，当它注意到“(venv)”指示器时，它会告诉您正在使用一个虚拟环境:

**python-m pip install-upgrade pip:**在 VS 代码终端运行以下命令，在虚拟环境中更新 pip。
python -m pip 安装 flask: 在 VS 代码终端的虚拟环境中安装 flask。

现在，您可以在一个自包含的环境中编写您的第一个 Flask 代码了。使用终端时，VS 代码自动激活环境:创建新的集成终端。当您打开单独的命令提示符或终端时，通过运行 source env/bin/activate(Linux/MAC OS)或 env \ Scripts \ activate . PS1(Windows)来激活环境。如果命令提示符开头显示(env ),您将看到环境被激活。

创建和运行最小的 Flask 应用程序

在 VS 代码中，通过菜单中的“文件”“➤”“新建”或按 Ctrl+N，在名为 app.py 的项目文件夹中创建一个新文件。之后，在 app.py 中，添加代码以导入 Flask 并创建 Flask 对象的实例。如果您键入以下代码(而不是使用复制-粘贴)，您可以看到 VS 代码的智能感知和自动完成:

from flask import Flask
app = Flask(__name__)

您还可以在 app.py 中插入一个返回内容的函数或简单字符串，并使用 Flask 的 app.route decorator 将 URL route /映射到该函数:

@app.route("/")
def home():
    return "Hello, Flask!"

也可以在同一个函数上使用多个 decorators，每行一个，这取决于您想要将多少不同的路径映射到同一个函数。

在集成终端中，通过输入 python -m flask run 运行应用程序，然后激活 flask 开发服务器。默认情况下，开发服务器会搜索 app.py。如果运行 Flask，您应该会看到类似如下的输出:

(env) D:\py\\hello_flask_app>python -m flask run
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

如果您看到一个错误，请确保您已经在您的虚拟环境中运行了 python -m pip install flask，如前所述。同时，如果您想在不同的 IP 地址或端口上运行开发服务器，可以使用 host 和 port 命令行参数，比如- host=0.0.0.0 - port=80。

要在默认浏览器中打开呈现的页面，请按住 Ctrl 并单击终端中的 http://127.0.0.1:5000/ URL。请注意，如果您访问类似/的 URL，调试终端中将弹出一条消息，显示 HTTP request:127 . 0 . 0 . 1--[11/Jun/2021 12:40:10]" GET/HTTP/1.1 " 200-

如果您想使用不同于 app.py 的文件名，比如 program.py，您需要指定一个名为 FLASK_APP 的环境变量，并将其值设置为您打开的文件。Flask 的开发服务器然后应用 FLASK_APP 的值，而不是默认文件 app.py，完成后，可以在终端中使用 Ctrl+C 来停止应用程序。

在调试器中运行应用程序

调试器工具允许您在特定代码行暂停正在运行的程序。当程序暂停时，您可以访问变量，在调试控制台面板中运行代码，或者利用调试中描述的功能，例如在每次调试前自动保存任何修改的文件。

在开始之前，你需要检查你是否已经在最后一节结束时通过在终端中点击 Ctrl+C 停止了正在运行的应用程序。如果您让应用程序在一个终端中运行，它将继续拥有该端口，当您使用相同的端口在调试器中运行应用程序时，最初运行的应用程序将管理所有请求，您将不会观察到正在调试的应用程序中的任何活动，并且程序不会在断点处停止。简而言之，如果调试器似乎不工作，你必须确保应用程序的其他部分都没有运行。

然后，用下面的代码替换 app.py 的内容，这样就添加了第二个路径和函数，您可以在调试器中逐步执行:

从烧瓶进口烧瓶
从日期时间导入日期时间
进口 re

app = Flask(__name__)

@app.route("/")
def home():
    return "Hello, Folks!"

@app.route("/helloworld/<name>")
def hello_world(name):
    now = datetime.now()
    formatted_now = now.strftime("%A, %d %B, %Y at %X")

将名称参数过滤为字母时，请仅使用正则表达式。URL 参数可以包含任意文本；因此，它仅限于安全字符。

装饰者申请了新的 URL 路由，/hello/ ，描述了一个端点/hello/route 中的标识符< and >代表传递给函数的变量，可以在代码中使用。

正如您已经知道的，URL 路由是区分大小写的。例如，路由/helloworld/ 不同于/HelloWorld/ 。如果你需要同一个函数来管理这两者，试着为每个变体应用装饰器。此外，如代码注释中所述，始终过滤用户提供的任意信息，以防止对您的应用程序的各种攻击。在这种情况下，代码过滤 name 参数，使其只包含字母，从而避免了控制字符和 HTML 的注入。然而，当您在下一个项目中使用模板时，Flask 将执行自动过滤，并且您不需要再次编写代码脚本。

在 hello_world 函数(now = DateTime.now())的第一行代码中设置断点非常简单，如果您通过下面的方法来完成:

光标在该行上时按 F9
将光标置于该行上，选择“运行切换断点”菜单命令
直接在行号左边的空白处单击

之后，您应该能够看到断点在左边空白处显示为一个红点。

您可以在 VS 代码中切换到 Run 视图(使用左侧的活动栏或 F5)，之后您可能会看到消息“To customize Run and Debug create a launch . JSON file”这表明您还没有包含各种调试特性的 launch.json 文件。一旦你点击创建一个 launch.json 文件链接，VS 代码就可以为你生成这些文件。

当您选择链接时，VS 代码将启动调试配置。从下拉列表中选择 Flask，VS 代码将使用 Flask 运行配置填充一个新的 launch.json 文件。launch.json 文件有许多调试配置，每个配置都是配置数组中自己的 json 对象。

向下滚动并检查名为“Python: Flask”的配置。这个配置由“模块”:“flask”，它告诉 VS 代码在打开调试器时用-m flask 运行 Python。它还在 env 属性中定义了 FLASK_APP 环境变量来定位启动文件，默认情况下该文件是 app.py，但是您可以轻松地指定一个不同的文件。当您需要更改主机或端口时，可以使用 args 数组。只需点击 Ctrl+S 即可保存 launch.json。

接下来，在调试配置列表中选择 Python: Flask 配置。通过选择“运行➤启动调试”菜单命令，或通过选择列表旁边的绿色启动调试箭头(F5)，启动调试器。请注意状态栏是如何改变颜色来指示调试的。调试工具栏也在 VS 代码中按以下顺序显示命令:暂停(或继续，F5)、单步执行(F10)、单步执行(F11)、单步执行(Shift+F11)、重新启动(Ctrl+Shift+F5)和停止(Shift+F5)。

输出通常出现在 Python 调试控制台终端中。按住 Ctrl 键并单击该终端中的 http://127.0.0.1:5000/ 链接，以打开该 URL 的浏览器。在浏览器的地址栏中，转到 http://127.0.0.1:5000/helloworld/VSCode 。在页面下载之前，VS 代码会在您建立的断点处暂停程序。断点上的黄色小箭头表示这是要激活的下一行代码。

使用 Step Over 函数运行 now = DateTime.now()语句。在 VS 代码窗口的左侧，您可以查看显示局部变量和参数(如 now 和 name)的变量窗格，以及监视、调用堆栈和断点窗格。在“局部变量”部分，您可以通过双击不同的值或使用 F2 来展开它们。然而，像现在这样改变变量会破坏程序。当代码在开始没有产生正确的值时，开发人员通常只对正确的值进行更改。

当程序暂停时，调试控制台面板允许您使用程序的当前状态尝试不同的表达式和代码位。例如，一旦跨过 now = DateTime.now()这一行，就可以测试不同的日期和时间格式。为此，在编辑器中选择代码 now.strftime("%A，%d %B，%Y at %X ")，然后右键单击并选择 Debug: Evaluate，将代码发送到调试控制台，在那里运行:

now.strftime("%A, %d %B, %Y at %X")
'Sunday, 20 June, 2021 at 14:23:32'

调试控制台还揭示了应用程序内部的异常，这些异常可能不会出现在终端中。例如，如果您在“运行”视图的“调用堆栈”区域看到“异常时暂停”消息，请切换到调试控制台查看异常行。之后，将该行复制到调试控制台底部的>提示符中，并尝试修改格式:

now.strftime("%a, %d %B, %Y at %X")
'Sunday, 20 June, 2021 at 14:23:32'
now.strftime("%a, %d %b, %Y at %X")
'Sunday, 20 June, 2021 at 14:23:32'
now.strftime("%a, %d %b, %y at %X")
'Sunday, 20 June, 2021 at 14:23:32'

当您看到喜欢的更改时，可以在调试会话期间将其复制并粘贴到编辑器中。在您重新启动调试器之前，这些更改不会被应用。您可以再单步执行几行代码，然后选择 Continue (F5)让程序运行，直到浏览器窗口显示最终结果。

为了更容易地反复导航到特定的 URL，如 http://127.0.0.1:5000/helloworld/VSCode ，使用 print 语句输出该 URL。URL 在终端中弹出，您可以使用 Ctrl+click 在浏览器中打开它。完成后，请确保关闭浏览器，并使用“停止”工具栏按钮(红色方块)或“运行➤停止调试”命令(Shift+F5)停止调试器。

使用定义和查看定义命令

在使用 Flask 或任何其他库时，您可能希望查看这些库中的代码。VS 代码有两个方便的命令，可以直接操作任何代码中的类和其他项的定义:

转到定义从您的代码派生到描述对象的代码。例如，在 app.py 中，右键单击 Flask 类(在 app = Flask(name)行中)并选择“转到定义”(或单击 F12)，这将转到 Flask 库中的类定义。
Peek Definition (Alt+F12，也在右击上下文菜单上)与此有些相同，但是直接在编辑器中显示类定义(在编辑器窗口中留出空间，而不干扰任何代码)。要关闭 Peek 窗口，请按 Escape 键或使用右上角的 x。

使用模板呈现页面

用 Flask 创建的第一个应用程序通常只从 Python 代码生成纯文本网页。虽然可以在代码中直接插入 HTML，但开发人员会尽量避免这种做法，因为这会使应用程序面临跨站点脚本(XSS)攻击。例如，在本教程的 hello_world 函数中，人们可能会想到用 content = "

Hello buddy，"+ clean_name +"！

，内容结果直接给浏览器。这个漏洞还可能给一些攻击者机会在以 clean_name 结尾的 URL 中放置恶意 HTML，包括 JavaScript 代码，从而最终在浏览器中运行。

更好的做法是通过应用模板将 HTML 完全置于代码之外，这样您的代码就只关心数据值而不关心呈现。模板是一个 HTML 文件，其中包含代码在运行时提供的值的占位符。模板引擎主要处理在呈现页面时放置替换。因此，代码只关心数据值，模板只关心标记项。

Flask 的默认模板引擎是 Jinja，它与 Flask 同时安装。该引擎提供了灵活的选项，如自动转义(以避免 XSS 攻击)和模板继承。通过继承，您可以轻松地用公共标记定义一个基本页面，然后在此基础上添加特定于页面的内容。

为了使用模板创建单个页面，请在 hello_flask 文件夹中创建一个名为 templates 的文件夹，默认情况下，flask 在这个文件夹中查找模板。在 templates 文件夹中，创建一个名为 hello_there.html 的文件，其内容如下。此模板需要两个名为“姓名”和“日期”的占位符，用大括号对{{和}}分隔。

在 app.py 中，在文件顶部附近导入 Flask 的 render_template 函数:

from flask import render_template

同样在 app.py 中，编辑 hello_there 函数以使用 render_template 加载模板并应用命名的值(并包含一个路由以识别没有名称的案例)。Render_template 假定第一个参数相对于 templates 文件夹。通常，开发人员将模板命名为与使用它们的函数相同的名称，但是不需要匹配的名称，因为您总是在代码中引用确切的文件名:

@app.route("/helloworld/")
@app.route("/helloworld/<name>")
def hello_world(name = None):
    return render_template(
        "hello_world.html",
        name=name,
        date=datetime.now()
    )

请注意，这段代码看起来简单多了，并且只涉及数据值，因为标记和格式都适合模板。

启动程序(使用 Ctrl+F5)后，导航到/helloworld/name URL 并观察结果。您还可以尝试使用类似于

为环境创建 Requirements.txt 文件

当您使用源代码控制或任何其他方法共享您的应用程序代码时，在虚拟环境中复制所有文件没有多大意义，因为接收者总是可以自己重新共享环境。

因此，开发人员通常会跳过源代码控制中的虚拟环境文件夹，而是使用 requirements.txt 文件写下应用程序的依赖关系。即使您可以手动创建文件，也可以使用 pip freeze 命令根据激活环境中附着的库重新设计文件。

在您选择的环境中，尝试使用 Python: Select Interpreter 命令并运行 Terminal:Create New Integrated Terminal 命令(Ctrl+Shift+`))来打开一个激活了该环境的终端。在同一个终端中，运行 pip freeze ➤ requirements.txt，在您的项目文件夹中创建 requirements.txt 文件。

任何获得项目副本的接收者只需要运行 pip install -r requirements.txt 命令就可以用它们原来的环境重新加载包。Pip freeze 能够列出您在当前环境中安装的所有 Python 包，包括当前不活动的包。该命令还列出了带有精确版本号的包，您可能需要在将来的某个时候将这些版本号转换为更适用的范围。

最后，记住 flask-snippets 是 flask 开发中流行的 VS 代码扩展。然而，一些片段经常与 Flask 开发周期不一致，所以在使用时应该小心。

数据科学—特定信息和教程

本节演示了如何使用 VS 代码和 Microsoft Python 扩展以及公共数据科学库来重新创建一个基本的数据科学场景。具体来说，它涵盖了如何设置数据科学环境，导入和清理数据，创建机器学习模型，以及评估生成的模型的准确性。在开始之前，安装由 Microsoft 从 Visual Studio Marketplace 发布的名为 Python 的 VS 代码的 Python 扩展。

如果您已经安装了完整的 Anaconda 发行版，那么就没有必要安装 Miniconda。或者，如果您不喜欢使用 Anaconda 或 Miniconda，您可以创建一个 Python 虚拟环境，并使用 pip 安装教程所需的包。如果您选择这条路线，您应该首先安装以下软件包:pandas、jupyter、seaborn、scikit-learn、keras 和 TensorFlow。

建立数据科学环境

VS 代码和 Python 扩展为数据科学场景提供了很好的编辑器。通过对 Jupyter Notebook 与 Anaconda 相结合的本机支持，可以很容易地使用数据科学模块以及 Jupyter Notebook 创建 Anaconda 环境，您将使用 Jupyter Notebook 来创建机器学习模型。

首先，通过打开 Anaconda 命令提示符并运行 conda create-n myenv python = 3.7 pandas jupyter seaborn scikit-learn keras tensor flow 创建一个名为 myenv 的环境，为数据科学教程创建一个 Anaconda 环境。接下来，在首选位置创建一个文件夹作为您的 VS 代码工作区，并将其命名为 hello_ds。通过运行 VS 代码并使用文件➤打开文件夹命令，在 VS 代码中打开项目文件夹。当 VS 代码启动时，打开命令面板(查看➤命令面板或 Ctrl+Shift+P)并选择 Python: Select 解释器命令。

Python: Select 解释器命令将显示 VS 代码能够自动指示的可用解释器列表(如果您没有看到所需的解释器，请参见配置 Python 环境)。从这个列表中，转到您创建的 Anaconda 环境，它应该包含文本“myenv”:conda。

准备好环境和 VS 代码后，最后一步是通过打开命令面板(Ctrl+Shift+P)并选择 Jupyter:Create New Blank Jupyter Notebook 来创建 Jupyter 笔记本。

或者，从 VS 代码文件资源管理器中，您可以单击新建文件图标来创建一个名为 hello.ipynb 的笔记本文件。一旦创建了文件，您应该尝试在本地笔记本编辑器中打开 Jupyter Notebook。

准备数据

本节展示了如何使用 OpenML.org 上可用的 Titanic 数据集加载和操作 Jupyter 笔记本中的数据，该数据集是从位于 http://biostat.mc.vanderbilt.edu/DataSets 的范德比尔特大学生物统计系获得的。泰坦尼克号的数据提供了泰坦尼克号上乘客生存的主要信息，以及乘客的属性，如姓名和年龄。使用这些数据，你应该尝试建立一个模型来预测一个给定的乘客是否会在泰坦尼克号沉没后幸存。

从 OpenML.org 下载名为 data.csv 的 CSV 文件格式的 Titanic 数据，并将其保存到您在上一节中已经创建的 hello_ds 文件夹中。

在 VS 代码中，打开 hello_ds 文件夹和 Jupyter 笔记本(hello.ipynb ),方法是转到文件➤打开文件夹。在 Jupyter 笔记本中，首先导入 pandas 和 NumPy 库，这两个库最常用于操作数据，并将 Titanic 数据加载到 pandas 数据帧中。将以下代码复制并粘贴到笔记本的第一个单元格中:

进口熊猫作为 pd
将 numpy 作为 np 导入
data = PD.read_csv('data.csv ')

之后，使用运行单元图标或 Shift+Enter 快捷键运行单元。

一旦单元完成运行，您就可以使用变量浏览器和数据查看器检查加载的数据。首先单击笔记本上部工具栏中的图表图标，然后单击数据变量右侧的数据查看器图标。然后，可以激活数据查看器来查看、排序和过滤数据行。在你分析完数据之后，用图表来描述不同变量之间的关系是很有用的。但是，在将数据制成图表之前，您需要确保它没有任何问题。如果你看泰坦尼克号的 CSV 文件，你可能会注意到一个问号(“？)被插入以指定无法获得数据的单元格。

虽然 Pandas 可以将该值放入 DataFrame 中，但 Age 数据类型等列的结果将被设置为 Object 而不是 numeric 数据类型，这在图形中很难可视化。这个问题可以通过将问号替换为熊猫能够读取的缺失值来避免。要添加新单元格，您可以单击现有单元格左下角的插入单元格图标，或者使用 Esc 键进入命令模式，然后按 B 键:

data.replace('?', np.nan, inplace= True)
data = data.astype({"age": np.float64, "fare": np.float64})

如果您需要查看列所使用的数据类型，可以使用 DataFrame dtypes 属性。

现在数据已经整理好了，是时候应用 seaborn 和 matplotlib 来看看数据集的某些列是如何与泰坦尼克号乘客的生存机会相关联的。为此，将以下代码添加到笔记本中的下一个单元格，并运行它以查看生成的绘图:

将 seaborn 作为 sns 导入
将 matplotlib.pyplot 输入为 plt

fig, axs = plt.subplots(ncols=5, figsize=(30,5))
sns.violinplot(x="survived", y="age", hue="sex", data=data, ax=axs[0])
sns.pointplot(x="sibsp", y="survived", hue="sex", data=data, ax=axs[1])
sns.pointplot(x="parch", y="survived", hue="sex", data=data, ax=axs[2])
sns.pointplot(x="pclass", y="survived", hue="sex", data=data, ax=axs[3])
sns.violinplot(x="survived", y="fare", hue="sex", data=data, ax=axs[4])

为了更好地查看图表的详细信息，您可以通过在图表的左上角共享它们来在绘图查看器中打开它们。这些图表在寻找存活率和数据的输入变量之间的一些关系以及变量之间所有可能的计算相关性时非常有用。为此，所有用于计算的变量都必须是数字，性别数据存储为字符串。要将这些字符串值转换为整数，请编写脚本并运行以下代码:

data.replace({'male': 1, 'female': 0}, inplace=True)

既然您可以分析所有输入变量之间的相关性，那么识别将成为机器学习模型的最佳输入材料的特征就变得更简单了。从统计学上来说，一个值越接近 1，该值和结果之间的相关性就越高。您可以应用以下代码来关联所有变量和存活率之间的关系:

data.corr().abs()[["survived"]]

仔细观察相关性结果，您可能会注意到一些变量，如性别，与存活率有相当高的相关性，而其他变量，如亲属(sibsp =兄弟姐妹或配偶，parch =父母或子女)，可能相关性很小。

假设 sibsp 和 parch 在如何影响生存能力潜力方面是相关的，并将它们分组到一个名为“亲戚”的新列中，以查看它们的组合是否具有更高的相关性水平。要做到这一点，您应该检查给定乘客的 sibsp 和 parch 的数量是否大于 0，如果是这样，您就可以声明他们在飞机上有亲属。使用以下代码在名为 relatives 的数据集中创建一个新的变量和列，并再次检查相关性:

data['relatives'] = data.apply (lambda row: int((row['sibsp'] + row['parch']) > 0), axis=1)
data.corr().abs()[["survived"]]

你还可以观察到，当从一个人是否有亲戚的角度分析时，相对于有多少亲戚，与存活率的相关性更高。有了这些信息，您现在可以从数据集中删除低值的 sibsp 和 parch 列以及具有 NaN 值的行，以创建可用于训练模型的数据集。

训练和评估模型

数据集准备就绪后，就可以开始创建模型了。为此，有必要使用 scikit-learn 库(因为它有一些最有用的帮助函数)来处理数据集，训练一个分类模型来显示泰坦尼克号上的生存能力，然后使用该模型和测试数据来修正其准确性。

训练模型的第一步通常是将数据集分成训练数据和验证数据。这使您可以使用一部分数据来训练模型，使用另一部分数据来评估模型。如果您使用所有的数据来训练模型，您将无法看到它相对于模型尚未看到的数据的实际表现如何。scikit-learn 库的一个优点是它提出了一种专门用于将数据集分成训练和测试数据的方法: ⁵

从 sklearn.model_selection 导入训练 _ 测试 _ 拆分

x_train, x_test, y_train, y_test = train_test_split(data[['sex','pclass','age','relatives','fare']], data.survived, test_size=0.2, random_state=0)

之后，您必须以平等对待所有项目的方式规范化输入。举例来说，在数据集中，年龄的值范围从 0 到 100，而性别只有 1 或 0。通过规范化所有变量，您可以确保值的范围保持一致。在新的代码单元格中使用以下代码来缩放输入值:

来自 sklearn .预处理导入标准缩放器

sc = StandardScaler()
X_train = sc.fit_transform(x_train)
X_test = sc.transform(x_test)

此外，有许多不同的机器学习算法可供选择，以对数据进行建模。scikit-learn 工具为其中的许多工具提供了强大的支持，并提供了一个图表来帮助寻找最适合您的场景的工具。现在，您应该尝试一下朴素贝叶斯算法，这是一种用于分类事务的常规算法。添加一个包含以下代码的单元格，以创建并试验该算法:

从 sklearn.naive_bayes 导入高斯

model = GaussianNB()
model.fit(X_train, y_train)

有了一个经过训练的模型，现在就可以用它来测试从训练中得到的测试数据集。包含并运行以下代码，以预测测试数据的结果并计算模型的准确性:

从 sklearn 导入指标

predict_test = model.predict(X_test)
print(metrics.accuracy_score(y_test, predict_test))

从测试数据的结果来看，你应该有一个训练好的算法，它能使估计的存活率达到 75%。

利用 Jupyter 笔记本来探索数据，再加上 VS Code 探索数据平台，让想法的实验变得更加容易。现在，您可以使用 IPython 内核定义和运行单个单元，可视化数据框，与绘图交互，重启内核，并将其直接导出到 Jupyter 笔记本中。此外，当涉及到将 Jupyter 笔记本导入 Python 时，可复制的和生产就绪的 VS 代码允许这种过渡非常顺利。有了这些特性，您现在可以在 VS 代码中交互地操作数据，对于那些喜欢使用编辑器来完成数据科学任务的人来说，这是一个令人兴奋的选择。

摘要

在本章中，我们首先从 VS 代码中的 Django 开发开始，然后转移到 Flask，熟悉两个最常见的 Python 框架。我们还讨论了与 VS 代码相关的数据科学，并涵盖了 Miniconda 等概念。在下一章，我们将继续我们对 VS 代码中 Python 编码的理解，并揭开一些新的话题。

Footnotes 1

VSC，《Django 教程 VSC》， https://code.visualstudio.com/docs/python/tutorial-django ，2021 年 7 月 29 日访问。

VSC，“VSC 中的 Django 教程”

SQLite，“何时使用 SQLite”，sqlite.org，访问日期。

VSC，《VS 代码教程中的数据科学》， https://code.visualstudio.com/docs/python/data-science-tutorial ，2021 年 7 月 29 日访问。

五、使用容器和 MS Azure

在前一章，我们学习了用 VS 代码开发 Django 和 Flask。在这一章中，我们将讨论容器和 Azure 女士。

VS 代码对远程开发有很大的支持，这是目前很流行的特性。它允许您通过安全外壳协议(SSH)连接到另一台机器，并在那里远程操作代码和各种语言服务。也可以连接到微软 Azure，在容器中管理你的开发环境。最后两个是本章的重点。

为您的 Python 项目集成 Azure

微软 Azure 通常被称为 Azure，是一个云计算平台，用于通过微软数据管理中心构建、测试和实现应用程序和服务(图 5-1 )。它特别重要，因为它提供了大量的开发工具和服务，比如构建和生产解决方案。

img/514155_1_En_5_Fig1_HTML.jpg

图 5-1

Microsoft Azure

它还充当软件即服务(SaaS)、平台即服务(PaaS)和基础设施即服务(IaaS)的提供商，并提供许多不同的编程语言、工具和框架、基于微软以及第三方指定的软件和系统。

在这一节中，我们将回顾 Azure 提供的一些更重要的服务，然后使用 VS 代码创建一个响应 HTTP 请求的 Python 函数。最后，我们将把 Docker 容器部署到 Azure 应用服务中。

关键 Azure 服务

Azure 在全球范围内的微软数据中心利用大规模虚拟化，并提供超过 600 种服务。

电脑服务

虚拟机或基础架构即服务(IaaS)提供商允许用户创建通用的 Microsoft Windows 和 Linux 虚拟机，以及用于按需软件集的预配置机器项目。由于提供了有益的 Linux 发行版和微软自己的基于 Linux 的 Azure Sphere，大多数用户在 Azure 上运行 Linux。此外，许多应用服务或平台即服务(PaaS)提供商使用 Azure 作为环境，让开发人员轻松发布和管理网站。此外，Azure 网站鼓励开发人员使用 ASP.NET、PHP、Node.js 或 Python 构建站点，并部署 Team Foundation Server 或通过用户门户上传。Azure 客户可以用 PHP、ASP.NET、Node.js 或 Python 创建网站，或者从几个开源应用程序中进行选择。这构成了微软 Azure 平台的平台即服务(PaaS)产品的一个方面。那些可以部署到应用服务环境以实现后台处理的应用可以按计划、按需或不间断地调用。

身份

受欢迎的以 Azure 身份为中心的产品包括:

Azure Active Directory 用于同步本地目录并支持单点登录。
Azure Active Directory B2C 支持在云中访问消费者身份和访问管理。
将 Azure 虚拟机加入没有域控制器的域时，Azure Active Directory 域服务被激活。
Azure 信息保护用于保护敏感信息。

Azure 移动服务

移动参与收集突出用户分析的实时数据。它还支持向移动设备推送通知。
可以安装 HockeyApp 来构建、分发和运行移动应用程序的各种测试版。

存储服务

存储服务为受众提供了在云上存储和访问数据的空间:

表服务允许程序将结构化文本存储在项目的分段集合中，这些集合通过分区或主键进行访问。Azure Table Service 的激活方式与任何其他 NoSQL 非关系数据库相同。
Blob 服务为程序提供了一个存储非结构化文本和二进制数据的地方，可以通过 HTTP(S)路径简单地访问这些数据。Blob 服务还具有内置的安全机制来限制和计算对数据的访问。
队列服务为程序提供了一个使用队列通过消息进行异步通信的平台。
文件服务允许使用流行的 REST APIs 和 SMB 协议在云上存储和访问数据。

数据管理

Azure Data Explorer 非常适合大数据分析和数据探索。
Azure Search 非常适合文本搜索和结构化数据过滤。
Cosmos DB 是一个 NoSQL 数据库服务，它在 JSON 文档上执行 SQL SELECT 语句的子集。
Azure Cache for Redis 是 Redis 的托管实现系统。
StorSimple 非常适合在不同设备和云存储之间分配存储任务。
Azure SQL Database 使用 Microsoft SQL Server 技术生产、扩展应用程序，并将其放入云中。它还可以与 Active Directory 和 Microsoft System Center 很好地集成。
Azure Synapse Analytics 是一个独立管理的云数据仓库。
Azure Data Factory 是一种数据集成服务，支持在云中创建数据驱动的工作流程，以实现数据集和数据转换的自动化。
Azure Data Lake 是另一个用于大数据分析和大规模并行查询的数据存储和分析服务平台。
Azure HDInsight 是一个数据相关的服务，支持使用 Linux 和 Ubuntu 创建不同的集群。
Azure Stream Analytics 是一个无服务器的事件处理工具，它使用户能够对来自设备、传感器、网站甚至社交媒体等来源的多组数据进行合并和实时分析。

信息产品

Microsoft Azure 服务总线允许应用程序在 Azure 内部或外部设备上运行，并与 Azure 集成。这也允许应用程序构建可靠的面向服务的架构。Azure 服务总线有四种不同类型的通信机制:

事件中心，以低延迟和高可靠性向云提供事件和遥测功能。例如，可以应用事件中心来跟踪来自手机的数据，如 GPS 实时位置。
队列，允许通过服务总线队列进行单向通信。尽管队列可以有多个读取器，但是只有一个读取器可以处理一条消息。
主题也提供单向通信，但是通过订阅者模式。它类似于队列，但是每个订阅者都可以获得发送到主题的消息的副本。此外，订户可以基于订户设置的各种标准过滤出消息。
另一方面，继电器提供双向通信。与队列和主题不同，中继不在自己的内存中存储传输中的消息，而是将数据传递给目的地应用程序。

加拿大

全球内容交付网络(CDN)对于音频、视频、应用程序、图像和其他静态媒体文件非常有用。它可以用来缓存在地理上离用户更近的网站的静态资产，以提高性能。通过 HTTP API 可以方便地管理网络。截至 2020 年 4 月， ¹ Azure 在全球拥有 94 个点的存在位置(也称为边缘位置)。

管理

Azure Automation management tool 为用户提供了一种自动化手动、长时间运行、容易出错和重复的任务的方法，这些任务经常在云或虚拟环境中执行。该工具不仅节省了时间并提高了日常管理任务的可靠性，而且还可以安排在固定的时间段自动完成这些任务。此外，您可以使用 runbooks 自动化流程，或者使用所需的状态配置自动化配置任务。

Azure AI

微软 Azure Machine Learning 代表一套超现代的工具和框架，供开发者设计自己的机器学习和人工智能(AI)服务。

Microsoft Azure Cognitive Services 是另一款产品，它为开发人员提供可定制的服务，使他们的应用程序更加智能、用户友好和受欢迎。这两个平台都包括感知和认知智能，涵盖语音识别、说话人识别、神经语音合成、人脸识别、计算机视觉、自然语言处理和机器翻译，以及商业决策服务。微软自己的产品和服务(如 Office、Teams 和 Xbox)中应用的大多数人工智能功能也由 Azure Cognitive Services 提供支持。

蓝色区块链维护作业

通过 Azure Blockchain Workbench，微软正在推动基础设施建立一个由多个区块链机制组成的联盟网络。该公司还渴望提供从 Azure 区块链平台到其他微软服务的集成，以分享分布式应用程序的开发。此外，微软支持许多通用区块链，如以太坊或 Hyperledger Fabric，以及其他专门构建的区块链，如 Corda。

Azure 目前在全球 54 个地区可用，被认为是首批承诺在南非地区建设设施的超大规模云提供商之一。截至目前，Azure geography 拥有多个 Azure 区域，如北欧(爱尔兰都柏林)和西欧(荷兰阿姆斯特丹)。

使用 VSC 用 Python 在 Azure 中创建函数

在本节中，我们将使用 VS 代码创建一个响应 HTTP 请求的 Python 函数。在本地测试完代码后，我们将尝试将其部署到 Azure Functions 的无服务器环境中。

以下是在 Azure 上使用 Python 的一些原因:

您可以在专为 Python 优化的云管理应用平台中构建 Python web 应用。对于流行的关系和非关系(SQL 和 NoSQL)数据库，也可以使用 Azure 服务将你的应用连接到数据。
出于数据科学和机器学习的目的，您可以使用 Azure 服务从任何 Python 环境中快速轻松地构建、测试和托管模型。Azure 还可以引入预构建的人工智能解决方案，为您的 Python 应用程序提供最流畅的体验。
有了 Azure，你可以用 VS 代码构建和调试你的 Python 应用。此外，Azure 和 VS 代码还与 GitHub 无缝集成，让您可以为 Python 应用程序运行完整的 DevOps 生命周期。
Azure 让你专注于应用程序的代码，而不是基础设施。这意味着你可以通过 Azure Web Apps 在 Azure 平台上运行 Django 和 Flask 应用，而 Azure 将管理底层应用的基础设施。
Azure 提供关系和非关系数据库作为托管服务。最流行的是 MySQL、Redis 和 Azure Cosmos DB(兼容 MongoDB)。

在开始之前，请配置您的环境，并确保您具备以下要求:一个 Azure 帐户，具有有效的订阅，并下载了 Azure Functions Core Tools 版。

为了使用 VS 代码在 Python 项目中创建您的本地 Azure Functions 项目，请在活动栏中选择 Azure 图标，然后转到 Azure: Functions 区域并选择 Create new project。接下来，为您的项目工作环境选择一个目录位置，并选择 Select。请确保使用您的 Outlook 或 Microsoft ID 登录 Azure。

这些简单的步骤被设计成在工作空间之外完成。因此，您不需要选择已经是工作空间一部分的项目文件夹。接下来，根据提示继续提供以下数据:

为您的函数项目选择一种语言:使用 Python。
选择 Python 集成来创建虚拟环境:选择 Python 解释器的位置。如果没有显示位置，请编写 Python 二进制文件的完整路径。
为项目的第一个功能选择一个模板:选择 HTTP trigger。
提供一个函数名:键入 HttpExample。
说到授权级别:选择匿名，这使得每个人都可以调用您的函数端点。
设置打开项目的方式:选择添加到工作区。

使用这些数据，VS 代码生成一个带有 HTTP 触发器的 Azure Functions 项目，这样您就可以在浏览器中查看本地项目文件。

然后，VS 代码将与 Azure Functions 核心工具集成，让您在将项目发布到 Azure 之前，在本地开发计算机上运行该项目。要激活您的功能，请按 F5 并启动 function app 项目。核心工具的输出位于终端面板中，这是您的应用程序启动的地方。在那里，您还可以看到本地运行的 HTTP 触发函数的 URL 端点。

如果在 Windows 上运行时出现问题，请检查 VS 代码的默认终端是否没有设置为 Windows Subsystem for Linux(WSL)Bash。你也可以手动操作，进入 Azure: Functions 区域，在 Functions 下，展开本地项目➤函数。右键单击(Windows)或按住 Ctrl 单击(MAC OS)http example 函数，然后选择“立即执行函数”。

在输入请求正文中，您应该能够看到{ "name": "Azure" }的请求消息正文值。按 Enter 键将此请求消息发送到您的函数，或者在 web 浏览器中手动将 HTTP GET 请求发送到 HTTP://localhost:7070/API/HTTP example 地址。当函数在本地被激活并返回响应时，会在 VS 代码中显示一个通知。按 Ctrl + C 停止核心工具并断开调试器。

在您确认该函数在您的本地计算机上正确运行之后，您现在可以访问 VS 代码来将项目直接发布到 Azure。但是，在发布应用程序之前，您应该登录 Azure。如果您尚未登录，请在活动栏中查找 Azure 图标，然后在 Azure: Functions 区域中，单击 Sign in to Azure。如果您还没有 Azure 帐户，您可以创建一个免费帐户。如果你是学生，你有资格为学生创建一个免费的 Azure 帐户。成功登录后，您可以关闭新的浏览器窗口。您激活的订阅将显示在侧边栏中。

为了将项目发布到 Azure，您需要在您的 Azure 订阅中制作一个功能应用程序和相关资源，然后部署您的代码。通常，发布到现有的功能应用程序会覆盖 Azure 中该应用程序的内容。首先，在活动栏中选择 Azure 图标，然后在 Azure: Functions 区域单击 Deploy to function app 按钮。

您还需要提供以下信息:

**选择文件夹:**从您的工作区中找到一个文件夹，或者浏览到一个包含您的功能应用程序的文件夹。如果您已经运行了有效的功能应用程序，您将看不到此信息。
**选择订阅:**选择要申请的订阅。如果您只有一份套餐，您将看不到此内容。
**在 Azure 中选择功能 App:**选择+新建功能 App。
**为函数 app 创建一个全局唯一的名称:**该名称必须在 URL 路径中有效，同时在 Azure 函数中也是唯一的。
**选择一个运行时:**选择您已经激活的 Python 版本在本地运行。建议使用 python - version 命令来检查您的版本。
为新资源选择一个地点:选择一个离你更近的地区总是更好。

完成后，以下 Azure 资源将包含在您的订阅中，使用基于您的功能应用程序名称的名称:

资源组，也是相关资源的逻辑容器。
一个标准的 Azure 存储帐户，其中包含关于您的项目的所有信息。
一个消费计划，为你的无服务器功能 app 确定主机。
一个功能应用程序，它定义了执行您的功能代码的环境，并让您的组功能作为一个逻辑单元，以便于管理和共享同一托管计划内的资源。
应用洞察用于记录您的无服务器功能的例程。

创建功能应用程序后，将显示通知。默认情况下，Azure 资源基于您在与 function app 相同的新资源组中提供的 function app 名称进行设置。如果您需要更改这些资源的名称或重用它们，您将需要应用高级创建选项来发布项目。

在通知中查找视图输出以查看部署结果，如果您错过了通知，您可以选择右下角的钟形图标让它再次出现。

回到侧边栏的 Azure: Functions 区域，展开你的订阅、你的新功能应用和功能。右键单击(Windows)或按住 Ctrl 单击(MAC OS)http example 函数，然后选择“立即执行函数”。在输入请求正文中，您应该能够看到{ "name": "Azure" }的请求消息正文值。按 Enter 键将这个请求消息发送到您的函数，这样当函数在 Azure 中被激活并返回响应时，就会在 VS 代码中显示一个通知。

一旦你进行到下一步，包括一个 Azure 存储队列绑定到你的函数，你将不得不准备好你所有的资源，以便能够在你已经拥有的基础上进行构建。或者，您可以完成以下步骤来删除功能应用程序及其相关资源，以避免任何额外成本:

在 VS 代码中，按 F1 激活命令选项板。在命令面板中，查找 Azure Functions: Open in the portal。选择您的功能应用，并按 Enter 键以查看 Azure 门户中打开的功能应用页面。
在“概述”选项卡中，查找资源组旁边的命名链接。从功能应用程序页面中选择要删除的资源组。进入“资源组”页面查看包含的资源列表，并单击需要删除的资源。请记住，删除可能需要一些时间(不超过几分钟)。完成后，会出现几秒钟的通知。您也可以单击页面顶部的钟形图标再次查看通知。

Azure Functions 让你无需编写自己的集成代码就能访问 Azure 服务。这些由输入和输出表示的绑定在函数定义中声明。来自绑定的数据通常以参数的形式出现。这里的触发器是一种特殊类型的输入绑定，即使一个函数只有一个触发器，它也可以有多个输入和输出绑定。

可以使用 VS 代码将 Azure 存储连接到函数。插入到该函数的输出绑定将数据从 HTTP 请求导入到 Azure Queue 存储队列中的消息。

大多数绑定都是通过存储的连接字符串来运行的，函数使用这些连接字符串来访问绑定的服务。简单来说，你用你的功能 app 创建的存储账号。与此帐户的连接已存储在名为 AzureWebJobsStorage 的应用设置中。

然而，在开始使用存储之前，您应该安装用于 VS 代码的 Azure 存储扩展，并安装 Azure 存储资源管理器。Storage Explorer 是一个很好的工具，可以查看由输出绑定产生的队列消息。方便的是，基于 macOS、Windows 和 Linux 的操作系统支持 Storage Explorer。要在本地运行该功能时连接到您的存储帐户，您应该将应用程序设置下载到 local.settings.json 文件中。

接下来，按 F1 键打开命令面板，然后查找并激活命令 Azure Functions:Download Remote Settings。选择“全是”覆盖现有的本地设置。local.settings.json 文件未发布，因此被排除在源代码管理之外。复制值 AzureWebJobsStorage，它是存储帐户连接字符串值的键，并使用此连接来确认输出绑定是否按需要工作。

因为我们将使用队列存储输出绑定，所以您应该在运行项目之前下载存储绑定扩展。然后，您的项目将被配置为容纳扩展包，这会自动安装一组预定义的扩展包。扩展包的用法在项目基础的 host.json 文件中启用，看起来是这样的: ²

JSON
Copy
{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "1.*, 2.0.0)"
  }
}

使用它，您可以将存储输出绑定添加到项目中。一旦您了解了这一点，就该学习如何添加输出绑定了。每种类型的绑定都有一个方向、类型和惟一的名称，包含在 function.json 文件中。定义这些属性的方式取决于功能应用程序的语言。绑定属性直接在 function.json 文件中定义，根据绑定类型，可能需要进行额外的修改。队列输出配置定义了 Azure 存储队列绑定所需的字段。

创建绑定是一个非常简单的过程。首先，通过右键单击(在 macOS 上是 Ctrl+单击)HttpTrigger 文件夹中的 function.json 文件并选择 Add binding 来创建一个绑定。然后按照表 [5-1 中列出的提示定义新绑定的特征。^??

表 5-1

结合特征

提示

价值

描述

| | --- | --- | --- | | 选择装订方向 | 在外 | 该绑定是一个输出绑定。 | | 选择方向绑定... | Azure 队列存储 | 该绑定是 Azure 存储队列绑定。 | | 用于在代码中标识此绑定的名称 | 味精 | 标识代码中引用的绑定参数的名称。 | | 消息将被发送到的队列 | 出栈 | 绑定写入的队列的名称。当队列名不存在时，绑定在第一次使用时创建它。 | | 从“local.setting.json”中选择设置 | AzureWebJobsStorage | 包含存储帐户连接字符串的应用程序设置的名称。AzureWebJobsStorage 设置包含您使用函数 app 创建的存储帐户的连接字符串。 |

一个绑定，附加到 function.json 中的 bindings 数组，通常看起来应该是: ⁴

JSON
Copy
{
  "type": "queue",
  "direction": "out",
  "name": "msg",
  "queueName": "outqueue",
  "connection": "AzureWebJobsStorage"
}

一旦定义了绑定，现在就可以使用绑定的名称作为属性签名来访问它。有了输出绑定，就不需要使用 Azure Storage SDK 代码进行身份验证或队列引用，或者编写数据脚本。函数运行时和队列输出绑定将为您完成这些任务。

为了在本地运行该功能，请按 F5 启动功能应用程序和核心工具。运行核心工具，寻找 Azure: Functions 区域。在“函数”下，展开“本地项目➤函数”,然后右键单击(在 Mac 上按住 Ctrl 键单击)HttpExample 函数，并选择“立即执行函数”。完成后，您应该能够看到{ "name": "Azure" }的请求消息正文值。按 Enter 键将这个请求消息发送到您的函数，当有响应返回时，不要忘记按 Ctrl + C 来停止核心工具。

由于您正在使用存储连接字符串，因此您的函数在本地运行时将自动连接到 Azure 存储帐户。当第一次激活输出绑定时，函数运行时将在您的存储帐户中创建一个名为 outqueue 的新队列。然后，将使用存储资源管理器来演示队列是与新消息一起创建的。

为了将存储资源管理器连接到您的帐户，必须运行 Azure 存储资源管理器工具。选择左边的连接图标，然后点击添加帐户。在连接对话框中，选择添加 Azure 帐户，选择您的 Azure 环境，然后选择登录。成功登录到您的帐户后，您将能够看到附加到您帐户的所有 Azure 订阅。

要检查 VS 代码中的输出队列，请按 F1 键打开命令面板，然后搜索并运行命令 Azure Storage:Open in Storage Explorer，并查找您的存储帐户名。您的存储帐户将在 Azure 存储资源管理器中打开。

然后，您应该展开 Queues 节点并选择名为 outqueue 的队列。该队列携带运行 HTTP 触发函数时队列输出绑定创建的消息。如果您使用默认的名称值 Azure 激活了函数，那么队列消息是传递给函数的名称:Azure。尝试再次运行该函数，发送另一个请求，您将能够看到一条新消息出现在队列中。有了它，现在是时候重新部署和验证更新的应用程序。

转到 VS 代码，按 F1 打开命令面板，您应该在其中搜索，并选择 Azure Functions:Deploy to function app。选择您在第一篇文章中创建的函数应用程序，并部署它以消除关于覆盖文件的警告。

部署完成后，您可以再次使用 Execute Function Now 特性来触发 Azure 中的函数，并查看存储队列中的消息，以验证输出绑定是否在队列中创建了新消息。

在 Azure 中，资源指的是功能 app、函数、存储账号。它们被分组到资源组中，您可以通过删除整个组来删除组中的所有内容。

在 VS 代码中按 F1 打开命令调板。在命令面板中，查找并选择 Azure Functions: Open in the portal。选择您的功能应用程序，然后按 Enter 键。功能应用页面将在 Azure 门户中打开。在“概述”选项卡中，选择资源组旁边的命名链接。在这里，从功能应用程序页面中选择要删除的资源组，并验证它们是您要删除的资源组。选择 Delete resource group，并按照说明进行操作。删除可能需要几分钟的时间，完成后，几秒钟就会出现一个通知。

在下一节中，我们将讨论如何在 Azure 中将 Docker 容器部署到应用服务。

将 Docker 容器部署到 Azure 应用服务

安装完 Azure 扩展后，转到 Azure explorer 并选择登录 Azure，按照提示进行操作。登录后，确认 Azure: Signed In 语句出现在状态栏中，并且您的订阅也显示在 Azure explorer 中。

如果您看到“找不到该名称的订阅”，该错误可能是由于您位于代理之后，无法访问 Azure API。您可以在终端中使用您的代理信息轻松配置 HTTP_PROXY 和 HTTPS_PROXY 环境变量: ⁵

对于 Windows:

set HTTPS_PROXY=https://username:password@proxy:8080
set HTTP_PROXY=http://username:password@proxy:8080

对于 macOS 和 Linux:

export HTTPS_PROXY=https://username:password@proxy:8080
export HTTP_PROXY=http://username:password@proxy:8080

有了注册表中的容器映像，您可以在 VS 代码中应用 Docker 扩展来设置操作容器的 Azure App 服务。在 Docker explorer 中，展开注册表，展开注册表的节点，然后展开图像名称的节点，直到看到带有:latest 标签的图像。

您可以在 Docker explorer 中找到一个映像，方法是右键单击该映像并选择“将映像部署到 Azure 应用服务”。选择“将映像部署到 Azure 应用服务”菜单项。之后，按照提示选择 Azure 订阅，选择或指定资源组，指定区域，配置应用服务计划，并为站点设置名称。

应用服务的名称在整个 Azure 中应该是唯一的，所以使用公司或个人名称是标准的。对于生产站点，您可以使用单独注册的域名配置应用服务。像这样设置应用程序服务不超过几分钟，你可以在 VS 代码的输出面板中看到进度。

完成后，您还应该向应用程序服务添加一个名为 WEBSITES_PORT 的设置，以指定容器所在的端口。通常使用在 VS 代码中创建 Python 容器教程中的图像，Flask 的端口为 5000，Django 的端口为 8000。要设置自己的 WEBSITES_PORT，请切换到 Azure: App Service explorer，展开新应用服务的节点，然后右键单击应用程序设置以选择添加新设置。开始时，确保输入 WEBSITES_PORT 作为键，端口号作为值。

当您更改设置时，应用服务会自动重新启动。您也可以随时右键单击应用服务并选择重新启动。服务重新启动后，浏览 HTTP:// .azurewebsites.net 上的站点。您可以在“输出”面板中的 URL 上使用 Ctrl+ click(在 macOS 上使用 Cmd + click ),或者在 Azure: App Service explorer 中右键单击应用服务并选择“浏览网站”。

因为您肯定会在某个时候对应用程序进行更改，所以您最终会多次重新构建容器。幸运的是，这个过程只包括几个步骤。首先，重塑 Docker 形象。如果您只更改应用程序代码，构建应该只需要几秒钟。然后，将您的图像推送到注册表。同样，如果只修改 but app 代码，只需要推送那一小层，几秒钟内就能完成流程。

之后，在 Azure: App Service explorer 中，右键单击合适的 App Service，选择 Restart。重新启动应用服务将自动从注册表中提供最新的容器图像。大约 15-20 秒后，再次尝试访问应用服务 URL 以检查更新。

您还可以使用此过程将容器的日志从 Azure 应用服务流式传输到 VS 代码。在 VS 代码中，你可以在 Azure App Service 上查看来自运行站点的日志，它将任何输出保留到控制台，并将它们定向到 VS 代码输出面板。为了打开连接到日志流的 VS 代码输出面板，在 Azure: App Service explorer 中找到应用程序，右键单击该应用程序，然后选择“启动日志流”。当要求启用日志记录并重新启动应用程序时，请务必回答是。

您为项目建立的 Azure 资源可能会产生持续的成本。为了防止超支，请删除承载所有这些资源的资源组。您可以通过 Azure 门户或 Azure 门户中的 Azure CLI:删除资源组。从左侧导航窗格中选择资源组，选择要擦除的资源组，然后使用删除功能。

然后运行以下 Azure CLI 命令，但将<resource_group>替换为所选组的名称:</resource_group>

az group delete --no-wait --name <resource_group>

以下是一些最受欢迎的针对 VS 代码的 Azure 扩展，你可能会发现对这个操作有用:

宇宙数据库(Cosmos DB)
天青函数
Azure CLI 工具
Azure 资源管理器工具

在 VS 代码中使用容器

VS Code Remote Containers 扩展使您能够将 Docker 容器用作全功能虚拟环境。它允许您访问容器中的任何文件夹，并利用 VS 代码的属性集。你的项目中有一个 devcontainer.json 文件，它可以指导 VS 代码创建一个具有良好定义的运行时集的开发容器(图 5-2 )。该容器可用于操作应用程序或断开处理代码库所需的工具、库或运行时。

img/514155_1_En_5_Fig2_HTML.jpg

图 5-2

VS 代码中的远程容器

工作区文件从本地文件系统安装，或者共享或复制到容器中。扩展在容器内部被激活，在那里它们可以完全访问工具、平台和另一个文件系统。这使您有机会通过链接到不同的容器来无缝切换整个开发环境。这使得 VS 代码运行流畅的本地质量开发体验——包括完整的智能感知能力、代码导航和调试——无论您的代码位于何处。

在 VS 代码中安装容器有一些系统需求:

Windows: 预计你会在 Windows 10 Pro/Enterprise 上安装 Docker Desktop 2.0+。Windows 10 家庭版(2004 以上)需要 Docker Desktop 2.3 以上和 WSL 2 后端。
macOS: 一定要设置 Docker 桌面 2.0+。
**Linux:**ce/ee 18.06+坞站和坞站复合 1.21+。

要开始，首先为您的操作系统安装和配置 Docker。如果您在 Windows 上使用 WSL 2，要启用 Windows WSL 2 后端:右键单击 Docker 任务栏项目并选择设置。选中“使用基于 WSL 2 的引擎”,并验证是否在“资源➤ WSL 集成”下启用了您的分发。然后右键单击 Docker 任务栏项目，选择“设置”,并更新源代码所在位置的资源➤文件共享。

如果您使用的是 Linux，请遵循您的发行版的 Docker CE/EE 的官方安装说明，并通过使用终端运行 sudo usermod -aG docker $USER 将您的用户添加到 Docker 组。然后注销并再次登录，在安装 VS 代码和远程开发扩展包之前设置您的更改。

如果您正在使用 Git，有两点需要考虑:如果您在本地 Windows 和容器中使用同一个存储库，请注意设置稳定的行尾。如果您使用 Git 凭据管理器进行复制，那么容器对您的凭据拥有完全访问权限是非常重要的。

使用容器操作

远程容器扩展以两种主要的操作模式进行管理:您可以将一个容器用作您的全职开发环境，或者将它附加到另一个正在运行的容器来检查它。最简单的开始方式是尝试 Docker 和 Remote-Containers 扩展中的一个示例开发容器，您可以从扩展列表中选择一个示例。

另一方面，通过在文件系统上应用活动源代码，您可以为任何项目打开容器中的现有文件夹，以用作您的全职开发环境。启动 VS 代码，从命令面板(F1)运行 Remote-Containers:Open Folder in Container 命令，并单击需要为其设置容器的项目文件夹。同时，如果您想在打开文件夹之前修改容器的内容或设置，您可以激活 Remote-Containers:Add Development Containers 配置文件。接下来，为您的开发容器选择一个起点。您可以从可过滤列表中选择一个基本开发容器定义，或者使用现有的 Docker 文件或 Docker 合成文件。使用 Alpine Linux 容器时请注意，由于扩展中本机代码的 glibc 依赖性，一些扩展可能不可用。

可筛选列表将根据您的文件夹内容自动组织。开发容器定义通常来自 vscode-dev-containers 存储库。您可以很容易地查看该存储库的 containers 文件夹，以检查每个定义的内容。在为您的容器选择了起始点之后，VS 代码将在您的项目中包含 dev 容器配置文件。开发容器/开发容器。JSON)。

VS 代码窗口将重启并构建 dev 容器。您只需要在第一次访问 dev 容器时构建它；在第一次成功构建后打开文件夹会快得多。进度通知将显示状态更新。构建结束后，VS 代码会自动连接到容器。然后，您可以在 VS 代码中与您的项目进行交互，就像您在本地访问项目一样:当您打开项目文件夹时，默认情况下，VS 代码将获取并重用您的 dev 容器配置。虽然使用这种方法将本地文件系统链接到一个容器中很方便，但是在 Windows 和 macOS 上确实有一些小的性能开销。

如果您正在使用 Windows Subsystem for Linux v2(WSL 2)并且已经激活了 Docker Desktop 的 WSL 2 后端，那么您可以使用存储在 WSL 中的源代码。

启用 WSL 2 引擎后，您可以从已经打开的文件夹中使用 Remote-Containers:Reopen Folder in Container 命令，或者从命令面板(F1)中选择 Remote-Containers:Open Folder in Container，然后使用 local \wsl$共享(从 Windows 端)选择 WSL 文件夹。

如果工作区仅引用子文件夹的相对路径，您也可以按照在单个容器中打开 VS 代码多根工作区的类似过程，在容器中打开现有的工作区。在这种情况下，您可以应用 remote-containers:open workspace in container 命令，或者在打开了一个包含容器中的. code-workspace 文件的文件夹后，简单地使用文件➤ Open Workspace 命令。连接后，您应该添加。devcontainer 文件夹添加到工作区，以便您可以轻松地编辑其内容(如果它还不可见的话)。请记住，虽然不可能在同一个 VS 代码窗口中为同一个工作区使用多个容器，但是可以在不同的窗口中同时使用多个 Docker Compose 操作的容器。

创建 Devcontainer.json 文件

VS 代码的容器配置位于 devcontainer.json 文件中。该文件是可选的，但建议您创建它，因为它使处理调试配置更容易。

该文件与用于调试配置的 launch.json 文件相同，但主要用于启动(或添加)您的开发容器。您还可以确定在容器运行时安装哪个扩展，或者构建后命令来安排环境。dev 容器配置位于。开发容器/开发容器。或者作为. devcontainer.JSON 文件存储在项目的基础中。您可以使用任何图像、Docker 文件或一组 Docker 合成文件作为起点。下面是一个普通的例子，其中包括一个预构建的 VS 代码开发容器映像: ⁶

{
  "image": "mcr.microsoft.com/vscode/devcontainers/typescript-node:0-12",
  "forwardPorts": [3000],
  "extensions": ["dbaeumer.vscode-eslint"]
}

从命令面板(F1)中激活 Remote-Containers:Add Development Container Configuration Files 命令将把所需的文件作为一个起点传递到您的项目中，您可以进一步编辑这些文件以满足您的需要。该命令还允许您根据文件夹的内容从列表中选择指定的容器配置，重用现有的 Docker 文件，或重用现有的 Docker 合成文件。

有时，您可能会使用名为 volume 的 Docker，您需要在其中查看或进行更改。您可以激活 VS 代码来处理这些内容，而无需创建或编辑 devcontainer.json 文件，只需从命令面板(F1)中选择 Remote-Containers:Explore a Volume in a Development Container 即可。

此外，还可以在远程资源管理器中检查您的卷。首先，在下拉列表中选择 Containers，在这里可以找到 Dev Volumes 部分。右键单击一个卷以检查其创建信息，例如卷的创建时间以及将哪些文件克隆到其中。如果您安装了 Docker 扩展，您可以在 Docker Explorer 的 Volumes 部分右键单击一个卷，然后在开发容器中选择 Explore 来浏览整个 Docker 上下文菜单。

管理扩展

VS 代码在两个地方管理和存储扩展:本地 UI/客户端，或者在容器中。虽然直接影响 VS 代码 UI 的扩展(如主题和代码片段)是在本地上传的，但大多数扩展都放在特定的容器中。这个特性允许您在一个容器中只安装特定任务所需的扩展，并通过链接到一个新的容器来毫不费力地打开整个工具链。

当您从 Extensions 视图安装一个扩展时，它将自动被放置在正确的位置。您可以通过查看类别分组来猜测扩展安装在哪里。将有一个本地安装的类别，也有一个为您的容器。实际上需要远程操作的本地扩展将在本地安装类别中显示为禁用。要在远程主机上安装扩展，请选择安装。您还可以通过访问 extensions 视图并单击 Install Local Extensions in Dev Container:[Name]，按 Local - Installed 标题栏右侧的 cloud 按钮，在 Dev 容器中安装所有本地安装的扩展。这将显示一个下拉列表，您可以从中选择要添加到容器中的本地安装的扩展。

一些扩展可能依赖于您在容器中安装额外的软件。即使您可以手动编辑 devcontainer.json 文件来添加扩展 id 列表，您也可以在 Extensions 视图中右键单击任何扩展，然后单击 Add to devcontainer.json。

如果您需要在任何容器中安装一些扩展，您应该更新 remote . containers . default extensions 用户设置。举例来说，如果您想安装 GitLens 和 Resource Monitor 扩展，您必须以如下方式编写它们的扩展 id:⁷

"remote.containers.defaultExtensions": [
    "eamodio.gitlens",
    "mutantdino.resourcemonitor

"
]

强制扩展在本地或远程运行

扩展通常被生产和测试为本地或远程操作，但不是两者都是。然而，如果一个扩展支持它，就可以修改它，使其在 settings.json 文件中的特定位置运行。例如，以下设置将使 Docker 扩展在本地运行，而 Chrome 扩展的调试器在远程运行，尽管它们的默认设置是: ⁸

"remote.extensionKind": {
    "ms-azuretools.vscode-docker": [ "ui" ],
    "msjsdiag.debugger-for-chrome": [ "workspace" ]
}

“ui”而不是“workspace”的值将强制扩展在本地 UI/客户端上操作。通常，除非扩展的文档另有指导，否则这应该只应用于测试，因为它会导致扩展中的错误。

转发或发布端口

容器本质上是不相关的环境，因此如果您需要访问服务器、服务或容器中的其他资源，您必须将端口转发或发布到您的主机。您可以配置您的容器，使其始终保持这些端口开放，或者暂时转发这些端口。

您还可以通过使用 devcontainer.json 中的 forwardPorts 函数(类似于" forwardPorts": [3000，3001])来确定在附加或访问容器中的文件夹时希望一直转发的端口列表。之后，当 VS 代码再次连接到容器时，会要求您重新加载并重新打开窗口，以便应用所有的设置。

临时转发端口

如果您需要访问 devcontainer.json 中不包含的端口，或者如果您需要在 Docker 合成文件中发布它，您可以通过从命令面板(F1)激活 Forward a Port 命令，在会话期间转发一个新端口。选择端口后，会有一个通知告诉您应该使用哪个本地主机端口来访问容器中的端口。例如，当您转发一个侦听端口 3000 的 HTTP 服务器时，通知会告诉您它被映射到本地主机上的端口 3000。然后，您可以使用 http://localhost:3000 创建到这个远程 HTTP 服务器的链接。

如果你想让 VS 代码回忆你之前转发的任何端口，在设置编辑器中勾选 Remote:Restore forwardedports(Ctrl+，)，或者在 settings.json 中设置“Remote . Restore forwardedports”:true。

Docker 还能够在创建容器时发布端口。发布端口的模式与您提供给本地网络的端口非常相似。如果您的应用程序只接受来自 localhost 的调用，它将像您的本地机器处理网络调用一样，解除来自已发布端口的连接。另一方面，转发端口实际上看起来像应用程序的本地主机。每一种在不同的情况下都是有益的。

要发布端口，您可以利用 appPort 项目。例如，在 devcontainer.json 中引用 image 或 Dockerfile 时，可以使用 appPort 属性向主机发布端口:“app port”:[3000，“8921:5000" ]。

类似地，您可以访问 Docker Compose 端口映射，该映射可以很容易地附加到 docker-compose.yml 文件以发布其他端口:

- "3000"
- "8921:5000"

在任何情况下，您都必须重新构建容器才能使设置生效。当您链接到容器时，可以通过在命令调板(F1)中启动 Remote-Containers:Rebuild Container 命令来实现这一点。

从 VS 代码打开容器中的终端也非常简单。当你在容器中创建一个文件夹时，你在 VS 代码中打开的任何终端窗口(通过终端➤新终端)将自动在容器中运行，而不是在本地运行。您还可以在同一个终端窗口中使用相同的代码命令行来执行许多不同的操作，例如在容器中打开一个新文件或文件夹。

一旦打开了容器中的文件夹，就可以像在本地执行应用程序一样打开 VS 代码的调试器。例如，如果您选择在 launch.json 中启动配置并开始调试(F5)，应用程序将打开远程主机并向其添加调试器。

当您链接到 dev 容器时，VS 代码的本地用户设置也会被重新应用。尽管这保持了用户体验的稳定性，但是您可能希望在本地项目和容器之间改变其中的一些设置。连接到容器后，还可以通过从命令调板(F1)运行首选项:打开远程设置命令或切换到设置编辑器中的远程选项卡来校准容器特定的设置。这些将覆盖您当前每次连接到容器时激活的任何本地设置。

默认情况下，当您打开文件夹时，Remote-Containers 扩展会自动启动附加到 devcontainer.json 的容器。当您关闭 VS 代码时，扩展会自动关闭您已经连接的容器。但是，您可以通过向 devcontainer.json 添加“shut down action”:“none”来纠正这种行为。

虽然您可以使用命令行来管理您的容器，但是您也可以使用远程资源管理器来完成。要停止容器，请从下拉列表中选择容器，右键单击正在运行的容器，然后选择停止容器。您也可以启动已退出的容器，删除容器，并删除最近的文件夹。通过“详细信息”视图，您可以转发端口并在浏览器中打开已转发的项目。当您需要清理图像或批量删除容器时，请查找“清理未使用的容器和图像”以了解各种可用选项。

使用点文件存储库进行个性化

点文件代表文件名以点(.)并且通常具有不同应用的配置信息。因为开发容器可以组成各种各样的应用程序类型，所以将这些文件放在某个地方会很方便，这样一旦容器启动并运行，就可以很容易地将它们复制到容器中。一个实用的方法是在 GitHub 存储库中找到这些点文件，然后应用一个实用程序复制并使用它们。Remote-Containers 扩展有内置的辅助功能，可以将这些功能用于您自己的容器。如果你是这方面的新手，先看看不同的点文件引导库。

同时，远程容器有一些已知的限制:

不支持 Windows 上的 Docker 工具箱。
尚不支持 Windows 容器映像。
使用远程 Docker 主机是可以实现的，但是需要额外的设置操作。
多根工作区中的所有根和文件夹都将在同一个容器中被访问，不管在较低的级别上是否有可用的配置文档。
不支持 Linux 的非官方 Ubuntu Docker 快照集。
如果您使用 SSH 复制 Git 存储库，并且您的 SSH 密钥有一个密码，那么在远程运行时，VS 代码的 pull 和 sync 特性可能会中断。要么使用不带密码的 SSH 密钥，使用 HTTPS 进行复制，要么从命令行运行 git push 来解决这个问题。
本地代理设置不会在容器内重新应用，这可能会妨碍扩展的工作，除非配置了正确的代理数据(例如，具有准确代理数据的全局 HTTP_PROXY 或 HTTPS_PROXY 环境项目)。

此外，在没有 WSL 2 引擎的情况下，第一次安装 Docker Desktop for Windows 可能需要一个额外的共享操作来为您的容器提供对本地源代码的访问。此步骤可能不适用于某些基于电子邮件的身份，如果您使用电子邮件地址而不是 Docker ID 登录 Docker，可能会出现错误。这是一个已知问题，可以通过使用您的 Docker ID 登录来解决。

摘要

在这一章中，我们揭示了 MS Azure 服务的强大世界，以及如何使用它来构建和部署出色的 Python 应用程序。

Footnotes 1

Azure，“Azure CDN 的新位置现已可用”， https://azure.microsoft.com/en-in/blog/new-locations-for-azure-cdn-now-available/ ，于 2021 年 7 月 29 日访问。

微软，《快速入门:使用 VSC 用 Python 在 Azure 中创建函数》， https://docs.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-python ，2021 年 7 月 29 日访问。

微软，“使用 VSC 将 Azure 功能连接到 Azure 存储”， https://docs.microsoft.com/en-us/azure/azure-functions/functions-add-output-binding-storage-queue-vs-code?pivots=programming-language-python ，2021 年 7 月 29 日访问。

微软，“使用 VSC 将 Azure 功能连接到 Azure 存储。”

微软，《教程:用 VSC 将 Docker 容器部署到 Azure App Service》， https://docs.microsoft.com/en-us/azure/developer/python/tutorial-deploy-containers-01 ，2021 年 7 月 29 日访问。

微软，“在做出更改后将容器重新部署到 Azure 应用服务”， https://docs.microsoft.com/en-us/azure/developer/python/tutorial-deploy-containers-03 ，2021 年 7 月 29 日访问。

微软，“在做出更改后将容器重新部署到 Azure 应用服务。”