为-Python-开发优化-VSCode-全-

为 Python 开发优化 VSCode（全）

原文：Optimizing Visual Studio Code for Python Development

协议：CC BY-NC-SA 4.0

一、VSC 简介

Visual Studio Code (VS Code)是微软为 Windows、Linux、macOS 打造的开源代码编辑器(图 1-1 )。广受欢迎的标准特性包括支持调试、语法突出显示、自动代码完成、代码片段、代码重组和嵌入式 Git。用户可以自由更改设计主题、键盘快捷键和首选项，也可以安装额外的扩展来升级整个项目的功能。

微软在 2015 年的 Build 大会上首次推出了 VS 代码。到 2019 年，VS Code 成为最受欢迎的开发人员环境工具，87，317 名受访者中有 50.7%的人表示他们经常使用它。

img/514155_1_En_1_Fig1_HTML.jpg

图 1-1

VSC，一个免费的开源代码编辑器

在这一章中，我们将带您了解如何设置 VS 代码，并提供基本特性的概述:

  • 用户界面:查看 VS 代码文档。

  • 设置概述:使用 VS 代码启动和运行的文档，包括平台相关的设置。

  • 键盘快捷键:自定义自己的快捷键选项，安装 Keymap 扩展。

  • Keybinding 扩展:如何安装一个 Keymap 扩展，将之前编辑器中的键绑定带到 VS 代码中。

用户界面

按照初衷，VS 代码是一个代码编辑器。与许多其他代码编辑器类似，VS Code 有一个通用的用户界面和浏览器布局，在左边显示您可以访问的所有文件和文件夹，在右边有一个编辑器，显示您已经打开的文件的内容。

基本布局

VS 代码有一个简单而直观的布局，它利用了为编辑器提供的所有空间，同时留下一些空间来浏览和访问文件夹或正在进行的项目的完整上下文。用户界面分为五个主要区域:

  • 编辑器:编辑当前文件的主要空间。您可以并排打开任意数量的编辑器，也可以垂直和水平打开。

  • 侧边栏:这个区域有不同的视图，例如资源管理器，以便在您处理项目时提供最大的帮助。

  • 状态栏:当前项目和正在编辑的文件的信息。

  • 活动栏:位于最左侧，这个区域使您能够在视图之间切换，并为您提供额外的特定于上下文的度量——例如，传出变更的数量。

  • 面板:您可以在编辑器区域下方显示不同的面板，用于输出或调试内容、错误、警告或集成信息。该面板还可以向右移动，以获得更大的垂直空间。

每次启动 VS 代码时，它都以上次离开时的状态打开。文件夹、布局和打开的文件将保持不变。每个编辑器中打开的文件在编辑器区域的顶部显示有选项卡式标题(选项卡)。要了解有关选项卡式标题的更多信息，请参阅选项卡部分的详细信息。你也可以移动侧边栏到右边(查看➤右移侧边栏)或者增强它的可见性(Ctrl+B)。

并排编辑

如前所述，您可以纵向和横向并排打开任意多个编辑器。如果已经打开了一个编辑器，有多种方法可以将另一个编辑器放在现有编辑器的旁边:

  • 按住 Alt 键并单击浏览器中的文件。

  • Ctrl+\将活动编辑器一分为二。

  • 从文件的资源管理器上下文菜单中打开到侧面(Ctrl+Enter)。

  • 点按编辑器右上角的“拆分编辑器”按钮。

  • 将文件拖放到编辑器区域的任意一侧。

  • 快速打开(Ctrl+P)文件列表中的 Ctrl+Enter (macOS: Cmd+Enter)。

一旦打开另一个文件，正在运行的编辑器将显示该文件的内容。因此，如果您有两个并排的编辑器，并且您需要在右边的编辑器中打开文件 doc.cs，请确保在打开文件 doc.cs 之前该编辑器是活动的(通过单击它)

默认情况下，编辑器在活动编辑器的右侧打开。您可以通过设置 work bench . editor . opensidebysidedirection 和 modify 来更改此模式，以便在活动编辑器的底部打开新的编辑器。同时，当您有多个活跃的编辑器时，您可以通过按住 Ctrl (macOS: Cmd)键并按下 1、2 和 3 来轻松地在它们之间切换。此外，如果您愿意，您可以调整编辑器的大小和重新排序它们:只需拖放编辑器标题区域来重新定位或调整编辑器的大小。

Minimap(最小化)

Minimap(代码大纲)允许你对你的源代码有一个高层次的概述，这对于简单的导航和代码理解是非常有用的。一个文件的小地图显示在编辑器的右边。您也可以单击或拖动阴影区域，快速切换到文件的不同部分。同样值得注意的是，你可以将小地图移动到左侧，甚至完全禁用它，只需在你的用户或工作区设置中设置“editor.minimap.side”:、“left”或“editor . minimap . enabled”:false。

缩进参考线

编辑器上方的图像还显示了垂直线或缩进参考线，它们有助于您自由观察匹配的缩进级别。如果您想关闭这些缩进参考线，您应该在您的用户或工作区设置中设置“editor . renderindentguides”:false。

面包屑

如果您再次查看编辑器，您会注意到在它的内容上方有一个名为 Breadcrumbs 的导航栏。它可以显示您的当前位置，并让您在文件夹、文件和符号之间快速导航。

面包屑还倾向于显示文件路径，如果活动文件类型支持符号语言，它会显示光标位置之前的符号路径。您可以使用查看➤显示面包屑简单命令关闭面包屑。您还可以在编辑器的 Breadcrumbs 部分访问有关 Breadcrumbs 功能的相同信息。

探险家

浏览器是一种工具，用于浏览、打开和操作编辑项目中的所有文件和文件夹。因为 VS 代码是基于文件和文件夹的，所以您可以在任何时候简单地通过在 VS 代码中打开一个文件或文件夹来开始。一旦在 VS 代码中打开一个文件夹，文件夹的内容就会显示在资源管理器中。您可以从这里进行许多修改，例如:

  • 创建、删除和重命名文件和文件夹。

  • 使用拖放功能更改文件和文件夹的位置。

  • 查看上下文菜单以查看所有选项。

此外，您可以从 VS 代码外部将文件拖放到资源管理器中，以制作它们的 VS 副本，这样，如果资源管理器为空，VS 代码将改为访问它们。

VS 代码也可以很好地与您可能使用的其他工具配合使用，尤其是命令行工具。如果您需要在 VS 代码中打开的文件夹的上下文中运行命令行工具，请右键单击该文件夹并选择在命令提示符下打开(或者在 macOS 或 Linux 上的终端中打开)。

同时，通过右键单击文件或文件夹并选择在资源管理器中显示(或在 macOS 上的 Finder 中显示，或在 Linux 上打开包含文件夹)，您可以在本机资源管理器中导航到文件或文件夹的位置。您也可以键入 Ctrl+P(快速打开选项)来按文件名快速搜索和打开文件。

默认情况下，VS 代码不会从资源管理器中打开某些文件夹(例如。git)。在这种情况下，您可以使用 files.exclude 设置来编辑在资源管理器中隐藏文件和文件夹的规则。但是，如果您有任何派生的资源文件，如*。Unity 或*中的 meta。js 在 TypeScript 项目中，那么这个解决方案实际上是没有用的。请注意，Unity 要排除*.cs.metafiles，选择的模式应该是“* / . cs . meta”:true。对于 TypeScript，可以用“**/*”排除为 TypeScript 文件生成的 JavaScript。js": {"when": "$(basename)。ts"}。

多重选择

您可以在文件资源管理器中选择多个文件，并打开编辑器视图来完成对多个项目的操作(删除、拖放、打开到侧面)。只需使用 Ctrl/Cmd 键单击选择单个文件，然后按住 Shift 键单击选择一个范围。如果选择两个项目，现在可以使用上下文菜单“比较所选项目”命令来快速区分这两个文件。此外，请记住，在早期的 VS 代码版本中，按住 Ctrl/Cmd 键单击会在旁边的新编辑器组中打开一个文件。如果您仍然喜欢此功能，可以使用 work bench . list . multiselect modifier 设置来修改多选，以便通过“work bench . list . multiselect modifier”使用 alt 键:“Alt”。

过滤文档树

可以在文件资源管理器中过滤当前可见的文件。您可以简单地开始键入您想要匹配的文件名的一部分，将焦点保持在文件资源管理器上。您将能够在文件资源管理器的右上角看到一个过滤框，显示您到目前为止键入的内容，匹配的文件名将突出显示。一旦您按下光标键上下移动文件列表，它将在匹配的文件或文件夹之间切换。但是，切换“过滤器”框并选择“根据类型启用过滤器”将只显示匹配的文件和文件夹。您可以应用 X Clear 按钮来清除过滤器。

大纲视图

Outline 视图是文件资源管理器底部的一个部分。激活后，它将显示当前活动编辑器的符号树。Outline 视图有不同的排序方式和可选的光标跟踪，并支持常见的打开手势。它还有一个输入框，可以在您键入时搜索过滤器和符号。错误和警告也显示在 Outline 视图中，使您可以对问题及其位置有所了解。

至于符号，视图很大程度上依赖于您为不同文件类型安装的扩展计算的数据。例如，内置的降价支持返回降价文件符号的降价标题层次结构。

降价大纲视图

有一些大纲视图设置允许您启用和禁用项目，并在显示错误和警告的情况下进行操作(默认情况下全部启用): 1

  • outline.icons: 用图标切换渲染轮廓元素。

  • outline . problems . enabled:显示大纲元素的错误和警告。

  • outline.problems.badges: 切换对错误和警告使用徽章。

  • outline.problems.colors: 切换使用错误和警告的颜色。

打开编辑器

在浏览器的顶部，有一个标记为“打开的编辑器”的部分，显示活动文件或预览的列表。也可能有一些您之前在 VS 代码中打开的可见文件。例如，如果您对文件进行更改、双击文件头、在资源管理器中双击文件或打开不属于当前文件夹的文件，文件将在打开的编辑器视图中列出。通过在打开的编辑器视图中单击一个项目，它在 VS 代码中变成活动的。完成项目后，如果希望从打开的编辑器视图中单独移除文件，或移除所有文件，可以使用视图:关闭所有编辑器或在组操作中查看并关闭所有编辑器。

视图

文件资源管理器只是 VS 代码中可用的视图之一。也有观点认为: 2

  • 搜索:在您打开的文件夹中提供全局搜索和替换。

  • 源代码控制: VS 代码默认包含 Git 源代码控制。

  • Run: VS 代码的运行和调试视图显示变量、调用栈和断点。

  • 扩展:在 VS 代码中安装和管理你的扩展。

  • 自定义视图:扩展贡献的视图。

使用“视图:打开视图”命令可以访问这些视图。

活动栏

左侧的活动栏旨在方便您在视图之间切换。您还可以通过将视图拖放到活动栏上来重新排序视图，或者通过右键单击隐藏活动栏来隐藏整个视图。

命令面板

VS 代码也很容易通过键盘访问。需要知道的最有用的组合键是 Ctrl+Shift+P，它调用命令面板。使用命令面板，您可以访问 VS 代码的所有功能，包括大多数已实现操作的键盘快捷键。命令选项板提供了对许多命令的访问。您可以管理编辑器命令、打开文件、搜索项目以及查看文件的快速大纲，所有这些都可以在同一个交互式窗口中完成。以下是几个导航组合: 3

  • Ctrl+P 将允许您通过键入名称来导航到任何文件或符号。

  • Ctrl+Tab 将在最后一组打开的文件中循环。

  • Ctrl+Shift+P 将把您直接带到编辑器命令。

  • Ctrl+Shift+O 将让您导航到文件中的特定符号。

  • Ctrl+G 将让您导航到文件中的特定行。

  • 类型？输入字段，以获取可从快速打开帮助中执行的可用命令列表。

配置编辑器

VS 代码有许多选项供您配置编辑器。从视图菜单中，您可以隐藏或切换用户界面的各个部分，如侧栏、状态栏和活动栏。

隐藏菜单栏(适用于 Windows、Linux)

您可以通过选择 window.menuBarVisibility 设置从经典到切换来隐藏 Windows 和 Linux 上的菜单栏。切换设置意味着按一下 Alt 键将再次显示菜单栏。

您也可以使用“查看➤切换菜单栏”命令删除 Windows 和 Linux 上的菜单栏。此命令将 window.menuBarVisibility 从经典切换到精简，从而使菜单栏移动到活动栏中。要将菜单栏移回经典位置，请再次选择“查看➤切换菜单栏”命令。

设置

大多数基本的编辑器配置保存在可以直接修改的设置中。可以通过用户设置全局设置选项，也可以通过工作空间设置按项目或文件设置选项。设置选项保存在 settings.json 文件中。你可以按照路径选择文件➤首选项➤设置(或按 Ctrl+，)来编辑用户设置. json 文件。要更改工作空间设置，请单击工作空间设置选项卡编辑工作空间设置. json 文件。注意，对于 macOS 用户，首选项菜单位于代码下，而不是文件下；请遵循➤代码首选项➤设置。

您可以在左侧窗口中访问 VS 代码默认设置，并在右侧访问您的可编辑 settings.json。还可以使用顶部的搜索框轻松过滤默认设置中的设置。通过单击设置左侧的编辑图标，可以将设置复制到右侧可编辑的 settings.json 中。具有一组固定值的设置允许您选择一个主要值作为其编辑图标菜单的一部分。编辑设置后，键入 Ctrl+S 以确定您的更改。这些更改将立即生效。工作空间设置将覆盖用户设置，有利于共享特定的项目设置。

禅宗模式

Zen 模式通过移除除编辑器之外的所有用户界面项目(活动栏、状态栏、侧栏和面板),显示全屏并仅居中编辑器布局，使您能够专注于代码。可以使用“视图”菜单、命令调板或快捷键 Ctrl+K Z 来切换 Zen 模式，要退出 Zen 模式，请按两次 Esc。可以通过 zenMode.fullScreen 禁用全屏过渡。zenMode 可以使用以下设置进一步修改:zenMode.hideStatusBar、zenMode.hideTabs、zenMode.fullScreen、zenMode.restore 和 zenMode.centerLayout。

居中编辑器布局

居中编辑器布局允许您将编辑器区域居中对齐。如果您发现自己在大型显示器上使用单个编辑器，这将非常有用。您可以使用 Alt 键应用边上的窗扇来调整视图的大小，使用相同的方法您也可以独立移动窗扇。

制表符

VS 代码在编辑器上方的标题区域显示带有选项卡式标题或标签的打开项。如果您打开一个文件，则会为该文件添加一个新选项卡。制表符允许您在文件之间快速导航，并且您可以拖放制表符以便根据您的意愿对它们重新排序。当打开的项目多于标题区域所能容纳的项目时，可以应用“显示打开的编辑器”命令来显示选项卡式项目的下拉列表。

如果不想使用选项卡，可以通过将 workbench.editor.showTabs 设置设置为 false 来关闭该功能:" work bench . editor . show Tabs ":false。

制表符排序

默认情况下，新选项卡包含在现有选项卡的右侧，但是您可以使用 work bench . editor . open positioning 设置来管理希望新选项卡出现的位置。例如，您可能希望新的选项卡式项目出现在左侧，方法是使用“work bench . editor . open positioning”:“left”。

预览模式

在浏览器中单击或选择一个文件后，它将以演示模式显示，并重用现有的选项卡。如果您只需要快速浏览文件，并且不希望您访问的每个文件都有自己的选项卡，这将非常有用。当您开始编辑文件或在浏览器中双击打开文件时，会为该文件分配一个新的选项卡。预览模式在标签标题中用斜体表示:预览模式。

如果您不希望看到预览模式，而总是创建一个新选项卡，您可以使用以下设置来控制模式:

  • work bench . editor . enable preview:全局启用或禁用预览编辑器。

  • work bench . editor . enablepreviewfromcquickopen:启用或禁用从快速打开打开时的预览编辑器。

编辑组

如果您通过“拆分编辑器”或“向侧面打开”命令拆分编辑器，则会创建一个可容纳一组项目的新编辑器区域。同时，您可以水平和垂直并排打开任意多个编辑器区域。您可以在 Explorer 视图顶部的 OPEN EDITORS 部分按顺序查看它们。OPEN EDITORS 部分还允许您在工作台上拖放编辑器组，在组之间移动各个选项卡，并通过单击 Close All 快速关闭整个组。

确保 VS 代码使用编辑器组，不管你是否有标签。如果没有标签，编辑器群组就是一堆打开的项目，最近搜索的项目在编辑器面板中可见。默认情况下，当您拆分编辑器以从侧面打开它时，编辑器群组以垂直栏的形式组织。您还可以按照您喜欢的任何布局(垂直和水平)排列编辑器群组。

为了支持灵活的布局，您应该创建空的编辑器组。默认情况下，关闭编辑器组的最后一个编辑器也会关闭该组本身，但您可以使用新设置 work bench . editor . closeemptygroups:false 来修改此行为。您还可以在查看➤编辑器布局菜单中查看是否有任何预定义的编辑器布局集。

通过单击编辑器工具条分割编辑器操作打开的编辑器通常会在活动编辑器的右侧打开。如果您喜欢在活动编辑器下面打开编辑器，请配置新的设置 work bench . editor . opensidebysidedirection:down。

有很多键盘命令可以单独使用键盘来调整编辑器布局，但是如果您更喜欢使用鼠标，拖放是将编辑器拆分到任何方向的最快方法。此外，如果您在切换工具栏操作以拆分编辑器时按住 Alt 键，它将提供向另一个方向的拆分。这是另一种快速向右或向下拆分的方法。

快捷键

了解一些方便的键盘快捷键来在编辑器和编辑器组之间快速导航对你来说也是非常有益的。下面是一些最广泛使用的: 4

  • Ctrl+PageDown 转到右边的编辑器。

  • Ctrl+PageUp 转到左边的编辑器。

  • Ctrl+Tab 打开编辑器组 MRU 列表中的上一个编辑器。

  • Ctrl+1 转到最左边的编辑器组。

  • Ctrl+2 转到中心编辑器组。

  • Ctrl+3 转到最右边的编辑器组。

  • Ctrl+F4 关闭活动编辑器。

  • Ctrl+K W 关闭编辑器组中的所有编辑器。

  • 关闭所有编辑器。

禁用预览模式

如果没有标签，文件浏览器的打开编辑器部分是一个很好的文件导航方式。在预览编辑器模式下，文件不会显示在打开的编辑器列表中，也不会显示在单击打开的编辑器组中。您可以通过 workbench.editor.enablePreview 和 work bench . editor . enablepreviewfromcquickopen 设置关闭此功能。

使用 Ctrl+Tab 在整个编辑器历史中导航

您可以编辑 Ctrl+Tab 的键绑定，以向您显示独立于活动编辑器组的历史中所有打开的编辑器的列表。您可以编辑您的键绑定，并使用以下命令添加:

{ "key": "ctrl+tab", "command": "workbench.action.openPreviousEditorFromHistory" },
{ "key": "ctrl+tab", "command": "workbench.action.quickOpenNavigateNext", "when": "inQuickOpen" }

关闭整个群组而不是单个编辑器

如果您想在关闭一个编辑器时重复 VS 代码关闭整个组的行为，您可以使用:

macOS: { "key": "cmd+w", "command": "workbench.action.closeEditorsInGroup" }
Windows/Linux: { "key": "ctrl+w", "command": "workbench.action.closeEditorsInGroup" }

窗口管理

VS 代码有一些操作选项来决定如何在会话之间打开或恢复窗口。默认情况下，设置 window.openFoldersInNewWindow 和 window.openFilesInNewWindow 用于配置打开新窗口或重新使用文件或文件夹的最后一个活动窗口以及可能的值。

如果编辑为默认条件，VS 代码将恢复您在之前的会话中工作的所有窗口。但是，仍然存在忽略此设置的情况(例如，如果使用-new-window 或-reuse-window 命令行选项)。

window.restoreWindows 设置告诉 VS 代码如何恢复上一个会话中打开的窗口。您还可以将此设置更改为从不重新打开任何窗口，并且总是从一个空的 VS 代码实例开始。

我们现在将看看如何为 Python 开发设置 VS 代码。

设置 VSC

获取和激活 VS 代码既简单又快捷。只需下载一小段，然后你就可以在几分钟内安装它(图 1-2 )。

img/514155_1_En_1_Fig2_HTML.jpg

图 1-2

设置 VS 代码

跨平台

VS Code 是一个免费的代码编辑器，可以在 macOS、Linux 和 Windows 操作系统上运行。

为了更顺利地安装，您可以遵循以下特定于平台的指南: 5

苹果

  1. 下载用于 macOS 的 VS 代码。

  2. 打开浏览器的下载列表，找到下载的归档文件。

  3. 选择放大镜图标以在 Finder 中打开归档。

  4. 将 VS Code.app 拖到 Applications 文件夹，使其在 macOS Launchpad 中可用。

  5. 将 VS 代码添加到您的 Dock 中，方法是右键单击图标，打开上下文菜单，然后选择 Options，Keep in Dock。

Linux 操作系统

VS 代码在 Snap Store 中以 Snap 包的形式正式发布，也可以以 RPM 或 DEB 包的形式从官方网站下载。

可以通过运行:sudo snap install - classic code #或者 code-insiders 来安装。

安装后，Snap 守护进程将在后台自动更新 VS 代码。每当有新的更新可用时，您还会收到产品内更新通知。

Windows 操作系统

  1. 下载 Windows 的 VS 代码安装程序。

  2. 下载后，运行安装程序(VSCodeUserSetup-{version}。exe)。这只需要一分钟。

  3. 默认情况下，VS 代码安装在 C:\ users \ { username } \ AppData \ Local \ Programs \ Microsoft VS Code 下。

VS 代码是轻量级的，应该可以在大多数可用的硬件和平台版本上运行。您可以查看系统要求，以了解您的计算机配置是否受支持。

更新节奏

VS Code 每个月都会发布一个新版本，包含新特性和渐进式错误修复。大多数平台都安装了自动更新，所以当新版本发布时，系统会提示您寻找新版本。您也可以手动检查更新，方法是在 Linux 和 Windows 上运行帮助➤检查更新，或者在 macOS 上运行代码➤检查更新。此外，如果您想根据自己的计划更新 VS 代码，也可以禁用自动更新。

内部人员夜间构建

如果您想在夜间检查 VS 代码构建，以便比其他用户更早地获得新特性，或者验证错误修复，您可以安装 Insiders 构建。内部版本与每月稳定版本并排安装，您可以在同一台机器上自由地合并和使用它们。内部人员构建与 VS 代码开发团队日常使用的工具相同。如果您对要提供的新特性有宝贵的反馈，开发团队会非常感激。

便携模式

VS 代码也支持便携模式安装。这种模式确保了由 VS 代码创建和维护的所有数据都存储在近距离内，以便在必要时可以跨环境移动，甚至是在 USB 驱动器上。

附加组件

VS 代码是一个占用空间相对较小的编辑器。与其他传统编辑器不同，传统编辑器倾向于包含所有其他功能，使用 VS 代码，您可以根据对您最重要的开发技术来调整和定制您的安装。

扩展ˌ扩张

VS 代码扩展允许第三方添加对以下内容的支持:

  • 语言: C++，C#，Go，Java，Python

  • 工具:斯洛文尼亚语、JSHint 语、PowerShell 语

  • 调试器: PHP XDebug

  • 按键映射: Vim，Sublime Text，IntelliJ，Emacs，Atom，括号，Visual Studio，Eclipse

扩展平滑地集成到 VS Code 的用户界面、命令和任务运行系统中，所以你会发现通过 VS Code 的共享接口很容易操作不同的技术。

VSC 的键绑定

VS 代码为您提供了一个直接从键盘管理大多数任务的选项(图 1-3 )。本节列出了默认绑定(键盘快捷键),并概述了如何更新它们。

img/514155_1_En_1_Fig3_HTML.jpg

图 1-3

在 VS 代码中使用键盘快捷键

键盘快捷键编辑器

VS 代码有许多简单的键盘快捷键使用键盘快捷键编辑器。它说明了所有可用的命令，包括有无按键绑定，您可以使用可用的选项轻松地更改、删除和更新这些命令。它的顶部还有一个搜索框，在搜索命令或按键时非常有用。您可以通过查看文件➤首选项➤键盘快捷键(macOS 上的代码➤首选项➤键盘快捷键)下的菜单来打开此编辑器。您也可以在帮助➤键盘快捷键参考中访问这些键盘快捷键的可打印版本，并获得一个适合打印的压缩 PDF 版本作为用户友好的参考。

检测按键绑定冲突

如果您安装了太多的扩展，或者您已经自定义了大部分键盘快捷键，您可能会不时地遇到键绑定冲突，因为同一个键盘快捷键被映射来执行几个命令。这可能会导致混乱，尤其是当您继续使用编辑器时，不同的键绑定会进入和超出范围。您应该不时地查看键盘快捷键编辑器，该编辑器有一个上下文菜单命令“显示相同的键绑定”,该命令用于根据键盘快捷键过滤键绑定，以显示并潜在地防止任何冲突。

按键疑难解答

要解决按键问题，可以激活命令 Developer:Toggle Keyboard shortcut s trouble shooting。这将有助于记录发送的键盘快捷键，并提供对带有相应日志文件的输出面板的访问。

有了它，你可以稍后按下你想要的键绑定，并检查什么键盘快捷键 VS 代码使用和什么命令被激活。

键盘规则

每条规则由以下内容组成: 6

  • 定义被按下的键的键。

  • 包含要执行的命令的标识符的命令。

  • 可选的 when 子句，包含将根据当前上下文计算的布尔表达式。

称为和弦的两个单独的按键动作通过用空格分隔两个按键来描述。比如 Ctrl+K Ctrl+C。

按下按键时:

  • 规则是自下而上评估的。

  • 第一个匹配的规则，包括键和何时被接受。

  • 不再处理任何规则。

  • 如果找到一个规则，并且它也有一个命令集，则执行该命令。

额外的 keybindings.json 规则在运行时被省略到默认规则的底部，因此允许它们覆盖默认规则。VS 代码会观察 keybindings.json 文件，因此在 VS 代码运行时编辑它会在运行时升级规则。

通过分析存储在 JSON 中的规则列表来完成键盘快捷键的分派。举几个例子来说明: 7

// Keybindings that are active when the focus is in the editor:
{ "key": "home",            "command": "cursorHome",              "when": "editorTextFocus" },
{ "key": "shift+home",      "command": "cursorHomeSelect",            "when": "editorTextFocus" },

// Keybindings that are complementary:
{ "key": "f5",              "command": "workbench.action.debug.continue", "when": "inDebugMode" },
{ "key": "f5",              "command": "workbench.action.debug.start",    "when": "!inDebugMode" },

// Global keybindings:
{ "key": "ctrl+f",          "command": "actions.find" },
{ "key": "alt+left",        "command": "workbench.action.navigateBack" },
{ "key": "alt+right",       "command": "workbench.action.navigateForward" },

// Global keybindings using chords (two separate keypress actions):
{ "key": "ctrl+k enter",    "command": "workbench.action.keepEditor" },
{ "key": "ctrl+k ctrl+w",   "command": "workbench.action.closeAllEditors" },

接受的密钥

密钥由修饰符和密钥本身组成。接受以下修饰符:

|

平台

|

修饰语

|
| --- | --- |
| 苹果 | Ctrl+、Shift+、Alt+、Cmd+ |
| Windows 操作系统 | Ctrl+，Shift+，Alt+，Win+ |
| Linux 操作系统 | Ctrl+， Shift+， Alt+， Meta+ |

接受以下密钥:

  • f1-f19，a-z，0-9

  • `, -, =, [, ], , ;, ', ,, ., /

  • 向左、向上、向右、向下、向上翻页、向下翻页、结束、回家

  • 制表符、回车、转义、空格、退格、删除

  • 暂停断开，帽锁，插入

  • numpad0-numpad9、numpad _ multiply、numpad_add、numpad_separator

  • numpad_subtract、numpad_decimal、numpad_divide

命令参数

您可以使用参数调用命令。如果您经常对特定的文件或文件夹执行相同的操作，这尤其有用。您可以包含一个自定义的键盘快捷键来完成您需要它做的事情。下面是一个覆盖 Enter 键以打印一些文本的示例:

{
  "key": "enter",
  "command": "type",
  "args": { "text": "Hello There" },
  "when": "editorTextFocus"
}

type 命令将接收{"text": "Hello There"}作为其第一个参数，并将" Hello There "添加到文件中，而不是生成默认命令。

删除特定的键绑定规则

您可以编写一个键绑定规则脚本，以消除特定的默认键绑定。使用 keybindings.json，重新定义 VS 代码的所有键绑定总是可以接受的，但是做一点小的添加可能是有挑战性的，特别是在重载的键周围，比如 Tab 或 Escape。为了隐藏特定的键绑定，在命令中添加一个-,该规则将成为一个移除规则。

独立于键盘布局的 Nindings

使用扫描代码，定义不随键盘布局的修改而改变的键绑定是可管理的。比如:{ " key ":" cmd+[斜杠]"，" command ":" editor . action . commentline "，以及" when": "editorTextFocus" }。

接受以下扫描代码:

[F1]-[F19], [KeyA]-[KeyZ], [Digit0]-[Digit9]
[Backquote], [Minus], [Equal], [BracketLeft], [BracketRight], [Backslash], [Semicolon], [Quote], [Comma], [Period], [Slash]
[ArrowLeft], [ArrowUp], [ArrowRight], [ArrowDown], [PageUp], [PageDown], [End], [Home]
[Tab], [Enter], [Escape], [Space], [Backspace], [Delete]
[Pause], [CapsLock], [Insert]
[Numpad0]-[Numpad9], [NumpadMultiply], [NumpadAdd], [NumpadComma]
[NumpadSubtract], [NumpadDecimal], [NumpadDivide]

When 子句上下文

VS 代码通过可选的 when 子句让您完全控制何时激活键绑定。如果一些键绑定没有 when 子句，那么这些键绑定在任何时候都是全局可用的。when 子句与操作键绑定的布尔值 true 或 false 相关。

此外，VS 代码根据 VS 代码用户界面中可用和活动的元素来设置各种上下文键和特定值。例如，内置的开始调试命令具有键盘快捷键 F5，该快捷键仅在有适当的调试器可用(context debuggersAvailable 为 true)并且编辑器不处于调试模式(context inDebugMode 为 false)时启用。

条件运算符

对于 when 子句条件表达式，表 1-1 中的条件运算符用于键绑定。8

表 1-1

条件运算符

|

操作员

|

标志

|

例子

|
| --- | --- | --- |
| 平等 | == | " editorLangId == typescript " |
| 不平等 | ！= | "resourceExtname ！= .js" |
| 或者 | || | " isLinux||isWindows " |
| 和 | && | “& textInputFocus！editorReadonly " |
| 比赛 | =~ | " resource scheme = ~ /^untitled\(|^file\)/ " |

可用上下文

在 when 子句上下文参考中，您可以看到一些可用的上下文。这里的列表并不详尽，您可以通过在键盘快捷键编辑器中搜索和过滤(首选项:打开键盘快捷键)或查看默认的 Keybindings JSON 文件(首选项:打开默认键盘快捷键(JSON))来查找其他 when 子句上下文。表格 1-2 到 1-12 为一些基本命令提供了快捷方式。 9

表 1-2

基本编辑

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 切割线(空选择) | Ctrl+X | editor . action . clipboard cut action |
| 复制行(空选择) | Ctrl+C | editor . action . clipboardcopyaction |
| 粘贴 | Ctrl+V | editor . action . clipboard paste action |
| 删除行 | Ctrl+Shift+K | 编辑器. action.deleteLines |
| 在下面插入一行 | 按住 Ctrl 键并输入 | editor.action.insertLineAfter |
| 在上面插入一行 | Ctrl+Shift+Enter | editor.action.insertLineBefore |
| 下移一行 | alt+向下 | editor . action . movelinesdownaction |
| 向上移动一行 | Alt+Up | editor . action . movelinesupaction |
| 向下复制一行 | shift+Alt+向下 | editor . action . copylinesdownaction |
| 复制整行 | shift+Alt+向上 | editor . action . copylinesupaction |
| 取消 | Ctrl+Z 组合键 | 取消 |
| 重做 | Ctrl+Y | 重做 |
| 将所选内容添加到下一个查找匹配项 | Ctrl+D | editor . action . addselectiontonxtfindmatch |
| 将最后一个选择移动到下一个查找匹配项 | Ctrl+K | editor . action . moveselectiontextfindmatch |
| 撤消上一次光标操作 | Ctrl+U | cursorUndo |
| 在行尾插入光标 | Shift+Alt+I | editor . action . insertcursoratendofeachlineselected |
| 选择当前选择的所有匹配项 | Ctrl+Shift+L | editor . action . select 突出显示 |
| 选择当前单词的所有匹配项 | Ctrl+F2 | editor.action.changeAll |
| 选择当前行 | Ctrl+L | 扩大选举 |
| 在下面插入光标 | ctrl+Alt+向下 | editor . action . insertcursorbelow |
| 在上方插入光标 | Ctrl+Alt+Up | editor . action . insertcursorabove |
| 跳转到匹配的括号 | Ctrl+Shift+\ | editor . action . jumptobragg |
| 缩进行 | Ctrl+] | 编辑器. action.indentLines |
| 突出线路 | Ctrl+[ | editor.action.outdentLines |
| 转到行首 | 主页 | 光标之家 |
| 转到行尾 | 目标 | cursorEnd |
| 转到文件结尾 | Ctrl+End | 光标底部 |
| 转到文件开头 | Ctrl+Home | cursorTop |
| 向下滚动一行 | ctrl+向下 | 向下滚动 |
| 向上滚动一行 | ctrl+向上 | scrollLineUp |
| 向下滚动页面 | Alt+PageDown | 向下滚动页面 |
| 向上滚动页面 | Alt+PageUp | scrollPageUp |
| 折叠区域 | Ctrl+Shift+[ | editor.fold |
| 展开(未折叠)区域 | Ctrl+Shift+] | 编辑器.展开 |
| 折叠(折叠)所有子区域 | Ctrl+K Ctrl+[ | editor.foldRecursively |
| 展开(取消折叠)所有子区域 | Ctrl+K Ctrl+] | editor.unfoldRecursively |
| 折叠(折叠)所有区域 | Ctrl+K Ctrl+0 | 编辑器. foldAll |
| 展开(取消折叠)所有区域 | Ctrl+K Ctrl+J | editor.unfoldAll |
| 添加行注释 | Ctrl+K Ctrl+C | editor.action.addCommentLine |
| 删除行注释 | Ctrl+K Ctrl+U | editor . action . remove commentline |
| 切换行注释 | Ctrl+/ | editor.action.commentLine |
| 切换块注释 | Shift+Alt+A | editor . action . block 注释 |
| 发现 | Ctrl+F | 动作.查找 |
| 替换 | Ctrl+H | 编辑器. action . startfindreplaceaction |
| 查找下一个 | 进入 | editor.action.nextMatchFindAction |
| 查找上一个 | Shift+Enter | editor . action . previousmatchfindaction |
| 选择“查找匹配”的所有匹配项 | Alt+Enter | editor.action.selectAllMatches |
| 切换区分大小写 | Alt+C | toggleFindCaseSensitive |
| 切换查找正则表达式 | Alt+R | toggleFindRegex |
| 切换查找整个单词 | Alt+W | toggleFindWholeWord |
| 切换使用 Tab 键设置焦点 | Ctrl+M | editor . action . toggletabfocusmode |
| 切换渲染空白 | 未赋值的 | toggleRenderWhitespace |
| 切换自动换行 | Alt+Z | editor.action.toggleWordWrap |

表 1-3

丰富的语言编辑

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 触发建议 | ctrl+空格 | 编辑器.操作.触发器建议 |
| 触发参数提示 | ctrl+Shift+空格键 | editor . action . trigger 参数提示 |
| 格式化文档 | 移位+Alt+F | editor . action . format 文档 |
| 格式选择 | Ctrl+K Ctrl+F | 编辑器.操作.格式选择 |
| 转到定义 | F12 | editor.action.revealDefinition |
| 显示悬停 | Ctrl+K Ctrl+I | 编辑器. action.showHover |
| 峰值定义 | Alt+F12 | editor.action.peekDefinition |
| 向侧面打开定义 | Ctrl+K F12 | editor . action . revealdefinitionside |
| 权宜之计 | Ctrl+。 | 编辑器. action.quickFix |
| 转到参考 | Shift+F12 | editor.action.goToReferences |
| 重命名符号 | 第二子代 | 编辑器.操作.重命名 |
| 替换为下一个值 | Ctrl+Shift+。 | editor . action . inplace replace . down |
| 用以前的值替换 | Ctrl+Shift+， | editor . action . inplace replace . up |
| 展开 AST 选择 | shift+Alt+右移 | editor . action . smart select . expand |
| 收缩 AST 选择 | shift+Alt+向左 | editor . action . smart select . shrink |
| 修剪尾部空白 | Ctrl+K Ctrl+X | editor . action . trimtrailinghhitespace |
| 更改语言模式 | Ctrl+K M | work bench . action . editor . changeloangemode |

表 1-4

航行

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 显示所有符号 | Ctrl+T | work bench . action . showall symbols |
| 转到线... | Ctrl+G | workbench.action.gotoLine |
| 转到文件...，快开 | Ctrl+P | workbench 动作 quickOpen |
| 转到符号... | Ctrl+Shift+O | workbench.action.gotoSymbol |
| 显示问题 | Ctrl+Shift+M | 工作台.操作.视图.问题 |
| 转到下一个错误或警告 | F8 | editor . action . marker . nextinfiles |
| 转到上一个错误或警告 | Shift+F8 | editor . action . marker . pre file |
| 显示所有命令 | Ctrl+Shift+P 或 F1 | work bench . action . show 命令 |
| 导航编辑器历史 | Ctrl+Tab | work bench . action . quickopenpreviousededitingroup |
| 回去 | alt+向左 | 工作台.操作.向后导航 |
| 快速输入返回 | alt+向左 | work bench . action . quick input back |
| 前进 | 好 | 工作台.操作.向前导航 |

表 1-5

编辑器/窗口管理

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 新窗口 | Ctrl+Shift+N | 工作台.操作.新窗口 |
| 关闭窗口 | Ctrl+W 组合键 | 工作台.操作.关闭窗口 |
| 关闭编辑器 | Ctrl+F4 | work bench . action . close active editor-work bench .动作.关闭作用中编辑器 |
| 关闭文件夹 | Ctrl+K F | 工作台.操作.关闭文件夹 |
| 在编辑器组之间循环 | 未赋值的 | work bench . action . navigateeditorgroups |
| plist 编辑器 | Ctrl+\ | 工作台.操作. splitEditor |
| 聚焦到第一个编辑组 | Ctrl+1 | work bench . action . focusfirsteditorgroup |
| 聚焦到第二个编辑组 | Ctrl+2 | work bench . action . focussecondeditorgroup |
| 聚焦到第三编辑组 | Ctrl+3 | work bench . action . focusthirdeditorgroup |
| 聚焦到左边的编辑组 | 未赋值的 | work bench . action . focuspreviousgroup |
| 聚焦到右边的编辑组 | 未赋值的 | work bench . action . focus next group |
| 向左移动编辑器 | Ctrl+Shift+PageUp | workbench 动作 moveeditorleftingroup |
| 向右移动编辑器 | Ctrl+Shift+PageDown | workbench 动作 moveEditorRightInGroup |
| 向左移动活动编辑器组 | Ctrl+K 向左 | work bench . action . moveactiveeditgroupleft |
| 向右移动活动编辑器组 | Ctrl+K 向右 | work bench . action . moveactiveeditorgroup right |
| 将编辑器移到下一组 | ctrl+Alt+右键 | work bench . action . moveeditortonextgroup |
| 将编辑器移到上一组 | ctrl+Alt+左键 | work bench . action . moveedittopreviewougroup |

表 1-6

文件管理

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 新文件 | Ctrl+N | work bench . action . files . newuntitled file |
| 开文件... | Ctrl+O | work bench . action . files . openfile |
| 救援 | Ctrl+S | 工作台.操作.文件.保存 |
| 全部保存 | Ctrl+K S | saveAll(保存全部) |
| 另存为... | Ctrl+Shift+S | 工作台.操作.文件.另存为 |
| 关闭 | Ctrl+F4 | work bench . action . close active editor-work bench .动作.关闭作用中编辑器 |
| 关闭其他 | 未赋值的 | 工作台.动作.收尾编辑器 |
| 封闭组 | Ctrl+K W 组合键 | work bench . action . closeeditorsingroup |
| 关闭其他组 | 未赋值的 | work bench . action . closeeditorsinothergroups |
| 向左关闭群组 | 未赋值的 | work bench . action . closeeditorstotheleft |
| 向右关闭群组 | 未赋值的 | work bench . action . closed store right-维护作业 |
| 全部关闭 | Ctrl+K Ctrl+W | work bench . action . closealleditors |
| 重新打开关闭的编辑器 | Ctrl+Shift+T | work bench . action . reopenclosededitor |
| 保持开放 | Ctrl+K Enter | 工作台.操作. keepEditor |
| 复制活动文件的路径 | Ctrl+K P | work bench . action . files . copypathfactory 文件 |
| 在窗口中显示活动文件 | Ctrl+K R 组合键 | work bench . action . files . revealactivefileinwindows |
| 在新窗口中显示打开的文件 | Ctrl+K | work bench . action . files . showopenedfileinnewwindow |
| 将打开的文件与 | 未赋值的 | work bench . files . action . comparefilewith |

表 1-7

显示

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 切换全屏 | F11 | work bench . action . toggle full screen |
| 切换 Zen 模式 | Ctrl+K Z 组合键 | workbench.action.toggleZenMode |
| 离开禅模式 | 逃跑 | 工作台。操作。请求模型 |
| 放大 | Ctrl+= | 工作台.动作. zoomIn |
| 缩小 | Ctrl+- | workbench.action.zoomOut |
| 重置缩放 | Ctrl+Numpad0 | workbench.action.zoomReset |
| 切换侧边栏可见性 | Ctrl+B | work bench . action . togglesidebarvisibility |
| 显示浏览器/切换焦点 | Ctrl+Shift+E | workbench.view.explorer |
| 显示搜索 | Ctrl+Shift+F | 工作台.视图.搜索 |
| 显示源代码管理 | Ctrl+Shift+G | 工作台.视图. scm |
| 显示运行 | Ctrl+Shift+D | 工作台.视图.调试 |
| 显示扩展 | Ctrl+Shift+X | 工作台.视图.扩展 |
| 显示输出 | Ctrl+Shift+U | 工作台.操作.输出. toggleOutput |
| 快速打开视图 | Ctrl+Q | workbench.action.quickOpenView |
| 打开新命令提示符 | Ctrl+Shift+C | work bench . action . terminal . opennativeconsole |
| 切换降价预览 | Ctrl+Shift+V | markdown.showPreview |
| 在侧面打开预览 | Ctrl+K V | markdown.showPreviewToSide |
| 切换集成终端 | Ctrl+`键 | 工作台.操作.终端. toggle 终端 |

表 1-8

搜索

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 显示搜索 | Ctrl+Shift+F | 工作台.视图.搜索 |
| 在文件中替换 | Ctrl+Shift+H | work bench . action . replace infiles |
| 切换匹配大小写 | Alt+C | toggleSearchCaseSensitive |
| 切换全字匹配 | Alt+W | toggleSearchWholeWord |
| 切换使用正则表达式 | Alt+R | toggleSearchRegex |
| 切换搜索详细信息 | Ctrl+Shift+J | work bench . action . search . togglequerydetails |
| 聚焦下一个搜索结果 | 法乐四联症 | search . action . focusextsearchresult |
| 聚焦上一个搜索结果 | Shift+F4 | search . action . focusprevioussearchresult |
| 显示下一个搜索词 | 向下 | history.showNext |
| 显示上一个搜索词 | 起来 | history . show 上一个 |

表 1-9

搜索编辑器

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 在编辑器中打开结果 | Alt+Enter | search.action.openInEditor |
| 焦点搜索编辑器输入 | 逃跑 | search . action . focusqueryeditorwidget |
| 再次搜索 | Ctrl+Shift+R | rerunSearchEditorSearch |
| 删除文件结果 | ctrl+Shift+退格键 | search . search editor . action . delete file results |

表 1-10

偏好；喜好；优先；参数选择

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 打开设置 | Ctrl+， | 工作台.操作. openSettings |
| 打开工作区设置 | 未赋值的 | work bench . action . openworkspacesettings |
| 打开键盘快捷键 | Ctrl+K Ctrl+S | work bench . action . openglobalkey bindings |
| 打开用户片段 | 未赋值的 | work bench . action . open snippet |
| 选择颜色主题 | Ctrl+K Ctrl+T | work bench . action . select 主题 |
| 配置显示语言 | 未赋值的 | work bench . action . configure locale |

表 1-11

调试

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 切换断点 | F9 | editor . debug . action . toggle 断点 |
| 开始 | F5 | 工作台.操作.调试.启动 |
| 继续 | F5 | 工作台.操作.调试.继续 |
| 启动(不调试) | Ctrl+F5 | 工作台.操作.调试.运行 |
| 中止 | F6 | 工作台.操作.调试.暂停 |
| 进入 | F11 | work bench . action . debug . stepinto |

表 1-12

任务

|

命令

|   |

钥匙

|

命令 id

|
| --- | --- | --- | --- |
| 运行生成任务 |   | Ctrl+Shift+B | 工作台.操作.任务.构建 |
| 运行测试任务 |   | 未赋值的 | 工作台.操作.任务.测试 |

表 1-13

扩展ˌ扩张

|

命令

|

钥匙

|

命令 id

|
| --- | --- | --- |
| 安装扩展 | 未赋值的 | 工作台.扩展.操作.安装扩展 |
| 显示已安装的扩展 | 未赋值的 | work bench . extensions . action . showinstalledextensions |
| 显示过时的扩展名 | 未赋值的 | work bench . extensions . action . listoutdatedextensions |
| 显示推荐的扩展 | 未赋值的 | work bench . extensions . action . show 推荐扩展 |
| 显示常用扩展 | 未赋值的 | work bench . extensions . action . show popular extensions |
| 更新所有扩展 | 未赋值的 | work bench . extensions . action . updateall extensions |

支持的编程语言

在 VS 代码中，几乎每一种主流编程语言都有一个支持工具。具有丰富语言扩展的 JavaScript、TypeScript、CSS 和 HTML 的大多数默认设置都可以在 VS 代码市场中找到。以下是八种最流行的语言扩展:

  • 计算机编程语言

  • C/C++

  • C#

  • Java 扩展包

  • 去

  • 镖

  • PHP 扩展包

  • 红宝石

您可以去市场或查看 integrated Extensions 视图，并搜索您想要的编程语言，以找到代码片段、代码完成和智能感知提供程序、linters、调试器等。如果您想要更改 VS 代码的显示语言(例如，更改为其他可用的语言)，您可以在显示语言主题中完成。

最好事先对这些编程语言和 VS 代码支持的特定于语言的文档有所了解。

VS 代码中的语言特性

不同语言及其扩展的支持特性各不相同:

  • 语法突出显示和括号匹配

  • 智能完成

  • 林挺和更正

  • 代码导航(转到定义，查找所有引用)

  • 排除故障

  • 重构

更改所选文件的语言

在 VS 代码中，有一个基于文件扩展名的默认语言支持设置。然而，当您需要更改一些语言模式时，您可以通过单击状态栏右侧的语言指示器来实现。这将调用选择语言模式下拉菜单，您可以看到并选择另一种语言的当前文件。

附加组件和工具

根据设计，VS 代码非常少，并且只包含有限数量的跨大多数开发平台共享的组件。包括编辑器、文件管理、窗口管理和首选项设置等基本功能。JavaScript 和 TypeScript 语言服务以及 Node.js 调试器也是基本结构的一部分。

如果您习惯于使用更大、更具包容性和多样化的开发工具，您可能会惊讶地发现，您的场景并不总是开箱即用。例如，没有预装项目模板的“文件➤新建项目”对话框。大多数 VS 代码用户将被要求寻找和下载额外的组件，这取决于他们的特定项目。

常用组件

以下是一些常见的安装组件:

  • Git: VS 代码内置支持使用 Git 的源代码控制，但需要 Git 安装在侧边。

  • Node.js(包含 npm): 主要用于构建和运行 JavaScript 应用的跨平台。

  • TypeScript:TypeScript 编译器 tsc，用于将 TypeScript 转录为 JavaScript。

VS 代码扩展

还可以通过扩展来扩展 VS 代码编辑器本身。VS 代码社区已经在 VS 代码市场上为以下编程语言构建了多种有用的扩展:

  • 计算机编程语言

  • C/C++

  • 朱皮特

  • 斯洛文尼亚语

  • 更漂亮:代码格式化程序

  • 实时服务器

  • Visual Studio 智能代码

  • C#

附加工具

VS 代码有效地集成了一些广泛使用的工具链。以下工具将有助于提升您的开发体验:

  • Yeoman: 一个应用搭建工具，File ➤新项目的命令行版本。

  • generator-aspnet: 一个用于运行 aspnet 核心应用程序的约曼生成器。

  • 发电机-热毛巾:约曼发电机，用于轻松创建 AngularJS 应用程序。

  • Express: 使用 Pug 模板引擎的 Node.js 应用的应用框架。

  • Gulp: 一个流任务运行器系统，可以与 VS 代码任务合并。

  • Mocha: 运行在 Node.js 上的 JavaScript 测试框架。

  • Yarn: 一个依赖管理器，也是 npm 的一个很好的替代品。

请注意，这些工具中的大多数都需要下载和应用 Node.js 和 npm 包管理器。

设置优先级

不同的设置范围可以在多个级别覆盖配置:

  • 用户设置:全局适用于所有 VS 代码实例。

  • 工作区设置:转到打开的文件夹或工作区，通常覆盖用户设置。

  • 工作区文件夹设置:通常适用于多根工作区的特定文件夹；覆盖用户和工作空间设置。

设定值可以有多种类型:

  • 字符串:" files . auto save ":" after delay "

  • Boolean:" editor . minimap . enabled ":true

  • 编号:“files . auto save delay”:1000

  • 数组: "editor.rulers": []

  • Object:" search . exclude ":

具有基元类型和数组类型的值将被覆盖，但具有对象类型的值将被合并。例如，workbench.colorCustomizations 接受一个指定一组用户界面项目及其所需颜色的对象。如果有冲突的值，通常的反应是用优先于用户值的工作空间值来覆盖行为。

设置和安全性

一些设置允许你指定一个可执行文件，VS 代码将运行该文件来执行某些操作。例如，您可以选择集成终端将使用的 shell。对于更高级的安全性，此类设置只能在用户设置中确定，而不能在工作区范围内确定。查看工作区设置中不支持的设置列表:

  • git.path

  • 终端.外部. windowsExec

  • terminal.external.osxExec

  • 终端.外部. linuxExec

第一次激活决定这些设置的工作空间时，VS 代码会警告你一次，之后你可以忽略这些值。

摘要

在这一章中，我们已经讲述了与 VS 代码相关的基础知识，包括它的用户界面和键盘快捷键。

在下一章中，我们将更仔细地研究 Python 开发的 VS 代码，包括所需扩展的列表、林挺和调试需求。

二、VSC 中的 Python 程序入门

在前一章中，我们介绍了 VS 代码的基础知识。在这一章中，我们将解释如何为 Python 开发设置 VS 代码。它可以很容易地下载并安装在所有主要的操作系统上，如 Windows、Linux 和 macOS。

安装基础

首先，让我们介绍一下安装基础知识。

为了举例说明，我们将展示如何在 Windows 上安装大多数工具。Windows 将用作设置 Python 环境的开发环境。对于 Linux 和 macOS，过程会差不多；尽管如此，这些命令还是有一些不同。

你所要做的就是导航到 https://code.visualstudio.com/download ，选择合适的平台安装软件。下载完成后，继续正常安装。

一旦 VS 代码启动并运行，接下来要做的就是设置 Python 运行时环境。同样，您可以在所有三种操作系统(Windows、Linux 和 macOS)上安装 Python。下载并安装 Python 后，您可以进入命令提示符并运行以下命令来验证安装是否成功。要验证是否已在计算机上成功安装 Python，请激活以下命令之一(取决于您的操作系统):

  • Linux 和 macOS: 打开终端窗口，键入以下命令:

  • Windows: 打开命令提示符并运行以下命令:

python3 --version


py -3 --version

如果安装成功，输出窗口应该能够显示您安装的 Python 版本。

接下来，我们将学习为 VS 代码安装扩展。

检查所需的扩展

默认情况下，VS 代码的操作就像普通的文本编辑器一样，并且没有对 Python 的任何内置支持。这意味着，即使您可以轻松地用 VS 代码编写 Python 代码，您也无法升级和使用一些使编写代码变得更加容易的开发工具或技术。VS 代码通过一个记录良好的扩展模型支持多种编程语言的开发。Python 扩展支持用 VS 代码进行 Python 开发，具有以下特性:

  • 支持 Python 3.4 和更高版本，以及 Python 2.7

  • 使用智能感知完成代码

  • 林挺

  • 调试支持

  • 代码片段

  • 单元测试支持

  • 虚拟环境的自动使用

  • Jupyter 环境和 Jupyter 笔记本中的代码编辑

  • 为 VS 代码安装 Python 扩展

VS 代码扩展也不仅仅涵盖编程语言功能:

  • 键盘映射让已经熟悉 Atom、Sublime Text、Emacs、Vim、PyCharm 或其他环境的用户推进您的编码。

  • 主题可以定制用户界面，无论你喜欢在亮处、暗处还是更鲜艳的地方编码。

  • 语言包让您有更本地化的体验。

  • GitLens 在您的编辑平台中直接提供了大量有用的 Git 特性，包括责备注释和存储库探索特性。

  • 通过从菜单中选择“文件”、“自动保存”,可以很容易地打开自动保存。默认的延迟时间是 1000 毫秒，也是可调的。

  • Settings Sync 提供了使用 GitHub 在不同安装之间同步 VS 代码设置的功能。如果您在不同的机器上工作，这对于保持您的环境在所有机器上的一致性非常有用。

  • docker 让您快速轻松地使用 Docker，帮助创作 Dockerfile 和 docker-compose.yml，设置和部署您的项目，甚至为您的项目生成适当的 Docker 文件。

通过点击活动栏上的扩展图标，可以识别和安装附加的扩展和主题。您可以使用关键字查找扩展，以最喜欢的方式对结果进行排序，并快速轻松地安装扩展。

接下来的章节简要介绍了 VS 代码中 Python 的八大扩展，在活动栏的扩展项中输入 Python 即可看到。开发人员喜欢使用更多的扩展，但是这里我们想把重点放在只适用于 Python 的扩展上。

tabline(表格线)

Tabnine 是一个扩展，它基于一个存储了数百万开源代码行的模型提供代码完成建议，然后将这些代码行提供给您当前正在处理的代码。Tabnine 从您当前编辑的文件中发送最少的上下文数据片段，允许我们根据您当前的项目目标进行预测。该扩展不使用您的代码来训练核心模型，并且发送到服务器的信息仅用于计算您的预测，不会被保存用于任何进一步的应用。

此外，Tabnine 被视为一个强大的人工智能(AI)助手，旨在帮助您更快地编码，防止任何错误，并习惯于最佳编码实践，而不必离开 VS 代码的舒适环境。Tabnine 研究公共共享的代码，并使用基于人工智能的学习算法，使它能够看到你的下一个编码请求，并建议一键完成代码。Tabnine 可与所有主流编程语言兼容，包括 JavaScript、Python、TypeScript、PHP、C/C++、HTML/CSS、Go、Java、Ruby、C#、Rust、SQL、Bash、Kotlin、Julia、Lua、OCaml、Perl、Haskell 和 React。

括号对着色机

这个扩展允许匹配的括号被发现或用颜色分类。这样，用户可以确定匹配哪些字符，使用哪些颜色。下面是几个基本设置: 1

  • " bracketpaircolorizer . time out ":配置编辑器在更新文档之前应该空闲多长时间；置 0 禁用。

  • " bracketpaircolorizer . forceuniqueopeningcolor ":禁用。

  • " bracketpaircolorizer . forceiterationcolorcycle ":已启用。

  • " bracketpaircolorizer . colormode ":连续的括号共享所有括号类型的颜色池。

独立的括号允许每种括号类型使用自己的颜色池:

  • " bracketpaircolorizer . highlight activescope ":突出显示当前作用域的括号。

  • " bracketpaircolorizer . activescopecss ":选择边框样式突出显示活动范围；使用{color}来匹配现有的括号颜色。如果使用此功能，建议禁用内置的 editor.matchBrackets 设置。添加值“backgroundColor : {color}”以增加可见性。

  • " bracketpaircolorizer . showbracketsinglets ":在装订线中显示活动范围括号。

  • " bracketpaircolorizer . showbracketsintruler ":显示标尺中的活动范围括号。

  • " bracketpaircolorizer . ruler position ":标尺中的装饰位置。

  • " bracketpaircolorizer . showverticalscopeline ":在括号之间显示一条垂直线。

  • " bracketpaircolorizer . showhorizontalscopeline ":在括号之间显示一条水平线；默认启用

  • " bracketpaircolorizer . scopelinerelativeposition ":禁用在第 0 列显示垂直线。

  • " bracketpaircolorizer . scopelinecss ":选择边框样式以突出显示活动范围；使用{color}来匹配现有的括号颜色。

  • " bracketpaircolorizer . consecutivepaircolors ":新的括号对可以通过添加到数组中来配置。注意:对必须是 Prism.js 支持的标点符号类型。

  • " bracketpaircolorizer . independentpaircolors ":新的括号对可以通过添加到数组中来配置。注意:对必须是 Prism.js 支持的标点符号类型

  • " bracketpaircolorizer . excluded languages ":排除此扩展解析的语言。

Python 片段

市场中有一个代码片段集，可以让你更有效地使用 Python。默认情况下，标准代码片段包包含以下所有 Python 方法:

  • 所有 Python 内置代码片段，并且包含每个方法的至少一个示例

  • 所有 Python 字符串片段至少包含每个方法的一个示例

  • 所有 Python 列表片段至少包含每个方法的一个示例

  • 所有 Python 集合片段都包含每个方法的至少一个示例

  • 所有 Python 元组片段都包含每个方法的至少一个示例

  • 所有 Python 字典片段至少包含每个方法的一个示例

此外，该集合还包含许多其他代码片段，如 if/else、for、while、while/else、try/catch、文件进程、类片段等， 2 如表 2-1 所示。

表 2-1

其他代码片段

|

片段

|

描述

|
| --- | --- |
| 丙烯腈-丁二烯-苯乙烯 | 返回一个数字的绝对值 |
| 全部 | 如果 iterable 对象中的所有项目都为 true，则返回 True |
| 任何的 | 如果 iterable 对象中的任何一项为 true，则返回 True |
| 美国信息交换标准代码 | 返回对象的可读版本。用转义字符替换非 ASCII 字符 |
| 容器 | 返回数字的二进制版本 |
| 弯曲件 | 返回指定对象的布尔值 |
| 字节数组 | 返回字节数组 |
| 字节 | 返回一个 bytes 对象 |
| 请求即付的 | 如果指定的对象是可调用的，则返回 True，否则返回 False |
| 儿童健康研究（Child Health Research 的缩写） | 从指定的 Unicode 代码中返回一个字符。 |
| 德拉特尔 | 从指定的对象中删除指定的特性(属性或方法) |
| 词典 | 返回一个字典(数组) |
| 目录 | 返回指定对象的属性和方法的列表 |
| 时尚潮流 | 返回参数 1 除以参数 2 所得的商和余数 |
| 列举 | 获取集合(例如，元组)并将其作为枚举对象返回 |
| evaluate 评价 | 计算并执行表达式 |
| 高级管理人员 | 执行指定的代码(或对象) |
| 过滤器 | 使用筛选函数排除可迭代对象中的项目 |
| 漂浮物 | 返回浮点数 |
| 冻结集合 | 返回一个 frozenset 对象 |
| getattr | 返回指定属性(属性或方法)的值 |
| 全球 | 将当前全局符号表作为字典返回 |
| 哈萨特 | 如果指定的对象具有指定的属性(属性/方法)，则返回 True |
| 混杂 | 返回指定对象的哈希值 |
| 帮助 | 执行内置帮助系统 |
| 十六进制 | 将数字转换为十六进制值 |
| （同 Internationalorganizations）国际组织 | 返回一个整数 |
| 编号 | 返回对象的 id |
| 投入 | 允许用户输入 |
| 情况如何 | 如果指定对象是指定对象的实例，则返回 True |
| 判断类是否为某类的子类 | 如果指定的类是指定对象的子类，则返回 True |
| 国际热核聚变实验堆 | 返回迭代器对象 |
| 低输入联网（low-entry networking 的缩写） | 返回对象的长度 |
| 当地人 | 返回当前局部符号表的更新字典 |
| 地图 | 返回应用于每一项的指定函数的指定迭代器 |
| 最大 | 返回 iterable 中最大的项 |
| 内存视图 | 返回一个内存视图对象 |
| 部 | 返回 iterable 中最小的项 |
| 然后 | 返回 iterable 中的下一项 |
| 目标 | 返回一个新对象 |
| 十月 | 将数字转换成八进制 |
| 打开 | 打开一个文件并返回一个 file 对象 |
| 订单 | 给定长度为 1 的字符串，当参数是 Unicode 对象时，返回表示字符的 Unicode 码位的整数，当参数是 8 位字符串时，返回字节的值。 |
| 啪 | 将 x 返回到 y 的幂 |
| 打印 | 打印到标准输出设备 |
| 财产 | 获取、设置、删除属性 |
| 范围 | 返回一个数字序列，从 0 开始，按 1 递增(默认情况下) |
| 继承人 | 返回对象的可读版本 |
| 颠倒的 | 返回一个反向迭代器 |
| 圆形物 | 舍入数字 |
| 薄片 | 返回一个切片对象 |
| 分类的 | 返回一个排序列表 |
| 静态方法 | 将方法转换为静态方法 |
| 潜艇用热中子反应堆（submarine thermal reactor 的缩写） | 返回一个字符串对象 |
| 总额 | 对迭代器的项求和 |
| 极好的 | 返回代理对象，该对象将方法调用委托给类型的父类或同级类。 |
| 类型 | 返回对象的类型 |
| unichr | 返回一个字符的 Unicode 字符串，该字符的 Unicode 代码是整数 I。 |
| 变动 | 返回对象的 dict 属性 |
| 活力 | 从两个或多个迭代器中返回一个迭代器 |

VSC 的 Python 测试资源管理器

这个扩展为您提供了一个选项，让您可以使用测试资源管理器 UI 运行 Python 单元测试或 Pytest 测试。此外，该扩展允许您在 VS 代码的侧栏中操作 Python 测试。有一些关键特性使得它在开发人员中非常受欢迎:

  • 在 VS 代码侧边栏的测试视图中显示一个测试资源管理器，其中包含所有注意到的测试和套件及其状态。

  • 测试期间方便的错误报告功能。

  • Unittest 和 Pytest 调试。

  • 当在资源管理器中选择测试时，通知失败测试的日志。

  • 支持多根工作区。

  • 支持 Unittest 和 Pytest 测试框架及其插件。

  • 与 Python 扩展的测试视图的比较。

  • 在发现阶段更好的错误报告。如果有错误，您将看到这样的测试处于出错状态，单击它们，完整的错误消息将显示在输出面板中。Python 扩展最多不会显示包含语法错误或无效数据等错误的测试。

  • 倾向于与诸如 Tavern 之类的 pytest 插件一起工作得更好。Python 扩展不会识别这些测试。

  • 基于测试资源管理器用户界面。当您有一个包含不同语言或框架的项目的工作空间时，这个事实可能特别方便。测试资源管理器用户界面有很多插件，您可以方便地在同一个视图中发现和运行测试。

  • 通过单击失败的测试，显示您的错误和测试的完整报告。

  • 在平台显示屏上仅显示您工作区中的相关文件夹。当您有多个工作空间文件夹时，显示所有工作空间文件夹(就像 Python 扩展所做的那样)可能会有一点问题，但是其中只有几个有任何测试。

用户对这两种扩展的体验是非常主观的。但是，您可能更喜欢这个扩展的用户界面。另外，当您的工作区中有多个文件夹时，每个发现、测试执行和测试取消都不需要您选择一个文件夹。

默认情况下，扩展配置使用 VS 代码的 Python 扩展中的配置。要为您的项目修改 Python，请参见 VS 代码中的 Python 入门。然而，这个扩展应用的测试框架可以被 python test explorer . test framework 配置属性覆盖。两个可用选项是 unittest 和 pytest。当属性设置为 null 时，将使用 Python 扩展模块中的配置。

在配置 Python 测试发现和执行时，确保您熟悉表 2-2 中显示的当前使用的属性列表。??

表 2-2

Python 开发的 VS 代码中使用的属性

|

财产

|

描述

|
| --- | --- |
| python.pythonPath | Python 的路径。 |
| python.envFile | 环境变量定义文件的路径。 |
| python.testing.cwd | 单元测试的可选工作目录。 |
| python.testing.unittestEnabled | 是否使用 unittest 启用或禁用单元测试(启用或禁用测试资源管理器的测试发现)。 |
| python.testing.unittestArgs | 用于测试发现的参数(目前只考虑-s 和-p 参数)。 |
| python.testing.pyTestEnabled | 是否使用 pytest 启用或禁用单元测试(启用或禁用测试资源管理器的测试发现)。 |
| python.testing.pytestPath | pytest 可执行文件或 pytest 兼容模块的路径。 |
| python . testing . pytestargs-python .测试. pytest rgs | 传递给 pytest 的参数。每个参数都是数组中的一个单独的项。 |
| python . testing . autotestdiscosveronsavenabled | 当保存文本文件时，真测试将被自动重新发现。 |
| python 测试器。测试框架工作 | 要使用的测试框架(覆盖 Python 扩展属性 python.testing.unittestEnabled 和 python.testing.pyTestEnabled)。 |

表 2-2 中的配置支持\({workspaceFolder}形式的工作空间文件夹占位符和\) { env:YOUR _ ENVIRONMENT _ VARIABLE }形式的环境变量。

如果您正在配置测试浏览器用户界面，请使用表 2-3 中列出的 g 配置属性。 4

表 2-3

配置属性

|

财产

|

描述

|
| --- | --- |
| testExplorer.onStart | 每当测试运行开始时，停用或重置所有测试状态 |
| testExplorer.onReload | 每当重新加载测试树时，停用或重置所有测试状态 |
| 探测器代码镜头 | 在每个测试或套件上方显示一个 CodeLens，用于运行或调试测试 |
| testExplorer.gutterDecoration | 使用装订线装饰在编辑器中显示每个测试的状态 |
| test explorer . error 装饰 | 在编辑器中将测试失败的错误消息显示为装饰 |
| test explorer . errordecorationhover | 为编辑器中的错误装饰提供悬停消息 |
| testExplorer.sort | 按标签或位置对测试和套件进行排序。如果没有设置(或设置为 null)，它们将按照从适配器接收的顺序显示 |
| test explorer . showcollapsebutton | 显示用于折叠测试树节点的按钮 |
| testExplorer.showExpandButton | 显示一个按钮，用于递归地展开测试树的顶层节点，达到给定的级别数 |
| testExplorer.showOnRun | 每当测试运行开始时，切换到测试资源管理器视图 |
| testexplorer . addtoeditorcontextmenu | 将用于运行和调试当前文件中的测试的菜单项添加到编辑器上下文菜单中 |
| testExplorer.mergeSuites | 合并具有相同标签和父项的套件 |
| testExplorer.hideEmptyLog | 当用户点击日志为空的测试时，隐藏用于显示测试日志的输出通道 |
| testExplorer.hideWhen | 当未注册任何测试适配器或已注册的适配器未找到任何测试时，隐藏测试资源管理器。默认情况下，永远不要隐藏测试资源管理器，有一些测试适配器只能使用这个默认设置。 |

配置调试

该扩展通常在 launch.json 中搜索带有“type”:“python”和“request”:“test”的配置，以便在调试期间加载以下任何项目:

  • 名字

  • 安慰

  • 包封/包围（动词 envelop 的简写）

  • 组件部分

  • showReturnValue

  • iredirectoutput

  • debugStdLib

  • justMyCode

  • 子过程

  • 发送文件

更好的评论

更好的注释扩展可以帮助您在代码中创建更加用户友好的、信息丰富的注释。扩展还可以帮助您将注释分类为提醒、查询、待办事项和项目亮点。注释掉的代码也可以用你喜欢的任何方式进行样式化，以清楚地表明代码的目标是什么，你喜欢的任何其他注释样式都可以在设置中进行调整。该扩展也可以在用户设置或工作区设置中按以下方式配置: 5

  • " better-comments . multilinecomments ":true

此设置将控制是否使用注释标记设置多行注释的样式。如果为 false，多行注释将不带修饰显示。

  • " better-comments . highlight plaintext ":false

此设置将控制纯文本文件中的注释是否使用注释标签来设置样式。为真时，标签(默认值:！* ?//)是一行的第一个字符。

  • better-comments.tags:

标签是用于标记注释以进行修饰的字符或序列。默认的 5 可以修改，以改变颜色，并可以添加更多。

扩展支持的语言列表令人印象深刻，包括以下语言:Ada、AL、Apex、AsciiDoc、BrightScript、C、C#、C++、ColdFusion、Clojure、COBOL、CoffeeScript、CSS、Dart、Dockerfile、Elixir、Elm、Erlang、F#、Fortran、gdscript、GenStat、Go、GraphQL、Groovy、Haskell、Haxe、HiveQL、HTML、Java、JavaScript、JavaScript React、JSON with comments、Julia、Kotlin、LaTexBibtex/Biblatex)、Less、Lisp、Lua、Makefile、Markdown、Nim、MATLAB、Objective-C、Objective-C++、Pascal、Perl、Perl 6、PHP、Pig、PlantUML、PL/SQL、PowerShell、Puppet、Python、R、rack、Ruby、Rust、SAS、Sass、Scala、SCSS、ShaderLab、ShellScript、SQL、STATA、Stylus、Swift、Tcl、Terraform、Twig、TypeScript、TypeScript React、Verilog、Visual Basic、Vue

AutoDocstring

这个 VS 代码扩展使用户能够快速生成 Python 函数的文档字符串。它有一些非常有用的功能，包括:

  • 生成可通过制表符分隔的 docstring 代码段。

  • 开发人员可以在几种不同类型的 docstring 格式之间进行选择。

  • 通过 pep484 类型提示、默认值和变量名称推断参数类型。

  • 该扩展支持 args、kwargs、decorators、errors 和参数类型。

默认情况下，autoDocstring 支持以下 Docstring 格式:

  • 谷歌

  • docBlockr

  • 数组

  • 狮身人面像

  • PEP0257

使用扩展时，建议遵循一些标准应用程序规则:

  • 将光标放在定义正下方的行上，以生成完整的自动填充的文档字符串

  • 确保在用三重引号(“'或' '”)打开 docstring 后按 enter 键

  • 键盘快捷键:对于 mac，ctrl+shift+2 或 cmd+shift+2

  • 可以在首选项中更改➤键盘快捷键➤扩展. generateDocstring

  • 命令:生成文档字符串

  • 右键菜单:生成文档字符串

该扩展提供了以下设置: 6

  • autoDocstring . docstring format:在不同的 docstring 格式之间切换

  • autoDocstring . customtemplatepath:自定义 docstring 模板的路径(绝对或相对于项目根)

  • autoDocstring . generatedocstringonenter:打开 docstring 后按回车键生成 docstring

  • autoDocstring . includeextendedsummary:在 docstring 中包含扩展摘要部分

  • autoDocstring . Include name:在 docstring 的开头包含函数名

  • autodocstring . startonnewline:摘要占位符前的换行符

  • autodocstring . guesstypes:从类型提示、默认值和变量名推断类型

  • autodocstring . quotes style:文档字符串的引号样式

借助 mustache.js 模板引擎，该扩展还支持定制模板。为了使用自定义模板，您需要创建一个. mustache 文件，并使用 customTemplatePath 配置指定其路径。你可以看看下面这些可以在自定义模板中使用的标签: 7

{{name}} - name of the function
{{summaryPlaceholder}} - [summary] placeholder
{{extendedSummaryPlaceholder}} - [extended_summary] placeholder

Sections
{{#args}} - iterate over function arguments
    {{var}} - variable name
    {{typePlaceholder}} - [type] or guessed type placeholder
    {{descriptionPlaceholder}} - [description] placeholder
{{/args}}

{{#kwargs}} - iterate over function kwargs
    {{var}} - variable name
    {{typePlaceholder}} - [type] or guessed type placeholder
    {{&default}} - default value (& unescapes the variable)
    {{descriptionPlaceholder}} - [description] placeholder
{{/kwargs}}

{{#exceptions}} - iterate over exceptions
    {{type}} - exception type
    {{descriptionPlaceholder}} - [description] placeholder
{{/exceptions}}

{{#yields}} - iterate over yields
    {{typePlaceholder}} - [type] placeholder
    {{descriptionPlaceholder}} - [description] placeholder
{{/yields}}

{{#returns}} - iterate over returns
    {{typePlaceholder}} - [type] placeholder
    {{descriptionPlaceholder}} - [description] placeholder
{{/returns}}

Additional Sections
{{#argsExist}} - display contents if args exist
{{/argsExist}}

{{#kwargsExist}} - display contents if kwargs exist
{{/kwargsExist}}

{{#parametersExist}} - display contents if args or kwargs exist
{{/parametersExist}}

{{#exceptionsExist}} - display contents if exceptions exist
{{/exceptionsExist}}

{{#yieldsExist}} - display contents if returns exist
{{/yieldsExist}}

{{#returnsExist}} - display contents if returns exist
{{/returnsExist}}
{{#placeholder}} - makes contents a placeholder

Python 缩进

这个扩展有助于快速生成 Python 函数的文档字符串。每当您在 Python 上下文中按下回车键时，该扩展将解析您的 Python 文件，直到您的光标所在的位置，并准确定义下一行(或者在悬挂缩进的情况下是两行)应该缩进多少以及靠近的行应该不缩进多少。

在下一节中，我们将从 VS 代码中的代码编辑开始。

代码编辑入门

VS 代码编辑应该从解释什么是智能感知开始。它是各种代码编辑特性的总称，包括代码完成、参数信息、快速信息和成员列表。IntelliSense 功能也有其他名称，如代码完成、内容帮助和代码提示。

VS 代码智能感知是为 JavaScript、TypeScript、JSON、HTML、CSS 和 SCSS 提供的。VS 代码支持任何编程语言的基于单词的完成，但也可以通过安装语言扩展来配置为具有更广泛的智能感知。

自动完成和智能感知

为当前激活的文件夹中的所有文件以及安装在标准位置的 Python 包提供了自动完成和智能感知功能。在编辑过程中，您可以右键单击不同的标识符来利用几个方便的命令: 8

  • 转到定义(F12)从您的代码转移到定义对象的代码。当您操作库时，此命令非常有用。

  • Peek Definition (Alt+F12)与前一个几乎相同，但是直接在编辑器中显示定义(在编辑器窗口中留出空间以避免弄乱任何代码)。按 Escape 关闭 Peek 窗口或使用右上角的 x。

  • 转到声明跳转到代码中声明变量或其他项的位置。

  • Peek 声明类似，但直接在编辑器中显示声明。同样，您可以使用 Escape 或右上角的 x 来关闭 Peek 窗口。

自定义智能感知行为

若要自定义引擎的行为，您应该检查代码分析设置和自动完成设置。您还可以自定义自动完成和智能感知的一般行为，甚至完全禁用这些调谐功能。IntelliCode 为 Python 中的 IntelliSense 提供了一组人工智能辅助功能，例如基于当前代码上下文推断最相关的自动完成。

若要为安装在其他非标准位置的包启用 IntelliSense，请将这些位置添加到设置文件的 python.autoComplete.extraPaths 集合中(默认集合为空)。例如，如果使用 Flask，您可能已经在-app.yaml 中指定的自定义位置安装了 Google App Engine。在这种情况下，您必须以下列方式指定这些位置:

Windows:

"python.autoComplete.extraPaths": [
    "C:/Program Files (x86)/Google/google_appengine",
    "C:/Program Files (x86)/Google/google_appengine/lib/flask-0.12"]

macOS/Linux:

"python.autoComplete.extraPaths": [
    "~/.local/lib/Google/google_appengine",
    "~/.local/lib/Google/google_appengine/lib/flask-0.12" ]

python . autocomplete . add brackets 设置(默认为 false)还定义了在自动完成函数名时，VS 代码是否自动添加括号(())。例如，当您将添加括号设置为 true 时:

  "python.autoComplete.addBrackets": true,

然后编写 import os 后跟 os.getc，您将获得 os.getcwd 的自动完成。选择该自动完成会将 os.getcwd()添加到您的源代码中，并将光标放在括号内。当设置为 false 时，只有 os.getcwd 被添加到文件中。

解决纷争

如果自动完成和智能感知对于自定义模块不起作用，建议检查以下原因:

  • 如果 Python 解释器的路径不正确，请检查 pythonPath 设置，或者在进行更正后重新启动 VS 代码。

  • 如果自定义模块位于非标准位置或者没有使用 pip 安装，请确保将该位置添加到 python.autoComplete.extraPaths 设置中，并重新启动 VS 代码。

终端中的运行选择/线路(REPL)

Python:Run Selection/Line in Python Terminal 命令(Shift+Enter)是获取所选代码或当前行代码(如果没有选择)并在 Python 终端中运行它的最快方法。对于编辑器中的选择，还可以在快捷菜单上访问 Python 终端中的相同运行选择/行命令。

VS 代码基于选择的第一个非空行自动删除缩进，相应地向左移动所有其他行。在终端/REPL 中运行的源代码是累积的，直到终端的当前实例完成。该命令仅在需要时打开 Python 终端；您也可以通过启动 REPL 命令使用 Python 直接启动交互式 REPL 环境。如果您刚刚开始使用 Python:Run Selection/Line in Python Terminal 命令，VS 代码会在环境准备好之前将文本发送到 REPL，在这种情况下，选择或行不会运行。如果遇到这种情况，请在 REPL 完成加载后重试该命令。

格式化

当对行距、缩进、运算符周围的间距等应用特定的规则和约定时，格式化使代码更加用户友好。同时，它并不真正影响代码本身的功能。相反，林挺分析代码中常见的语法、风格和功能错误，以及可能导致错误的非常规编程实践。尽管格式化和林挺之间有一些重叠，但这两种功能是互补的。

Python 扩展支持使用 autopep8(默认)、black 或 yapf 的源代码格式。

常规格式设置

表 2-4 显示了 VS 代码中 Python 代码的一般格式设置:

表 2-4

常规格式设置

|

设置(python.formatting)

|

缺省值

|

描述

|
| --- | --- | --- |
| 供应者 | " autopep " | 指定要使用的格式化程序，可以是“autopep8”、“yapf”或“black”。 |

表 2-5 中的设置主要适用于单个格式化程序。Python 扩展在当前 pythonPath 中查找格式化程序。为了在另一个位置使用格式化程序，请确保在指定的自定义路径设置中指定该位置。

表 2-5

特定于格式化程序的设置

|

格式程序

|

安装步骤

|

参数设置(python.formatting)

|

自定义路径设置(python.formatting)

|
| --- | --- | --- | --- |
| 自动驾驶仪 8 | 管道安装管道 8pip 安装-升级 autopep8 | autopep 8 args | autopep 路径 |
| 黑色(见注释) | pip 安装黑色 | 布莱克 Args | 黑色路径 |
| 耶！耶 | pip 安装 yapf | 雅普法格斯 | yapfPath |

默认情况下，如果 Python 2 环境处于活动状态，则不能安装黑色格式化程序。尝试这样做可能会显示消息“未安装黑色格式化程序。安装？”。如果您尝试安装 black 作为响应，会出现另一条消息，说明“找不到满足 Black 要求的版本。没有为黑色找到匹配的分布。

要解决这个问题并在 Python 2 中使用 Black 格式化程序，首先要在 Python 3 框架中安装 Black。然后将 python.formatting.blackPath 设置设置为该安装位置。使用自定义参数时，命令行上由空格分隔的参数字符串的每个顶级元素必须是 args 列表中的一个单独项。举例说明:

"python.formatting.autopep8Args": ["--max-line-length", "120", "--experimental"],
"python.formatting.yapfArgs": ["--style", "{based_on_style: chromium, indent_width: 20}"],
"python.formatting.blackArgs": ["--line-length", "100"]

格式疑难解答

如果格式化尝试失败，检查表 2-6 中列出的潜在原因。 9

表 2-6

VS 代码格式疑难解答

|

原因

|

解决办法

|
| --- | --- |
| python 解释器的路径不正确。 | 检查 pythonPath 设置。 |
| 当前环境中没有安装格式化程序。 | 打开命令提示符，导航到 pythonPath 设置中指定的位置，并为格式化程序运行 pip install。 |
| 格式化程序的路径不正确。 | 检查适当的 python.formatting. 路径设置的值。 |
| 格式化程序的自定义参数不正确。 | 检查适当的 python.formatting. 路径设置是否不包含参数，以及 python.formatting. Args 是否包含单个顶级参数元素的列表，如" python . formatting . yap fargs ":[-style "、" {based_on_style: chromium，indent_width: 20}"]。 |

如果出现“Black 不支持格式选择”的警告消息，可能的解决方案是使用以下设置来阻止它“[python]”:{ " editor . formaton paste ":false，" editor . formatonsavemode ":" file " }。

重构

Python 扩展包括三个重构命令:提取变量、提取方法和排序导入。

提取变量

提取特定范围内选定文本的所有相似项，并用变量替换它。这种新方法被命名为 newvariableNNN，其中 NNN 代表一个随机数。它通常由以下对象调用:

  • 上下文菜单:右键单击选择并选择提取变量。

  • 命令面板(Ctrl+Shift+P)，然后 Python 重构:提取变量。

  • 为 python . refactorextractavariable 命令分配键盘快捷键。

提取方法

提取当前范围内特定表达式或块的所有相似项，并用方法调用替换它。这种新方法被命名为 newmethodNNN，其中 NNN 代表一个随机数。它通常由以下人员调用:

  • 上下文菜单:右键单击选择并选择提取方法。

  • 命令面板(Ctrl+Shift+P)，然后 Python Refactor: Extract 方法。

  • 为 python.refactorExtractMethod 命令分配键盘快捷键。

  • 将代码重构为方法。

排序导入

排序导入应用排序包将来自同一模块的所有特定导入设置到单个导入语句中，并按字母顺序组织导入语句。它通常由以下对象调用:

  • 在编辑器中右键单击并选择 Sort Imports(不需要选择)。

  • 命令面板(Ctrl+Shift+P)，然后 Python 重构:排序导入。

  • 为 python.sortImports 命令分配键盘快捷键。

  • 排序导入语句。

要排序的自定义应用程序在 python.sortImports.args 设置中指定，其中每个顶级项目(由命令行上的空格分隔)都是数组中的一个项目:

" python.sortImports.args": ["-rc "，"- atomic"]。为了使用自定义的 isort 脚本，最好使用 python.sortImports.path 设置来设置特定的路径。

林挺

林挺不同于前面提到的格式化方法，因为它分析代码如何运行并跟踪错误，而格式化只能重构代码的结构。林挺指出了你的 Python 源代码中的任何语法和风格问题，这在大多数时候有助于你发现和纠正微妙的编程错误或可能导致错误的过时的编码实践。例如，林挺跟踪未初始化或未确定变量的使用，对未定义函数的请求，丢失括号，甚至更突出的问题，如试图重新定义内置类型或函数。

默认情况下，风格和语法代码检测由语言服务器完成。如果您需要第三方 linter 进行额外的问题检测，您可以通过使用 Python: Select Linter 命令和适当的 Linter 轻松启用它们。您当然可以使用 Python: Enable 林挺函数来启用和禁用所有林挺。

启用棉绒

要打开非默认 PyLint 的 Linter，应该打开命令面板(Ctrl+Shift+P)并选择 Python: Select Linter 命令。该命令将“python . linting .Enabled”:true 添加到您的设置中，其中是所选 linter 的名称。您还可以查看特定的 linter 以获得详细信息，并启用 linter 提示以在您的编程环境中安装所需的包。

如果您使用的是全局环境，而 VS 代码运行效率不高，linter 安装可能会失败。在这种情况下，要么运行 VS 代码提升，要么手动运行 Python 包管理器，在相同环境的提升命令提示符下安装 linter:例如， sudo pip3 install pylint (对于 macOS 和 Linux)或 pip install pylint (对于 Windows)。

禁用林挺

您可以使用 Python: Enable 林挺命令禁用所有 Python 林挺，该命令会显示包含当前林挺状态的下拉列表，并显示打开或关闭 Python 林挺的选项。

运行林挺

要高效运行林挺，您需要:

  • 默认情况下，林挺会在您保存文件时运行。

  • 打开命令面板(Ctrl+Shift+P)，然后输入并点击 Python: Run 林挺。

如果您遇到任何问题，它们都会显示在问题面板中，并在代码编辑器中显示为下划线。

林挺设置

本节列出了林挺的一般和特定设置。您可以自由地将任何设置添加到 user settings.json 文件中(通过文件➤首选项➤设置命令 Ctrl+，)。您还可以参考用户和工作区设置，了解如何在所有启用的 linters 上更改林挺行为。您可以在表格 2-7 : 10 中修改以下设置

表 2-7

林挺设置

|

特征

|

设置(python.linting)

|

缺省值

|
| --- | --- | --- |
| 林挺概况 | 使能够 | 真实的 |
| 文件保存时的林挺 | 林顿储蓄 | 真实的 |
| 林挺消息的最大数量 | maxNumberOfProblems | One hundred |
| 排除文件和文件夹模式 | ignorePatterns | [.]。vscode/*。py "，" /站点包/**/。py"] |

您也可以通过单击启用林挺命令，通过 python 轻松更改 python.linting.enabled。但是，当启用 lintOnSave 时，您可能还希望启用 generic files.autoSave 选项(保存/自动保存)。当你编写代码时，这个函数在你的代码中提供常规的林挺反馈。

特定棉绒

表 2-8 列出了可用的 Python linters 及其基本设置。一定要注意，默认情况下只有 Pylint 是启用的。 11

表 2-8

可用的 python 衬里

|

棉绒

|

包名

|

默认状态

|

真/假启用设置(python.linting)

|

参数设置(python.linting)

|

自定义路径设置(python.linting)

|
| --- | --- | --- | --- | --- | --- |
| Pylint (默认) | 皮拉 | 使能够 | pylintEnabled | 皮林塔格斯 | pylintPath |
| 薄片 8 | 薄片 8 | 有缺陷的 | 启用薄片 8 | flake8Args | 薄片 8 路径 |
| mypi | mypi | 有缺陷的 | mypyEnabled | mypyArgs | mypyPath |
| pydocstyle | pydocstyle | 有缺陷的 | pydocstyleEnabled | pydocstyleArgs | pydocstylePath |
| pycodes style(pep 8) | pycodes style | 有缺陷的 | pycodestyleEnabled | pycodestyleArgs | pycodestylePath |
| 探矿者 | 探矿者 | 有缺陷的 | 有前景的 | 探矿者 | 探矿路径 |
| 血浆 | 皮拉玛 | 有缺陷的 | pylamaEnabled | 皮拉马尔格斯 | pylamaPath |
| 强盗 | 土匪 | 有缺陷的 | banditEnabled | banditArgs | banditPath |

要选择不同的 linter，可以通过 Python: Select Linter 命令来完成。您也可以手动编辑您的设置来启用多个棉条。同时，请记住，应用 Select Linter 命令将会覆盖这些编辑。在每个 linter 的适当参数设置中预先确定了自定义参数。命令行上由空格分隔的参数字符串的每个顶级元素都应该是 arguments (args)列表中的一个单独项目。但是，如果顶级元素是由引号或大括号括起来的单个值，即使值本身有空格，它在列表中仍然是单个项目。

通常不需要定制路径，因为 Python 扩展具有基于所应用的 Python 解释器的 linter 路径。要使用不同版本的 linter，请在指定的自定义路径设置中记下其路径。例如，如果您选择的解释器是一个虚拟环境，但是您想要使用一个安装在全局环境中的 linter，那么您必须设置适当的路径设置来指向全局环境的 linter。

派林特

Pylint 消息属于表 2-9 中列出的类型，并标明了到 VS 代码类别的映射。如果要更改映射，可以修改设置。 12

表 2-9

带有 VS 代码类别映射的 Pylint 类别

|

Pylint 类别

|

描述

|

VS 代码类别映射

|

适用设置(python.linting)

|
| --- | --- | --- | --- |
| 公约(C) | 违反编程标准 | 信息(绿色下划线) | pylintcategoryseverity . conventi on |
| 重构(R) | 糟糕的代码味道 | 提示(灯泡) | pylintcategoryseverity . refactor |
| 警告(W) | Python 特有的问题 | 警告 | pylintCategorySeverity.warning |
| 错误(E) | 可能的代码错误 | 错误(红色下划线) | pylintCategorySeverity.error |
| 致命的 | 进一步处理 pylint 时出现错误 | 错误 | pylintCategorySeverity.fatal |

默认 Pylint 规则

默认情况下，VS 代码中的 Python 被定制为应用与大多数 Python 开发者相关的一组三个主要林挺规则: 13

  • 启用所有错误(E)和致命(F)消息。

  • 禁用所有约定(C)并重构(R)消息

  • 禁用所有警告(W)消息，以下消息除外:

    • 不可达(W0101):不可达代码

    • 重复键(W0109):字典中的重复键%r

    • 不必要的分号(W0301):不必要的分号

    • global-variable-not-assigned(w 0602):对%r 使用 global，但没有完成赋值

    • 未使用变量(W0612):未使用变量%r

    • binary-op-exception (W0711):要捕获的异常是二进制“%s”操作的结果

    • 格式字符串错误(W1302):无效的格式字符串

    • 字符串中的异常反斜杠(W1401):字符串中的异常反斜杠

    • 错误的打开模式(W1501): "%s "不是有效的打开模式

这些规则是通过传递给 Pylint 的以下默认参数激活的:

--disable=all, --enable=F, E, unreachable,duplicate-key,unnecessary-semicolon,global-variable-not-assigned,unused-variable,binary-op-exception,bad-format-string,anomalous-backslash-in-string,bad-open-mode

每次 python . linting . pylintuseminimalcheckers 设置为 true 时，都会传递这些项目。但是如果在 pylintArgs 中指定一个值或者使用一个 Pylint 配置文件，那么 pylintUseMinimalCheckers 将总是被设置为 false。

此外，命令行参数可以用来加载 Pylint 插件，比如 Django 的插件:

"python.linting.pylintArgs": ["--load-plugins", "pylint_django"]

其他选项也可以在 pylintrc 或中指定。工作区文件夹中的 pylintrc 选项文件，如 Pylint 命令行参数所述。

林挺故障排除

在表 2-10 中，列出了一些基本错误信息及其可能的解决方案。 14

表 2-10

林挺问题疑难解答

|

出错信息

|

原因

|

解决办法

|
| --- | --- | --- |
| ...无法导入<module_name></module_name> | Python 扩展使用了错误版本的 Pylint。 | 确保pythonPath设置指向安装 Pylint 的有效 Python 安装。还可以尝试为正在使用的 Python 解释器将python.linting.pylintPath设置为合适的 Pylint 版本。 |
| 林挺用失败了... | Python 解释器的路径不正确。 | 检查pythonPath设置。 |
|   | linter 尚未安装在当前的 Python 环境中。 | 打开一个命令窗口，在pythonPath设置中导航到 Python 解释器的位置，并为 linter 运行pip install。 |
|   | 到棉绒的路径不正确。 | 确保棉绒的适当python.linting.<linter>Path设置正确。 |
|   | 自定义参数定义不正确。 | 检查适当的python.linting.<linter>Args设置，并且该设置的值是由空格分隔的参数元素的列表。比如"python.linting.pylintPath": "pylint --load-plugins pylint_django"不正确。正确的语法是"python.linting.pylintArgs": ["--load-plugins", "pylint_django"] |

排除故障

调试是指修复代码并消除潜在的错误。Python 是一种语法类型的语言，这意味着代码编辑器的角色在调试中变得至关重要，因为一个好的编辑器可以帮助您立即找到代码中的问题。

VS 代码在两个方面处理调试。一方面，有 VS 代码的一般调试特性，比如检查变量、设置断点和其他通常依赖于语言的特性；另一方面，调试需要考虑特定于 Python 的调试配置，包括特定的应用程序类型和远程调试。

初始化配置

为了初始化调试配置，您必须首先在侧边栏中选择 Run 视图，然后点击 Run 图标。配置决定调试会话期间 VS 代码的行为，并在 launch.json 文件中定义，该文件存储在工作区的. VS Code 文件夹中。若要更改调试配置，您需要确保代码存储在文件夹中。

如果您还没有定义任何配置，您可以看到一个运行和调试按钮以及一个创建配置(launch.json)文件的链接:调试工具栏设置命令。要使用 Python 配置生成 launch.json 文件，请完成以下步骤:首先，单击创建 launch.json 文件链接或使用运行➤打开配置菜单命令。命令面板中将显示一个配置菜单，允许您为打开的文件选择所需的调试配置类型。接下来，在出现的选择调试配置菜单中，选择 Python 文件。调试配置菜单。

请记住，通过调试面板、F5 或在不存在配置时运行➤启动调试来启动调试会话也将调出调试配置菜单，但不会创建 launch.json 文件。

然后，Python 扩展生成并打开一个 launch.json 文件，该文件具有基于您之前选择的内容的预定义配置，在本例中为 Python 文件。您可以自定义这些配置(例如，通过添加参数)，也可以添加自定义配置。

附加配置

默认情况下，VS 代码只显示 Python 扩展提供的最常用的配置。通过激活列表和 launch.json 编辑器中显示的 Add Configuration 命令，可以选择 launch.json 中包含的其他配置。当您使用该命令时，VS 代码会提示您所有可用配置的列表(向下滚动以查看所有 Python 选项):

  • 添加新的 Python 调试配置

  • 选择 Node.js: Gulp 任务会产生以下结果:添加了一个配置

  • 有关所有这些配置的详细信息，请参见调试特定的应用程序类型

调试期间，状态栏会显示当前配置和当前调试解释器。选择配置会调出一个列表，您可以从中选择不同的配置。通常，调试器使用与 VS 代码的其他特性相同的 python.pythonPath 工作空间设置。要专门为调试应用不同的解释器，您需要为适用的调试器配置在 launch.json 中设置 python 的值。或者，您可以在状态栏上选择指定的解释器来选择不同的解释器。

基本调试

开始调试 Python 文件的最简单方法是使用运行视图并单击运行和调试图标。如果之前没有进行任何配置，您将看到一个调试选项列表。您只需要选择适当的选项来快速开始调试您的代码。

两个最常用的选项是 Python 文件配置，用于操作当前打开的 Python 文件，以及 Attach to use with Process ID，用于将调试器添加到已经运行的进程中。添加配置后，可以从下拉列表中选择它，并使用 Start Debugging 按钮启动。此外，您还可以添加其他设置，如标准配置中不包含的参数: 15

  • 名称:提供出现在 VS 代码下拉列表中的调试配置的名称。

  • type: 标识要使用的调试器的类型；对于 Python 代码，将此设置保留为 Python。

  • 请求:指定开始调试的模式:

    • 启动:在程序中指定的文件上启动调试器

    • 附加:将调试器附加到已经运行的进程。有关示例，请参见远程调试。

    • 程序:提供 Python 程序入口模块的全限定路径。默认配置中经常使用的值${file}使用编辑器中当前活动的文件。通过指定一个特定的启动文件，无论打开哪个文件，您都可以确保用相同的入口点启动程序。例如:

      "program": "/Users/Me/Projects/PokemonGo-Bot/pokemongo_bot/event_handlers/__init__.py",

  • python: 指向用于调试的 python 解释器的完整路径。

    如果未确定，此设置默认为 python.pythonPath 设置中标识的解释器，这相当于使用值${config:python.pythonPath}。要应用不同的解释器，请在调试配置的 python 属性中标识其路径。

    作为一个选项，您还可以使用在每个平台上定义的自定义环境变量来包含要使用的 Python 解释器的完整路径，这样就不需要其他文件夹路径。一旦需要向 Python 解释器传递参数，就可以使用 pythonArgs 属性。

  • pythonArgs: 使用语法" pythonArgs": [" < arg 1 >"，"< arg 2 > "]指定要传递给 Python 解释器的参数。

  • args: 指定要传递给 Python 程序的参数。由空格分隔的参数字符串的每个元素都必须包含在引号中，例如:

"args": ["--quiet", "--no-repeat", "--port", "1593"],

  • stopOnEntry: 设置为 true 时，在被调试程序的第一行中断调试器。如果省略(默认情况下)或设置为 false，调试器将程序运行到第一个断点。

  • console: Specifies how program output is presented as long as the defaults for redirectOutput are not edited. Most widely used console values are listed in Table 2-11.

    表 2-11

    输出值

    |

    价值

    |

    显示输出的位置

    |
    | --- | --- |
    | "内部控制台" | VS 代码调试控制台。如果 redirectOutput 设置为 False，则不显示任何输出。 |
    | "集成终端" | VS 代码集成终端。如果 redirectOutput 设置为 True，调试控制台中也会显示输出。 |
    | "外部终端" | 单独的控制台窗口。如果 redirectOutput 设置为 True，调试控制台中也会显示输出。 |

  • cwd: Specifies the current working directory for the debugger, which is the basic folder for any relative paths used in code. Once omitted, defaults to ${workspaceFolder} (the folder open in VS Code). As an example, say ${workspaceFolder} contains a py_code folder containing app.py, and a data folder containing salaries.csv. If you start the debugger on py_code/app.py, then the relative paths to the data file vary depending on the value of cwd (Table 2-12).16

    表 2-12

    日期文件路径

    |

    粗木质残体

    |

    数据文件的相对路径

    |
    | --- | --- |
    | 省略或${workspaceFolder} | 数据/薪水. csv |
    | $ {工作空间文件夹}/py_code | ../data/salary . CSV |
    | ＄{ workspace folder }/data | 薪水. csv |

  • redirectOutput: 设置为 true 时(默认为 internalConsole)，使调试器将程序的所有输出打印到 VS 代码调试输出窗口中。如果设置为 false(对于 integratedTerminal 和 externalTerminal，默认情况下)，则调试器输出窗口中不显示程序输出。使用“console”:“integrated terminal”或“console”:“external terminal”时，通常会禁用此选项，因为不需要在调试控制台中复制输出。

  • justMyCode: 当省略或设置为 true(默认)时，只对用户编写的代码进行调试。设置为 false 也会启用标准库函数的调试。

  • Django: 当设置为 true 时，激活特定于 Django web 框架的调试特性。

  • sudo: 当设置为 true 并与“控制台”一起使用时:“externalTerminal”，允许调试需要提升的应用程序。应用外部控制台是捕获密码所必需的。

  • pyramid: 设置为 true 时，确保使用必要的命令行 pserve 命令启动 pyramid 应用程序。

  • env: 为调试器进程设置系统环境变量之外的可选环境变量，调试器始终会继承这些变量。这些变量的值必须以字符串形式输入。

  • envFile: 包含环境变量定义的文件的可选路径。

  • gevent: 如果设置为 true，则启用 gevent 猴子修补代码的调试。

条件断点

断点也可以设置为基于表达式、命中次数或两者的组合来触发。Python 扩展支持整数的命中计数，以及前面带有==，>，> =， 5 的整数。

在代码中调用断点

在 Python 代码中，您可以在调试会话期间想要暂停调试器的任何时候调用 debugpy.breakpoint()。

断点验证

Python 扩展自动检测设置在不可执行行上的断点，例如 pass 语句或多行语句的中间。在这种情况下，运行调试器会将断点移动到最近的有效行，以确保代码执行在该点停止。

调试特定的应用程序类型

对于一般的应用程序类型，配置下拉菜单有各种不同的选项(表 2-13 )。 17

表 2-13

Python 的流行配置描述

|

配置

|

描述

|
| --- | --- |
| 附上 | 请参见上一节中的远程调试。 |
| Django | 指定" program ":" $ { workspace folder }/manage . py "，" args": ["runserver"]。还添加了“Django”:true 以启用 Django HTML 模板的调试。 |
| 瓶 | 请参见烧瓶调试。 |
| -风 | 将“ge vent”:true 添加到标准集成终端配置中。 |
| 金字塔 | 移除程序，添加" args ":[" $ { workspace folder }/development . ini "]，添加" jinja": true 以启用模板调试，并添加" pyramid": true 以确保用必要的 pserve 命令启动程序。 |
| Scrapy | 指定“module”:“scrapy”并添加“args”:[“crawl”，“specs”，“-o”，“bikes . JSON”]。 |
| 沃森 | 指定" program ":" $ { workspace folder }/console . py "和" args": ["dev "，" runserver "，"- noreload=True"]。 |

摘要

在本章中，我们从 Python 开发者的角度讲述了 VS 代码中的几个编程基础，比如林挺、调试和代码格式化。

在下一章中，我们将更深入地研究 Python 开发的 VS 代码，并继续其他代码范例和技巧。

三、设置环境和测试

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 代码使用以下优先顺序:

  1. launch.json 中所选调试配置的 pythonPath 属性

  2. 工作空间 settings.json 中的 python.pythonPath 设置

  3. 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 显示了使用代码单元格时支持的一些附加命令和键盘快捷键。 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。

四、使用 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 函数的路径: 1

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”的配置: 2

{
    "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 内置的日期过滤器和时间过滤器。然后，代码只需要以如下方式传递日期时间值: 3

<!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 中，在

<title>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></title>

同样在 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 库的一个优点是它提出了一种专门用于将数据集分成训练和测试数据的方法: 5

  • 从 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 编码的理解，并揭开一些新的话题。

五、使用容器和 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 月， 1 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。

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

  1. 为您的函数项目选择一种语言:使用 Python。

  2. 选择 Python 集成来创建虚拟环境:选择 Python 解释器的位置。如果没有显示位置，请编写 Python 二进制文件的完整路径。

  3. 为项目的第一个功能选择一个模板:选择 HTTP trigger。

  4. 提供一个函数名:键入 HttpExample。

  5. 说到授权级别:选择匿名，这使得每个人都可以调用您的函数端点。

  6. 设置打开项目的方式:选择添加到工作区。

使用这些数据，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 按钮。

您还需要提供以下信息:

  1. 选择文件夹:从您的工作区中找到一个文件夹，或者浏览到一个包含您的功能应用程序的文件夹。如果您已经运行了有效的功能应用程序，您将看不到此信息。

  2. 选择订阅:选择要申请的订阅。如果您只有一份套餐，您将看不到此内容。

  3. 在 Azure 中选择功能 App:选择+新建功能 App。

  4. 为函数 app 创建一个全局唯一的名称:该名称必须在 URL 路径中有效，同时在 Azure 函数中也是唯一的。

  5. 选择一个运行时:选择您已经激活的 Python 版本在本地运行。建议使用 python - version 命令来检查您的版本。

  6. 为新资源选择一个地点:选择一个离你更近的地区总是更好。

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

  • 资源组，也是相关资源的逻辑容器。

  • 一个标准的 Azure 存储帐户，其中包含关于您的项目的所有信息。

  • 一个消费计划，为你的无服务器功能 app 确定主机。

  • 一个功能应用程序，它定义了执行您的功能代码的环境，并让您的组功能作为一个逻辑单元，以便于管理和共享同一托管计划内的资源。

  • 应用洞察用于记录您的无服务器功能的例程。

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

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

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

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

  1. 在 VS 代码中，按 F1 激活命令选项板。在命令面板中，查找 Azure Functions: Open in the portal。选择您的功能应用，并按 Enter 键以查看 Azure 门户中打开的功能应用页面。

  2. 在“概述”选项卡中，查找资源组旁边的命名链接。从功能应用程序页面中选择要删除的资源组。进入“资源组”页面查看包含的资源列表，并单击需要删除的资源。请记住，删除可能需要一些时间(不超过几分钟)。完成后，会出现几秒钟的通知。您也可以单击页面顶部的钟形图标再次查看通知。

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 文件中启用，看起来是这样的: 2

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 数组，通常看起来应该是: 4

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 环境变量: 5

  • 对于 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 代码开发容器映像: 6

{
  "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:7

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

"
]

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

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

"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 应用程序。

posted @ 2024-08-09 17:45  绝不原创的飞龙  阅读(5)  评论(0)  编辑  收藏  举报