ShowMeAI-人工智能工具笔记-五-

ShowMeAI 人工智能工具笔记（五）

Hugging Face速成指南！一遍搞定NLP任务中最常用的功能板块＜实战教程系列＞ - P7：L7- 微调(Fine Tuning) - ShowMeAI - BV1cF411v7kC

另一个我们如何微调自己模型的看法。这非常重要，我已经准备了一些代码，我会大致介绍，但还有很好的文档可以参考。因此，我们可以访问这个文档页面，你也可以在colab中打开它。

无论是使用Pytorch还是TensorFlow代码，这真的很有帮助。因此，我鼓励你查看一下。但现在让我们快速浏览一下。基本上，你需要做五个步骤。在这个例子中，适用于Pytorch。我们必须准备我们的数据集，例如，从Cv文件或其他地方加载。

然后我们必须加载一个预训练的分词器，然后用我们的数据集调用它。然后我们得到编码或tokens。😊。

然后我们必须根据这些编码构建一个pytorch数据集。如果你不知道什么是pytorch数据集，我这里会有一个链接来解释这个。然后我们加载一个预训练模型，然后可以加载Hugging Face训练器并进行训练。这抽象了很多事情，或者我们可以使用一个本地的或普通的pytorch训练管道，就像我们其他pytorch代码中一样。

是的，这就是我们必须做的。让我们很快浏览一下。在这个案例中，我们定义我们的基础模型名称。因此我们想从这个distilbert面部uncased版本开始。例如，在这个案例中，不是微调的那个。所以仅仅是这个。然后步骤1。我们准备数据。我们写一个有用的函数来创建文本和标签。

从实际文本中，这里我们下载了一些数据集并放入我们的文件夹。因此，我已经在这里做了，是的，这可以在这个网站上获得，包含电影评论，因此我们希望在电影评论上微调我们的模型，以进行情感分类。因此，在这里我们使用我们的助手函数创建训练文本和训练标签，我们还进行训练测试拆分，以获得验证文本和标签，然后下一步我们创建或定义一个Pytorch数据集。

这继承自pytorch数据集，因此torch U数据我们导入数据，然后在这里定义它。因此，我有一个教程来解释这个是如何工作的，但基本上它需要编码。

标签将被存储在这里。所以，是的，这需要编码。因此，对于编码，我们需要一个分词器。再一次，我们使用这个来自预训练函数的模型名称，在这个案例中，由于我们知道使用的是distill bird模型，我们可以使用这个类。所以记住，我们之前使用的是一个通用分词器，这个自动分词器类。

在这里，我们使用了一个更具体的示例。因此，我们使用了远程鸟分词器快速处理，然后将其应用于训练、验证和测试集，并获取编码。然后，我们将它们放入数据集中，并创建 Pytorch 数据集，接着导入一个训练器和训练参数。

这在 Trans us 库中是可用的，我们可以设置它来创建参数。例如，在这里，我们指定训练纪元的数量、输出目录、学习率和其他参数，然后再次从具体模型类创建我们的模型，使用这个 dot from pretrained 函数，然后设置这个训练器，提供模型、训练参数、训练集和验证集，然后我们只需调用训练器的 train，这将为我们完成所有训练，之后你可以在测试数据集上测试它，然后你就拥有一个微调的模型。

是的，这基本上就是你所知道的，然后我还想告诉你，如果你想手动操作并获得更多灵活性，可以使用普通的 Pytht 训练循环。为此，我们使用数据加载器并需要一个优化器。在这种情况下。

我们使用了来自 Transformers 库的优化器。然后在这里我们指定了设备，再次创建这个模型。我们将其推送到设备并设置为训练模式，然后创建数据加载器和优化器，接着进行典型的训练循环。我们说，对于每个纪元和训练加载器中的每个批次，我们执行我们通常做的事情。我们说优化器零梯度，如果需要也将其推送到设备。

然后我们调用模型，使用这个计算损失，在这种情况下，它已经包含在输出中，因此我们可以这样访问损失。然后我们调用损失的反向传播和优化器步骤，进行迭代，之后我们可以将模型设置为。

评估模式再次启用。是的，这就是我们在原生 Pythtorch 代码中执行的方式。这基本上就是我们如何进行微调，然后可以微调我们自己的模型。之后，如果需要，你还可以将它们上传到 Hugging Face 模型中心。所以我觉得这非常酷，今天我想展示的就是这些，希望你喜欢这个教程，也期待在下一个视频中见到你。

😊。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和 Terminal 讲解得清清楚楚。学完新手也能玩转！ - P11：11）在 Jupyter Notebook 中使用终端命令 - ShowMeAI - BV1yv411379J

好的，我们继续吧。我们在笔记本里还有几件事要做。然后我们将进行一次关于在 Jupyter 笔记本外部可以做的其他事情的 tour。接着我会给你展示一些扩展功能，然后我们就完成了。所以我们快到了。

好的，所以运行 bash 或终端。

这里的命令。关于 Jupyter 笔记本的一件好事是，即使我们在这里运行 Python，Jupyter 笔记本也允许你运行 bash 命令。所以举个例子，即使这个 LS 是一个 bash 命令，它也不需要我即将展示的这种特殊语法，也就是感叹号。所以通常来说。

如果你运行普通的 bash 或终端命令，你将使用这个感叹号告诉 Jupyter 笔记本你想要运行一个 bash 命令。所以假设我们想要创建一个目录。我们想要创建一个测试目录，类似这样的。

现在如果我运行 LS。

你会看到我们刚刚创建了一个新的测试目录。如果我回到我们的 Jupyter 笔记本主窗口，你会看到这里是我们的测试目录。所以我们能够在 Jupyter 笔记本中运行一个 batchsh 命令。如果需要安装新包，比如说，你也可以这样做。

比如说你想安装数据可视化库 Cborn。你可以在 Jupyter 笔记本里直接做到这一点。😊。

虽然你也可以直接跳回终端去做这个。所以，你知道，你不一定要在这里做这个，但。

就这样。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和 Terminal 讲解得清清楚楚。学完新手也能玩转！ - P3：3）安装 Python 和 Jupyter Notebook - ShowMeAI - BV1yv411379J

好吧，首先，无论何时开始使用 Jupyter 笔记本，我们需要安装 Python 和 Jupyter。如果你已经安装了 Python 和 Jupyter，可以跳过这一步。如果你当前不想在电脑上安装任何东西，可以使用 Google Colab。

所以 Google Colab 有点像云端的 Jupyter 笔记本。你可以直接在浏览器中运行它们。它们不会完全与 Jupyter 笔记本相同。因此，我们在这个教程中讲到的一些内容可能不完全相同。！

但这是一种快速启动代码笔记本的好方法。你知道，这基本上是相同的概念。你有文本，还有代码，并且可以与人分享。所以这是完全相同的概念。一些具体细节会稍有不同。

但是如果你不想在电脑上安装 Jupyter，或者由于某种原因无法安装，那么可以自由使用 Google Colab。我觉得这是一个很好的资源。😊！

但是，对于那些在电脑上安装 Python 和 Jupyter 的我们来说，我们来看看 Miniconda。因此，我推荐通过 Miniconda 安装 Python 吗？

你在使用 Python 时所用的各种数据科学包。那么，什么是 Minconda 呢？Minconda 附带 Python，同时也包括这个方便的 Conda 工具。现在，Conda 用于安装像 pandas、Jupyter 笔记本以及你需要安装的其他 Python 库。

Conda 也用于创建虚拟环境，虚拟环境是将你的 Python 安装和包封装到一个与主 Python 安装隔离的目录中的最佳实践之一。无论如何，如果你想，可以自由地进行更多研究。

我建议你为你的系统安装正确版本的 Python，安装 Python 3.7 版本。大多数人现在使用 Python 3.7，除非你的公司特别使用 Python 2.7，那你可以安装它。所以安装适用于 Python 3 的 Miniconda，然后在安装完成后。

让我们跳到终端，或者 bash，我在使用 Zsh。如果你在 Windows 上，可以使用命令提示符。所以，好吧，我们要做的是，我喜欢通过创建新的虚拟环境来开始每个新项目和新教程视频。

所以我们将创建一个漂亮的小地方来安装 Jupyter，同时我也会安装 pandas，因为我想展示一下 pandas 数据框在 Jupyter 中的样子。所以，😊，让我们用 Conda 创建一个新的虚拟环境，我要给它命名。

我现在就把它命名为Jupiter。我可以在创建这个新虚拟环境时立即列出我想安装的包。所以我想安装Jupiter。我想安装pandas。我想这就是全部了。

所以我会创建这个名为😊，Jupiter的虚拟环境，这个-n标志代表环境的名称。我将把Python包Jupiter和pandas安装到这个虚拟环境中，并且它也会安装所有这些Jupiter和pandas的依赖项。

这些必须安装才能正常工作。所以它问我是否想继续。我会直接输入“yes”来确认。这将开始安装所有内容，等安装完成后我会回来。好的，看起来一切都成功安装了，Conda非常友好地给我们这个小块来激活环境。使用Conda activate Jupyter。所以我会继续这样做，这样我们就可以使用它。

我会很快展示给你。如果我现在输入which Python，它会告诉我当前使用的Python版本。如果我运行Python。😊。我当前使用的版本在Anaconda 3的bin目录下。现在，如果我激活我的虚拟环境，然后输入which Python。

你会看到我现在使用的是一个完全不同的Python版本。这就是虚拟环境的全部意义。我们把安装内容包裹在这个新文件夹里，这样如果需要在电脑上同时有多个安装，我们就能做到。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和 Terminal 讲解得清清楚楚。学完新手也能玩转！ - P7：7）其他 Notebook 功能 - ShowMeAI - BV1yv411379J

好的，让我们快速了解一下我们可以在 Jupyter Notebook 中做的一些其他事情。我会很快给你展示的事情之一是。折叠。折叠单元格。所以假设我说，你知道的，对于值在范围 100 内。让我们打印值。好吧。这会产生一个非常长的输出，对吧？突然间，我们的笔记本是。

如果我为 10 这样做，它会变得更加明显。哦。Jupyter Notebook 已经为我折叠了它。所以这实际上有点削弱了我想给你展示的内容。但是请注意，如果我们打印出从 0 到 999 的所有值。我们的 Jupyter Notebook 现在非常巨大。我们必须一直滚动到最下面。😊，所以。

Jupyter Notebook 有一个帮助这个的功能是你可以点击这里的侧边栏，点击这个。它会将这个单元格折叠。变成一个较小的滚动版本，它不占用整个笔记本。所以这非常有帮助。所以我可以继续对上面的这个 du 部分做同样的事情。把它变得小一点。这是非常方便的事情。让我们上去看看。

菜单栏。这些按钮在这里，所以。你有正常的保存按钮，保存和检查点。你有这个加号按钮，它是插入单元格在下面，所以我们可以在这里使用。 我喜欢使用 B。B。快捷键。所以你只需在你的计算机上，或者在你的键盘上按下字母 B。无论你在哪里。所以我想这里有两种不同的模式，我们应该快速讨论一下。

其中一个是文本输入模式，比如打印 hello world。当这里的颜色是绿色时，这告诉你你正在输入文本或代码。如果你单击单元格本身，那就把你放入这种主执行模式，在这里你可以使用键盘快捷键，比如字母 X 删除单元格，或字母 B 插入单元格在下面。B 是下面，A 是上面。好了，回到工具栏。

你可以剪切选定的单元格。你可以复制它们，可以粘贴它们。你可以上下移动单元格。所以如果我点击这个单元格，然后点击这个按钮。那就把它向上移动。这个把它向下移动。你可以运行一个单元格。你可以打断内核。打断内核。我的意思是，让我们练习打断内核。

所以，打断内核。假设我创建一个无限的 while 循环，我做一些愚蠢的事情，比如这样。这真的很愚蠢。而且，你知道的，打印 1。为了。让我们看看。只是为了不小心崩溃内核。我会说 time.dot.sleep 0.2，这样它就。好了，来了。这是永远不会停止的。这总是。

这个将一直运行到时间的尽头，或者至少在计算机存在的时间内。或者只要我的电池还在。那么我该怎么做，怎么停止这个呢？你可以在这里点击这个小停止按钮。中断内核或内核中断，然后我们来点击一下。好了。

让我们向下滚动看看发生了什么。你会发现，基本上，它做的是一个键盘中断。它说，嘿，你知道吗，Colel。不管你在做什么，我们想要停止你。我们想要打断你。你应该停止你正在做的事情。所以在这个例子中，我创建了一个无限循环。

这里有一个无限的循环。我们可以通过那个内核中断来停止它。好的。这次是重启内核，就像我们之前做的内核重启一样。然后这个。重启内核，然后重新运行整个笔记本。所以你会注意到在这里单元格下方，我们有运行单元、运行全部、运行以下所有内容。

这些都是执行你笔记本的不同选项。你知道，如果你想的话。你可以进来。然后从头到尾运行所有单元。如果你有一个想要完整运行的工作流。例如，如果你不在进行，嗯，例如，探索性数据分析。在分析中来回进行更多的操作。好的。

然后我们看到的这个下拉单元，它将单元从Markdown更改为代码。所以如果我将这个单元更改为代码，那么突然之间它就没什么意义了，因为这不是Python代码。我将把它改回Markdown。然后再执行一次，这样它就会格式化得很好。可以将这个单元从代码改为Markdown，你知道的。

它可以运行，但这不是我们想要的。我们希望它是一个代码单元。因为这里有Python代码。好吧，就这样。让我们看看这个最后的按钮。打开命令面板。

所以如果你点击这个，那么你就可以访问一堆不同的命令。太多了，无法一一阅读。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P12：12）Jupyter Notebook魔术命令 - ShowMeAI - BV1yv411379J

好吧，那么在我们保存并退出笔记本之前，我要给你展示的最后一件事是魔术命令。现在，这是个很酷的名字。魔术命令让你感觉非常强大，确实如此。因为这些命令非常酷，所以。😊。

我会，看看。让我复制这个链接。或者其实。如果你只是谷歌一下Jupyter魔术命令。

应该在这里的顶部弹出，内置的魔术命令。

所以这些都是你在标准Python中无法做到的事情。

在Jupyter笔记本中。所以，例如，让我们向下滚动。

有一个很酷的，叫debug。所以。Debug，例如，假设我们让某段代码崩溃。

所以也许我会说，你知道，在这个单元中，假设x等于。Hello world。然后我们可能会说y等于true。也许如果y，那么我们尝试z等于1除以0。让我们，打破这个代码。

所以我们运行这个。这会崩溃。让我们输入debug，好吗，因为我们想调试我们的代码。这样我们就能在代码崩溃的执行点进入这个单元。如果我打印出y，比如说。那么你会看到y为真。也许我想尝试z等于1除以0。你会看到我们得到了零除错误。

所以你能够直接进入代码崩溃的地方，使用这个方便的Dbug魔术命令。现在，这里有很多其他魔术命令。

例如，你可以保存Jupyter笔记本的各个部分。你可以改变笔记本的运行方式，各种有趣的东西。你可以查看你运行过的历史记录。各种酷炫的东西。我建议至少浏览一下这些，以便在需要时能使用它们。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P13：13）Notebook之外的其他功能 - ShowMeAI - BV1yv411379J

未来。好吧，让我们保存这个笔记本。所以我会命令S保存笔记本。让我们关闭它。我会先关闭它。

我会删除这个。测试目录是在里面创建的。

让我们在这里展示一些其他内容，然后我会给你一些资源，我们就结束了。好吧，如果你到右边这个新按钮下面去，你会注意到我们在其他选项下有一个文本文件和一个终端。所以如果你想在Jupyter笔记本中运行终端，你可以这样做。

在我的情况下，你会注意到这看起来非常类似于我在这里的终端。所以它正在运行Zish，所以我可以，你知道，我可以使用LS命令打印出这里所有的目录。

如果我想的话，如果我使用git进行版本控制，我可以在这个终端中做那样的事情或其他任何我想做的事情。所以我会退出这个。你会注意到这个现在已经关闭了。

在运行中，没有终端在运行，因为我已经退出了，如果我们让它保持运行。让我们保持这个打开一秒钟。然后刷新。这样你就会看到我们有一个终端在运行。现在。我会关闭它。

这对我们来说就结束了。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P16：16）结论与致谢 - ShowMeAI - BV1yv411379J

有了这些，我认为你已经为使用Jupyter Notebook奠定了坚实的基础。我希望你觉得这个教程很有价值。我希望你也能觉得其他数据科学项目的教程有价值。祝你学习愉快，我们将在未来的教程中再见。好了，祝好运。😊

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P2：2）Jupyter Notebook示例 - ShowMeAI - BV1yv411379J

我将把它拖到这里。我有一个，这是一个Github代码库，里面有一些有趣的Jupyter Notebook画廊。如果你对Jupyter Notebook的用途感到好奇。那么，答案是它们可以用于你可能想用数据和Python做的任何事情。具体来说，这个人，或者我想这可能是由许多人汇编的。

😊。

他们在这里汇总了许多不同的笔记本。让我们看看，我们有一些通用的Python编程和科学计算。我将滚动到我们学习统计学和概率的地方。让我们来看看。

所以，如果我打开这个在“野外数据集中标记的人脸子集”上的面部识别。

你会看到，使用这个不错的inB查看器URL，我们能够查看这个人的Jupyter Notebook，确切地看到他们使用的代码，确切地看到他们做了什么。

并查看结果的图像。查看他们使用的数据的图表。

你可以在这里使用普通文本将其划分为多个部分。这就是为什么Jupyter Notebook在科学界和数据科学家中越来越受欢迎的原因。一般来说，这是因为你能够在一个笔记本中进行一些实验，进行一些建模。

你可以对你的数据进行任何你想要的转换和操作，并训练一个能够进行预测的模型。

你可以写一些关于它的背景信息。你还可以与其他人分享这个笔记本。所以，这是一种非常好的方式。😊。

让你的工作对他人更加可见和透明。而且，你知道的。你可以与任何人分享这个笔记本。他们不需要具备技术背景。你不需要创建一个网络应用程序或任何东西，你也不需要创建一个完整的网站来分享你想做的一些分析。因此，Jupiter笔记本在许多不同的场合都非常方便，而我不确定你想用它们做什么。

不过我相信这一定非常有趣且有用。所以让我来告诉你如何使用Jupiter笔记本。让我们开始深入探讨吧。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P4：4）启动 Jupyter 笔记本 - ShowMeAI - BV1yv411379J

好的，我们现在已经安装了Python和Jupiter。我们需要做的就是输入Jupiter Note，然后在后面加一个&符号，这样就可以在终端后台运行，这样我们还可以继续使用终端。好的，这样在我的另一屏幕上弹出了一个窗口。让我把它拖到这里。

让我们关闭这个。好，现在开始。我们进入了Jupiter笔记本。我在我的主目录中启动了这个。所以你会看到我们可以访问所有文件夹，所有目录。我要创建一个新笔记本的地方是这个项目数据科学文件夹，你会看到这就是我项目数据科学目录中的所有文件夹。

让我们创建一个新的。我会创建一个新文件夹。

让我们重命名它。我们称它为Jupiter教程。

现在，我会点击这里。这是你每次运行Jupiter笔记本时会看到的基本界面。所以我们有一个文件浏览器，还有这个运行标签，基本上显示了我们是否有任何正在运行的笔记本，是否有正在运行的终端。然后我们还有这个集群标签，我们暂时不需要处理它。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P5：5）基本的Notebook功能 - ShowMeAI - BV1yv411379J

Da。但是基本上，我启动 Jupyter 笔记本后，首先会来这里选择新建。然后你可以选择一个新的 Python 3 笔记本。这会创建一个新的笔记本。我们给它命名，叫它 Jupiter Tu 笔记本。

U 在这里。那么，什么是笔记本呢？笔记本是一种可以编写纯文本并在不同单元格中执行代码的方式。你可以看到，这里有一个单元格。这个单元格目前将是一个代码单元格。你可以通过右侧的标识判断这是一个代码单元格，同时左侧的方括号也能表明这一点。

所以如果我进入这个单元格，我会简单地在 Python 中做一些简单的事情。你知道的，我会设定 x 等于 hello world。然后我们打印出 X。现在，我将点击 shift enter。这将运行这个单元格。你会看到旁边有一个小数字 1。这是一个代码单元格。我们刚刚运行了这个代码并执行了这里的 Python 代码，并打印了出来。

hello world。现在，如果我进入下一个单元格并输入 X，然后按回车。看看会发生什么。你会看到我们在这里得到了输出，它基本上告诉我们，x 是什么。我们不是打印 X，而是将 X 返回到这个笔记本的标准输出，它告诉我们，嘿，X 是一个变量，实际上是一个字符串。

而那个字符串是 hello world。你会注意到我们仍然可以访问这个 X 变量，即使我们在之前的单元格中定义了它。你会看到这个单元格旁边有数字 2，这是因为在后台，Jupyter 笔记本使用的是一个单一的 Python 实例。

一个单一的 Python 内核，它维护着所有变量并跟踪所有内容，就像在普通的 Python 脚本或 iPython 交互式 shell 环境中发生的那样。所以，只要我们在这个笔记本的任何地方定义一个变量，这实际上是 Jupyter 笔记本的一个危险，我现在就来演示给你看。我可以在这里定义一个变量 y，假设 y 是一个再见世界。这有点酷，对吧。

好吧，我运行这个。我还没有打印任何东西。所以我只是定义了一个变量 y。现在，如果我回到顶部，并插入一个新单元格。插入一个上方的单元格。现在我打印 y。即使这个单元格在这个单元格之前，我们也在打印一个变量，它在被定义之前。

但是Jupyter笔记本并不关心单元的顺序。它关心的是单元的执行顺序。所以你会注意到这个小侧边编号，1，2，3，4。我们执行了这个单元，赋值变量，然后现在使用这个变量的位置并不重要。

因为它已经被分配，所以如果我们想可以在这里使用它。你知道，这很棘手。我将使用字母X删除这个单元。现在，如果我打印，为什么又可以呢？好吧，依然有效。它依然有效，因为即使我们删除了变量赋值的单元，Y仍然存储在内存中。为了证明这一点，我将输入。

让我们快速输入Dr，带有两个括号。D基本上会给你一个可用的不同变量和方法的列表。在你的工作会话中。因此在你当前的Python实例中，你会看到x和y都是定义的。这些是我们定义的东西。

还有一些其他的东西是预定义的。我们现在不打算担心这些。但我只想让你看到有哪些变量。这些变量会一直存在，直到我们显式地删除它们。

或者我们关闭笔记本然后再打开。我们重启内核。所以我们这里有点超前了。让我们回到基础。好的，我们有一个代码单元。我会说这是一个代码单元。好的。现在我们还有markdown单元。我要过来这里。

我将输入字母M，但你也可以点击上面的下拉菜单选择markdown。现在，markdown基本上是纯文本。只不过你可以使用各种特殊字符进行格式化。当你在这个Jupyter笔记本中执行markdown时，它会为你格式化。

所以markdown基本上是纯文本。只不过你可以。我将使其为粗体格式。你可以以不同方式格式化内容。让我们在这里创建一个标题。你可以有标题，所以这是一个标题。是一个标题1。并且说，你知道，这是一个。二级标题。😔，这里还有一些文本，包括斜体。还有其他的文本，更多的粗体。好的。

我们做了一点格式化，哦，抱歉。这是二级标题。好了。你会注意到Jupyter笔记本非常友好，实际上在你输入时就做了格式化，所以你甚至不需要等待执行单元以查看会发生什么。

让我们把这个设为二级标题。现在，如果我点击，按下shift和enter，你会看到这只是变成了纯文本，不是代码。它只是markdown。这是一种描述我们在Jupyter笔记本中所做事情的方式。好的，出于组织的考虑，我将创建一个新的单元。

所以与其插入上方单元，我通常喜欢使用键盘快捷键。我将输入字母 A，这样可以在上方插入一个单元。现在我将输入字母 M 以创建一个 Markdown 单元。我会按 Enter。😊，我将说，这里是我们对 Markdown 单元和代码单元的基本介绍。

这是一个 Markdown 单元。你可以创建一个列表。实际上，你可以有列表。有序和无序。你可以有粗体文本。你可以有斜体文本。你可以有代码块。我会说，等等等。为了给你展示一个小代码块的例子。假设这里有一个代码块的例子，所以我们将其格式化为代码。

但它实际上不会运行轻量级代码，所以。假设 x 等于 hello world。打印 X。就这样。这是一个 Markdown 单元。这是一个代码单元。总的来说，这基本上就是 Jupyter Notebook。所以我们在这里讨论的其他所有内容都将是关于这个设置的细节、设置的扩展，以及你可以做的其他事情。

但有了这些知识，我的意思是，你已经有足够的基础可以继续了。这些是 Markdown 单元。这些是代码单元。就这样。如果你想要一个 Markdown 备忘单，你可以在 Google 上搜索类似于 Markdown cheat sheet 的内容。这就是我找到大量信息的方式，这也是每个人使用 Google 找到大量信息的方式。

去看一下 Markdown 表格。我喜欢这个网站 Markdowngu do org。这是一个很好的网站。你可以看到，哦，这里是如何创建标题的。这里是如何创建粗体文本、有序列表的。你可以做链接，可以，您可以做表格。

各种不同的内容。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P8：8）菜单功能 - ShowMeAI - BV1yv411379J

现在。

好的，让我们快速浏览一下这些文件菜单。所以我们有文件。你可以创建一个新的笔记本。你可以保存和检查点。编辑。你可以拆分单元。你可以合并单元。你可以剪切、粘贴和删除。你可以查看。你可以查看行号，所以你可以在这里切换行号的显示或隐藏。你可以插入单元。

在单元菜单项下，你可以运行单元并更改类型。如果你想清除输出，比如说，我们知道，我们想要清除这个 hello world 输出，来到这里，当前输出。然后清除。或者如果我想清除这个 Dr 这里，你知道，单元当前输出清除。

就好像这个单元没有运行。让我们看看小部件。我们现在不打算讨论这个。然后你有帮助。我现在就给你展示。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P9：9）Jupyter Notebook键盘快捷键 - ShowMeAI - BV1yv411379J

我现在就给你展示一个我最喜欢的帮助。

迷你项目，也就是键盘快捷键。所以我认为如果你学习了这些，只需要几个，就能让你在使用Jupyter Notebook时更快、更高效。让我看看我能找到哪些。这里我们开始。A 是在上方插入单元，B 是在下方插入单元，X 是剪切选中的单元。运行 shift enter 将会运行一个单元。

你会看到这里的进入是进入编辑模式，这就是我所说的。至于在单元格中输入代码与处于蓝色执行模式之间的区别，在这个模式下你可以使用这些键盘快捷键。所以这里有很多很棒的快捷键，确实值得花些时间去学习。如果你发现自己一直在重复某个操作，学习这个操作的键盘快捷键。

Jupyter Notebook 超棒教程！50分钟，把安装、常用功能、隐藏功能和终端讲解得清清楚楚。学完新手也能玩转！ - P1：1）介绍 - ShowMeAI - BV1yv411379J

你好，欢迎来到另一个精彩的数据科学项目教程。今天我们将深入探讨 Jupyter Notebook。因此这个教程非常适合从未使用过 Jupyter Notebook 的人，是一个直截了当的介绍。

我们将学习相当多的内容，并且我们将在 Jupyter Notebook 中进行。所以数据科学项目就是通过实践来学习，因此我希望你能有一台电脑并跟着我一起学习。

😊，所以。😊，让我们来谈谈我们在本教程中要做的事情。第一步，我们将查看几个 Jupyter Notebook，以便奠定基础。第二步，我们将安装 Jupyter Notebook。我会帮助你在一个良好的虚拟环境中安装 Python 和 Jupyter Notebook。第三步，我们将打开 Jupyter Notebook，并提出问题。

什么是 Notebook，我们将开始探索。

第四步，我们将看看除了基本功能之外，你还可以在 Jupyter Notebook 中做的一些其他常见操作。第五步，我们将查看 Jupyter Notebook 的其他部分，除了 Notebook 本身，然后我们将看看一些其他内容，比如键盘快捷键、Jupyter Notebook 的一些扩展和我非常喜欢使用的其他功能。

所以让我们直接进入吧，开始吧。

Jupyter Notebook超棒教程！50分钟，把安装、常用功能、隐藏功能和Terminal讲解得清清楚楚。学完新手也能玩转！ - P15：15）Jupyter Notebook扩展和其他库 - ShowMeAI - BV1yv411379J

这基本上就是我们这里的Jupyter笔记本教程。所以我想给你留几个其他资源。我不会深入讲解，因为我认为你已经打下了很好的基础，可以开始了，但我想让你知道这些，以防它们对你想要做的事情有帮助。

所以第一个工具，我相信是Jupyter笔记本安装的一部分，是nbconvert。所以这里的notebook convert。这基本上帮助你将笔记本转换为其他格式。正如这里所说，非常有帮助。你可以转换为PDF，可以转换为LaTeX、HTML等等。这会非常方便。第二个我想指出的资源是B格式。

所以如果你在B格式中搜索，然后点击Jupyter笔记本格式，特别是这个用于处理笔记本文件的Python API。

这也是随你的Jupyter笔记本安装提供的。这是一种在Python脚本中以编程方式处理笔记本文件的方法。因此，例如，想象一下你想创建某种类型的Jupyter笔记本。也许你想创建不同类型的数据对应的各种代码单元和不同类型的markdown单元。

你有一些逻辑来决定如何创建Jupyter笔记本。好吧，B格式可以帮助你做到这一点。此外，你可以读取现有笔记本并编辑，然后将其保存为Jupyter笔记本。这对于以编程方式处理不同的Jupyter笔记本非常有帮助。

而这个资源，加上下一个，paper mill可以形成非常强大的组合。所以paper mill并不是Jupyter笔记本自带的，你需要单独安装。

但是paper mill让你可以参数化笔记本并执行笔记本。所以每当我说参数化，这意味着将变量传入笔记本。所以假设你在Jupyter笔记本中有一个实验，想用不同的参数集运行它。

好吧，你可以使用paper mill将不同的参数值传入笔记本，然后自动执行整个笔记本，最终输出一个完成的、执行过的Jupyter笔记本。

或者从B格式考虑，你可以使用Python动态创建某种类型的笔记本，然后使用paper mill执行该笔记本，也许你可以将该笔记本转换为PDF，并且，知道吗？也许自动发送电子邮件之类的。

所以这是一种这些扩展非常强大且可以相互结合使用的方式。

现在，我想留给你们的最后一件事就是。如果你在谷歌上搜索Jupyter笔记本扩展，然后来到这个i Python contri Jupiter contri in B扩展。让我们具体看看。这里是文档的链接。

所以你在Jupyter笔记本中想要的任何功能可能都可以通过Jupyter笔记本扩展实现。所以在这里你可以做各种各样的事情，比如说代码字体大小，自动对齐代码。让我们看看，你有各种不同的扩展。你有拼写检查器。你有这个，哦。

hinter land one，提供代码提示或代码自动补全，各种各样的，哦对了。这里有代码折叠。你可以在这里查看各种不同的Jupyter笔记本扩展。如果你想要某种功能，它可能就在这里存在。

OpenCV 基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P11：第8章：轮廓与形状检测 - ShowMeAI - BV1zL411377L

现在我们要在图像中检测形状，因此我们将检测它们的轮廓、角点，并根据这些决定该物体的形状。我们有我们的包，资源中有形状的图像，我们所做的只是使用IM show函数将其打印出来。

这是我们的图像，它包含三角形、圆形、正方形和矩形。我们将检测每一个，并将其分类，显示每个形状的角点数量以及面积。那么，让我们开始。首先我们将预处理我们的图像，将其转换为灰度图像，然后找到边缘以便找到角点。

让我们先将其转换为灰度图像。因此，我们将使用CVT color函数。在这里，我们将写我们想要更改的图像，并定义我们希望通道是什么颜色，因此我们将说BGR2 gray。然后我们会添加一点模糊。因此，我们将使用Wassian模糊函数。

所以我们得到了灰度图像。然后我们需要定义卷积核，假设它是7乘7，然后我们有了sigma，sigma值越高，模糊程度越大，所以我们先将其设为1，看看是否需要更多。接下来我们要检测边缘，实际上，在此之前。

让我们打印出来，看看一切是否正常。所以我们有图像灰度、图像灰度，然后是图像模糊。我们将在这里写灰度，并在这里写模糊。如果我们运行这个，我们应该得到三幅图像。是的，我们得到了灰度图像，并且增加了一些模糊效果。

实际上，此时使用我们的堆叠函数是个好主意，这样我们就不需要过多处理了。在第6章中，我们使用了这个函数。所以让我们复制它，然后回去粘贴到顶部。那么，让我们使用堆叠。所以我们将说我们的图像堆叠等于堆叠图像。我们将其缩放至0.6。

然后我们将定义我们的图像数组。现在，在里面，假设我们将放入我们的图像和图像灰度，然后是我们的图像模糊。我们可以去掉所有这些，然后可以直接说stock。然后，image stuck。所以如果我们在这上面，就这样，我们得到了图像，所有三幅图像堆叠在一起。

接下来我们要在图像中找到边缘，因此我们将使用Canny边缘检测器。我们将写image canny等于C2.dot scanningny。Canny，我们将定义图像，给它模糊图像，然后我们必须定义阈值，我们可以选择一些阈值，比如50和50，看看效果如何。

所以我们可以添加另一行。并且。我们可以添加。图像 Gny。图像，Gny。然后其余的。我们可以保持不变，或者我们可以定义一张黑色图像，所以我们可以定义我们的图像为空白图像，所以我们可以说图像。Mage blank 等于 nuy dot。Zeros，像。图像。然后，我们可以把这个。放在这里。让我们运行这个。就这样。所以现在我们有了我们的边缘。从这些边缘，我们将找到我们的轮廓。

所以，让我们回去。现在我们要创建一个函数。之前我们没有创建函数，但因为这段代码稍微多一点。所以现在我们要创建一个函数。所以让我们在这里向上定义一个名为 get contours 的函数。在这个函数中，我们将定义我们的图像。它将输入一张图像。从这里开始。

我们将找到我们的轮廓。所以我们要做的第一件事是写。轮廓。然后。我们将写层级。Hi are。让我们保持小一点。然后我们将使用我们的 C2 dot find contour 函数。查找轮廓。在这方面。我们必须定义我们的图像，即我们要查找轮廓的图像，第二个参数是我们的检索方法。

我们有不同类型的检索方法。我们要使用的是外部方法。所以检索。我们将写 R E。是什么，R，E T。E 是，没错。R，E，T，E，R 对，外部。这做的就是它。它检索极端的外轮廓。还有其他替代方法可以检测所有轮廓。它们不会被过滤掉。

但如果你想找到外部细节或外部角落，这个方法特别好。所以我们将使用这个。然后我们有了近似，你可以请求所有信息。或者你可以请求压缩值。因此，它将为这个例子减少点数。我们将获取所有找到的轮廓。所以我们会说。C，V2 dot chain。

近似为 none。所以一旦我们有了轮廓，它们将保存在轮廓中。我们将说我们想要循环遍历它，所以对于。C 和 T 在轮廓中。干。Tos。所以对于每个轮廓，我们将。首先找到区域。所以我们会说区域。等于 CB2 dots。Contour。Area，我们只需提到我们要查找区域的轮廓。现在。

我们要做的第二件事是绘制这个轮廓。那么好吧，等一下，在此之前。让我们先打印出来，以便你能看到。我们得到了什么样的区域。所以如果我们运行这个。哦，实际上，我们必须调用这个函数。天哪。所以我们需要下去，在这里我们会说。获取轮廓，我们将发送图像 canny。就这样。

所以这些是我们为每个你所说的形状找到的区域。接下来，我们将绘制它们，以便清楚地看到。我们将使用 drop contours 函数。所以 C V2 dot draw。Contours。我们将给它我们想要绘制的图像。所以我们将创建。

我不想把它放在原始图像上。所以我们可以做的是创建一个原始图像的副本。因此我们可以在这里说。图像轮廓。等于。图像.复制。因此我们将复制图像，以便我们可以。在此图像上绘制图形，即图像轮廓。因此我们将定义它在哪里。所以我们将说图像轮廓。我们想把它放在那。

然后我们必须给它轮廓本身。所以这将是C和T。然后我们有轮廓索引。因此这里我们将说负一，因为我们想要绘制所有的轮廓。接着我们必须写2，5，5。然后我们假设，我们将要制作它。那是什么颜色？是蓝色。好的，然后我们将其设置为厚度为3。

因此，每次循环时，它将绘制在CNT中找到的完整轮廓。这就是这个语句所做的。所以让我们运行它。

哦，我们没有在这里放图像轮廓。所以图像。

轮廓。

这就是结果。因此现在我们有了所有的形状，并且我们检测到了所有的轮廓。你可以看到它们周围有一条蓝线，似乎检测得相当好。

所以下一步，我们要做什么。因此接下来，我们将检查最小面积。因此我们将给它一个阈值，通常，如果这只是一个图像，你不需要。但是给一个最小阈值以确保它不检测到任何噪音是个好主意。因此我们可以说，如果我们的。面积大于，例如，500，500像素。

然后我们将进行计算，数学运算，如果你想完全忽略它。那么我们就把它放在这里，而不是上面。

如果我们写下这个，我们可以看到所有的形状的面积都大于500。所以我们不应该有任何的。

问题，因此我们接下来要做的是计算曲线长度。因此曲线长度将帮助我们近似边缘的角落，形状的角落。因此我们将把它写下来。所以我们将写这里。周长等于C，V2.阿兰。我们想找到我们轮廓的阿克兰。我们将说它是封闭的。

所以我们将其设置为真。因此，我们可以。如果你想看到它打印出来，我们可以打印出来。巴里和。因此。现在我们正在获取每个轮廓的长度，弧。阿克兰或控制参数。你称之为什么？或者控制参数。因此接下来，我们将近似。角点，我们有多少个角点。因此我们将写一个pro等于。C，V 2点。

近似多边形。我们将给我们的轮廓，然后我们将给它一个分辨率。所以你可以在这里进行调整。如果你没有得到好的结果，我们将用我们的长度乘以它。这里你可以稍微调整一下，如果你没有得到好的结果。然后你可以再写一次，因为它是封闭的。

我们希望所有的形状都是封闭的。那么接下来，我们将打印出我们的块的值。现在，这将给我们每个角点的坐标。所以对于它们中的每一个，每个形状都是如此。所以如果我们在这里看到，对于它们中的每一个，我们都有一定数量的点。所以这里，例如。

我们有三个点。这里我们有超过三个，也许是七个或八个。然后我们有1，2，3，3。然后继续。那么我们可以做的是，不打印这些。我们可以打印每个形状的长度。这样就能让我们了解形状是什么。所以在这里你可以看到我们有383，所以我们可以说3是三角形。

4要么是一个正方形，要么是一个矩形，我们稍后也会找到答案。然后我们可以说，任何大于四的形状都是一个圆形。所以因为我们只检测三到四个类别，所以我们可以假设。那么接下来，我们将创建我们的对象角点。对象角点等于我们近似值的长度。

现在我们将为我们的检测对象创建一个边界框。所以现在我们将获得边界框的值。如果我们要在我们的对象周围绘制一个边界框，那么X和Y，以及宽度和高度将是什么？那么让我们获取那个X、Y、宽度和高度。

所以我们将从C2点获取这个。边界框，边界矩形，然后一个rockx。好的，我们在这里放一些空格。然后这里也是。好的，这将给我们每个对象或形状的X、Y坐标和宽度、高度。让我们立即绘制它们，以便我们能清楚地了解我们在做什么，C2点矩形。我们想绘制它。那么你想在哪里绘制它？让我们在图像轮廓上绘制。

然后我们将给它第一个点，这将是你的X和Y。它将是X和Y，而你的第二个点将是X加上宽度和Y加上高度。所以它将是X加上宽度和Y加上高度。接下来我们将给它一个颜色。让我们给它一个不同的颜色，这样我们就能辨别它是一个边界矩形。

然后我们将给它一个厚度。这样就可以了。那么让我们重新运行它。

就这样，现在我们可以看到我们在检测的每个形状周围都有边界框。通过这些边界框，我们可以获取信息，例如对象的总宽度和高度，以及对象的中心点在哪里，这些信息在其他项目中可能会很有用。

但现在我们要做的是对这些对象进行分类。

关于它们是圆形、三角形、矩形还是方形。首先，我们从最小的开始，那就是我们的三角形。所以我们可以说如果。我们的对象。角数是3。然后我们希望我们的对象类型。对象类型。这个变量将是。三角形。这只是一个字符串。

我们可以做的是把这个字符串打印出来。在我们的图像中，所以我们可以说CB2.dot put text。我们将定义我们的图像轮廓，然后我们将写下我们想要打印的内容。那就是我们的对象。我写成什么了，哦，这个要大写。让我们改成小写。对象类型。然后我们要写下我们希望在哪里打印它。

所以让我们在对象的中心稍微偏移一下打印它。那么对象的中心是什么呢？这会占用一些空间。所以我会把它放在这里。那么对象的中心将是x加上。等等。除以2。然后我们稍微偏移一下，所以我们会减少10个像素。接着我们会写出y的中心，也就是y加上。高度。

除以2。这个我们保持不变。还是应该我们加一些你说的。偏差在这里。所以让我们设为-10。这样会比中心点稍微高一点。那么接下来是什么呢？是的，接下来是字体。所以我们会写C V2.dot font。我们不想要什么花哨的东西。所以我们会写。我们将使用第一个。

然后我们会写出我们的缩放。缩放，我们设为0。5。然后我们有我们的颜色。所以我们设定颜色为0，2，5，5，以及2，5，5。然后字体缩放，我们设为2。好的。那么我在哪里出错了，Ca它没有正确显示。是的，逗号。好的。那么这应该让我们在每个地方都有三角形。之前的对象类型引用。

对象类型。好的，所以我们没有定义如果不是3会发生什么。所以现在，我们可以说else。对象类型等于。等于none。

所以你看。哦，那是黄色的。

这有点难以阅读。所以我们将换成不同的颜色。让我们用黑色。我认为黑色会更容易阅读。我们还可以稍微增大一点尺寸。这样更容易看清。而且我们还可以增加尺寸，因为我们还有一些空间。所以，让我们运行这个。看吧。现在我们可以看到所有的三角形。

它们被正确检测，其余的没有。因此接下来。我们将定义其余的。这将在这里。如果我们的对象或者应该是否则如果。我们的对象。角数等于4。现在这个有点棘手，我们要检查我们得到的是正方形还是矩形。我们怎么能判断呢？我们知道，如果我们将宽度和高度相除，应该得到1，因为正方形的宽度和高度是相同的。我们可以查看，如果我们将它们相除，将得到宽高比，如果该宽高比在某个范围内，我们可以说它是正方形；如果不在，我们将说它是矩形。

所以我们要做的第一件事是获取宽高比。所以我们将写宽高比等于宽度除以高度。由于我们处理的是小数，我们必须将其中一个定义为浮点数。这样可以给我们。浮点值。因此，一旦我们有了，我们将放置另一个if语句，如果我们的宽高比。大于0.95。并且。

我们的宽高比。小于1.0，5，这意味着我们可以有5%的偏差。然后我们将说我们的对象类型。等于2。正方形。如果不是这样。则我们的对象类型等于2。矩形。

那么我们来运行一下。就这样。这里我们得到了一个正方形矩形，正方形，正方形。矩形正方形。接下来，我们将为圆形编写代码，所以我们会写。

否则，如果。对象的角数。大于4。那么我们将写对象类型等于2。圆形。所以，让我们运行一下。

就这样。现在我们有了圆形、矩形和平方三角形。它们都被正确检测，除了这个。解决这个问题会稍微复杂一些，但我们可以稍后再尝试。

OpenCV 基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P12：第9章：人脸检测 - ShowMeAI - BV1zL411377L

要检测阶段，我们将使用 Viola 和 Jones 提出的一个方法。这是最早允许实时物体检测的方法之一。因此，如果我们要检测人脸，我们可以收集大量的正样本，这些将是人脸的图像，同时我们也会收集大量的负样本。

这些将是任何非人脸的图像。使用这些负样本和正样本。我们将训练并创建一个级联文件，这将帮助我们找到人脸。在我们的案例中，我们不会训练模型，而是使用 OpenC 提供的预训练文件。现在 OpenC 提供了一些默认级联，可以检测不同的物体，如车牌、眼睛、全身等。如果你想了解更多关于创建自定义级联的信息。

我有一个单独的视频，这将在描述中提供。

我们从源文件夹中导入 Lina 图像，并使用 IM show 函数显示它。因此，我们要做的第一件事是添加我们的级联。因此，我们将写 face cascade，face.Gas.Kate。等于 C2.dot。Caascade classifier。然后我们必须写下名称。Celes。Soer says。好。Bres。Sources，slash。接下来我们将写 ha。Gass。Skate。Undersco frontal。Face。Underscore default dot X。

M，L。因此让我再检查一下拼写，如何。Ca。Gaiade。😔，而 frontal face default。X M L 看起来不错。接下来，我们将把图像转换为灰度图像，因此 image.Gray 等于 C2.dot CT color，接着是 image。然后我们使用 C2.dot color RGB2 gray。然后我们将使用人脸级联在此图像中找到人脸。

因此我们将说 faces 等于 face.Cascade，dot detect。我们将使用 multi scale，并写 image gray，然后我们必须定义缩放因子。我们将其设为 1.1，然后我们必须定义最小邻居，我们可以设为 4。这些参数可以根据你获得的结果进行更改。

接下来，我们将在人脸周围创建一个边界框。因此，我们必须遍历所有已检测到的人脸，并在它们周围放置矩形，我们将直接获取 x、y 以及宽度和高度的参数。

因此，这四个参数是你实际创建边界框所需的。因此我们将写 x、y 然后是宽度和高度。接着我们将说，在 faces 中。然后我们就画出矩形。让我们在原始图像上写它，然后给出初始点，即 x 和 y。

然后我们需要定义角点，斜点，即 x 加上宽度和 y 加上高度。接着我们需要定义颜色。我们就用蓝色，2，5，5 和 0，0。然后我们将定义厚度。我们设为 2。所以，差不多就是这样。让我们运行看看。好了，现在我们已经检测到人脸，并且为它创建了一个边界框。

如果你想检测更多对象，网上有很多人已经训练好的级联可用，或者你可以创建自己的自定义级联来检测汽车、手机、电视，任何你能想到的东西都可以使用这些级联方法进行检测。现在，这种级联方法并不是最准确的，但它很快，因此很多摄像头也使用这些硬级联方法来寻找人脸，尽管这是一种相对较旧的算法，但在某些情况下仍然有效且表现良好。

OpenCV 基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P14：项目2：文档扫描器 - ShowMeAI - BV1zL411377L

在这个项目中，我们将从摄像头代码开始。我们在第一章中做过，所以让我去复制这个。然后我们更改参数。我们将设置为 1，这将是 50。所以，让我们运行它。这里是我们的摄像头。我们将检测这个文档，然后使用透视变换获取文档的平面图像。

我们将进行扫描。现在。让我们继续。所以我们要做的第一件事是。我们将对图像进行预处理，所以我们将应用一些所谓的预处理技术，以便可以正确检测图像中的边缘。所以让我们定义一个函数。3e。处理。这里我们将输入一张图像。所以我们会说图像，然后我们将首先转换这张图像。

我们将调整大小，所以图像。等于 C2 点调整大小。或者我们在这里调整大小。这样大小保持不变。对于持有者过程，所以调整大小。我们将调整我们原始图像的大小。根据我们的宽度和高度，所以图像的宽度和高度。所以这个，我们可以在顶部声明。嗯。就是这样。

在这里创建一个新部分。说明。2，6，40。这个是48。所以我们去掉它。这。完成后。好的，所以我们要做的第一件事是将其转换为灰度图像。所以我们会说图像灰度等于。CV2 点，CT 颜色，然后是我们的源，即我们的主图像。然后我们想将其转换为灰度图像。所以 C2 点。颜色，P G，R 转灰度。

接下来我们将应用一些模糊，所以图像模糊等于 cv2。模糊。我们有我们的图像查询以模糊，然后我们将应用，我们将给出内核的大小为 5 x 5，然后 sigma x。我们说 1。然后，我们将使用我们的 Canny 边缘检测器查找边缘。所以我们会说图像 Canny。等于。CV2 点。Gny。我们的图像是模糊的。

然后我们有阈值。所以我们设置。假设 200 x 200，所以这些值我们可以在过程中更改。但现在我们将保持一些随机值，看看效果如何。一旦我们完成，有时边缘会很细。所以我们可以使用膨胀函数使其更粗，然后可以使用侵蚀函数再稍微变细。

我们可以应用两次膨胀和一次我们称之为侵蚀的处理。现在。这不是强制性的，但有帮助，所以最好这样做。膨胀等于 C2 点膨胀。是的，然后我们将使用我们的图像 Canny。我们将定义一个内核。然后，迭代次数。D。Rations 等于 2。所以。某处有个错误。好的，所以内核。

等于，我们将定义一个矩阵数组。在AtOnce，因此我们需要在这里定义。Numpy有N P。在这里，我们将说我们的卷积核是numpy的once。大小是5乘5。然后我们将进行腐蚀。因此图像。腐蚀。等于C2。实际上，这是最终结果。因此我们称之为阈值图像。阈值。等于C2.ero。

然后我们将输入我们的图像膨胀。接下来我们将定义我们的卷积核，迭代次数设为1。因此，一旦处理完成，我们可以返回我们的图像。它变成了。图像。阈值。所以我们可以在这里看到。嗯。图像阈值等于。我们主图像的重新处理。因此我们可以显示图像。好了，我们得到了。如果我们想查看这些步骤中的每一个输出。

我们可以简单地。你可以说注释掉，然后返回我们想要看到的轮廓。例如，如果我们想移除这两个，我们可以注释掉，然后返回canny。看看这个。这里你可以看到我们的边缘相当1。有时，当出现阴影或反射时，可能无法正确检测。

所以我们添加这个。这里也是。因此我们需要返回。这个阈值。好了，边界变得更厚，更容易检测图像中发生的事情。接下来，我们将继续处理我们的轮廓。我们需要在图像中找到最大的轮廓。这就是我们现在要做的事情。在第8章中，对于轮廓，我们使用函数获取轮廓。

所以我们将复制这个。直到我们的边界框。然后我们会做一些修改。现在我们会粘贴出来，得到了获取轮廓的函数。我们需要做的是找到可用的最大轮廓。首先，我们在这里获取轮廓，然后对每个轮廓进行循环。因此我们可以说，首先我们需要给出面积的阈值。

我觉得最好再加一个零，因为我们的面积会相当大。我们可以移除打印并进行绘制，我们可以在这里复制一个图像。因此我们可以说。图像，假设。轮廓。写一下。轮廓等于。图像.复制。实际上，我们应该在调整大小之后进行此操作，因为所有这些都应该是相同的。

所以我们往下走，然后写tear。然后在这里粘贴。这里我们将粘贴我们的图像轮廓。实际上，让我们使用这个拼写。这样更好。如何控制。然后。我们可以展示发生了什么。所以我们将移除这个参数，我们不需要查看长度。我们需要查看长度吗？是的，我们确实需要查看长度，应该是4。然后。

我们需要边界框吗？是的，好的，那么我们要做的是，首先获取我们的面积。然后检查是否大于5000，如果可以的话。然后我们将进入下一步，在我们的图像上绘制它，或者我们需要绘制吗？我们稍后会看是否需要移除。现在我们将获取我们的参数。

然后我们将找到我们的角点的近似。然后我们必须说。 如果我们的。区域。不是，抱歉。如果我们的。长度。我们的。近似等于4。在这种情况下。我们将说最大的。等于一个 pro。但在循环时。我们需要找到最大的。所以我们必须在这里添加另一个条件。

我们将说如果我们的区域。大于。最大区域。那我们就在这里结束。所以。我们将在这里放手。然后在这里我们会看到最大区域。等于我们当前的区域。那么这将不断循环，每当它找到一个比之前更大的值时。它会替换当前的值。所以这将给我们最大的。

区域和我们近似的最大值，将是我们的四个点。所以我们需要这个吗？不需要，因此我们可以用边界框去掉它。然后我们需要做的就是返回我们的。近似，所以我们将返回。近似。哦，抱歉。我们将返回最大的那个。最大。所以这将给我们最大的轮廓。好的。

所以让我们运行一下，看看会发生什么。现在我们需要在这里调用它。我们将说。获取轮廓，我们将发送图像阈值。好的。那么我们忘记做的一件事是定义。最初，我们的变量。所以第一个是一个列表。所以最大的。将是一个新的列表，一个新的数组，nuy。数组。还有。第二个是最大区域。

所以我们将说最大。区域等于20。因此如果我们再运行一次。看吧。现在我们正在获取我们的轮廓，并希望它返回给我们最大的那个。就是这个蓝色的。所以一旦我们有了最大的轮廓。接下来我们需要做的是使用它的角点。

我们需要扭曲我们的图像，获得鸟瞰图。因此，为了做到这一点，我们将。首先，在这里获取我们的近似，所以我们可以说我们的最大值等于获取轮廓图像阈值。然后在那之后，我们需要做的就是。我们需要发送它进行透视变换。因此我们将写一个新函数。所以，我们将说。获取。它成功了。并在内部。

我们将发送我们的图像。我们将发送我们需要发送的内容。我们需要发送我们最大的。轮廓点。因此，在这里。我们可以调用这个函数获取我们原始图像的透视变换，我们需要基于最大的点。因此，实际上，我们没有打印出来。让我们看看是否正确获取了它。让我们只打印一下。

一旦我们得到了最大的那个，让我们把它打印出来。看吧。我们得到了四个点。所以一个。2，三，和四。所以我们正确地得到了它们。因此，无论它们是否正确，我们会进一步查看。或者。嗯。我们现在可以打印出来吗？我们应该现在打印出来吗？是的，实际上，我们可以。

我们可以做的是，不打印它们所有。我们可以。复制这个。然后我们可以。注释掉这个。最后我们可以做的就是在发送之前打印出最大的一个，所以我们可以在这里说最大的。就这样，如果我们看看。让我增大一下那个尺寸。让我们设为 20。就这样。所以我们得到了最大轮廓的正确点，下一部分将是 verp。

所以现在我们要工作。那个函数在哪里，好的。在 workp 中，我们将遵循之前在扭曲章节中的例子，所以这里我们需要两个点，然后我们创建一个矩阵，然后得到我们的工作透视，所以我们会复制所有这些。然后带入我们的当前项目。所以我们需要找出这些 points1 和这些 points2。

然后我们创建矩阵。基于此，我们得到了宽度和高度。因此，这个宽度和高度基本上是我们图像的宽度和高度。所以我们会说。宽度图像和。高度图像，再次，宽度图像。和高度图像。然后。什么图像。然后。高损坏。好的，我们可以去掉基础。好的，下一步是将我们的点放在这里。

所以我们得到了最大的轮廓。我们需要做的就是输入。最大的轮廓在这里，所以已经有四个点。这样我们就可以轻松地直接放在这里。接下来是在这里找到。所以我们需要做的是看看我们的图像，这里有一个棘手的部分。

我会解释这是什么，但让我们先看看我们的输出图像，这里可以说返回。我们的图像。输出。这里。我们可以调用这个函数。我们可以说 get workb。然后我们可以保存。我们的。Pp。图像工作。没。Worb 等于那个。让我们展示一下。所以这样。现在我们知道我们的点被正确检测到了，但如你所见。

扭曲是不正确的。如果我移动它，它甚至会给我们一个错误。因此，扭曲错误的原因是我们有一个注释，有一个结构我们的点应该位于的位置。所以在我们最大轮廓中的第一个点应该是00，然后宽度0然后0高度，然后宽度和高度。如果在最大轮廓中我们的宽度和高度在第一个，00 在第二个，或者它们混合在一起，那么这意味着我们的词透视将无法正常工作。

所以我们需要确保的是，当我们将点发送到 verp 时，所有的点都要像这样对齐，最小的点应该是第一个，然后是宽度和高度，接着是宽度和高度，所以我们怎么能确保这一点，因为我们的值可能会变化。

这可以不断变化。所以我想说的是，这些值可以根据纸张的角度和轮廓而变化。所以我们必须做的是在发送之前整理这些值。这些最大点。在重新排序它们之前，我们需要创建一个新函数。我们会说，重新排序。在里面，我们需要我们的点。

所以我的要点是。我们需要一些内部点，然后我们将应用一些方法论来创建或重新排序我们的点。例如，如果我们有，让我简单一点，如果你想要这个。等一下。嗯。我们将这些值相加，接下来可以找到最小和最大的点。因此，例如，如果我们加上00，再加上宽度和高度，宽度和0。

0和高度，宽度和高度，最小的点将是00，最大的点将是宽度和高度。这意味着无论我们在这里给出什么点，如果我们将它们全部相加，最小的一个将是我们的00，最大的一个将是我们的宽度和高度，这样我们就能快速区分哪个是最大的，哪个是最小的，哪个是原点，哪个是我们矩形的对角点或最后一个点。

然后为了找到宽度和高度，我们可以相减，其中一个会给我们一个正值，而另一个会给我们一个负值，基于此我们可以判断哪个先来，哪个后来。所以我们需要做的是。首先让我在继续之前给你展示一些东西。嗯。在这里。

所以如果我们看一下我们的数组或矩阵的形状。最大的。让我们看看。它是4乘1乘2。所以我们有四个不同的点，我们理解，并且对于每个点，我们也理解X和Y。但是那个是多余的，所以我们将把它去掉。

所以当我们准备重新排序时，首先我们会说我的点。等于我的点。点reshape。我们希望将其重塑为4乘2。然后我们将创建一个新的矩阵，我们将把它发送到外部，并从这个函数返回。这矩阵应该与我们在这里收到的相同，即4乘1乘2。好的。

所以我们将写我的点。nuon等于nuier点zeros。Zeros。然后我们可以说。4乘1乘2。然后我们可以写它的类型，所以nuy点。Integer 32。我们要做的第一件事是我们将添加。正如我们所讨论的，我们将添加所有这些值。所以内部，我们有四个点。让我打印出来。这样更容易看到。我们将打印最大值。

所以我们要做的第一步是将它们逐一相加。所以1，85加55。然后61加279，依此类推。为了做到这一点，我们有一个简单的函数。我们可以说加法等于我的点。点和。我们将使用A 1。所以这将给我们。让我们打印出来，我们可以说。我们的加法。是。我们没有发送它进行重新排序。

所以这就是它不显示的原因。那么我们可以做什么呢？我们可以。在这里写。或者这应该在verp内部。因此，我们可以在这里写。重新排序。我们可以发送最大的点。所以如果我们停止它，我们可以看到这里，183加55是238，然后61加279是340，依此类推，我们得到了。我们的值。因此，这里最小的一个是我们的第一个。所以我们将说这是我们的00。

而这里最大的值是651。我们将说这是我们的宽和高。所以这个位于正确的位置。它应该在00。但这个位于错误的位置。这个应该是最后一个。所以我们将在新的点中重新排列顺序。因此，我们将在这里说我的点。新的。在数字0，也就是第一个。

等于我的点。我们将获取索引。因此我们首先要找到最小的。我们会说nuy点。A RG最小值。我们将说找到最小的。这个列表或这个矩阵中最小的索引。所以在这里我们将找到最小值，并获取其索引。

一旦我们有了索引，我们将在这里放置它。从中我们得到值。实际的x和y，然后将其存储在我们的新点中。我们对最大的点做同样的事情，它将是最后一个作为0，1，2，3。这次我们将写作max。因此，如果我们运行它。让我把它打印出来。Brent。

新的点。我们可以写。前にポ。所以如果我们打印出来。我们可以看到现在新的点最小的在第一个位置，最大的在最后一个位置。所以现在我们需要找到中间的点。因此，接下来，我们将。我们可以删除，或者让我们现在保留它们。接下来，我们将找到它们之间的差值。

所以我们可以说，差值等于nuy点。差异，我们将使用我的点。再次，我们将把我们的轴定义为一。实际上，让我写下来。你可以这样定义x为一。因此，基于此，我们将说我的点。新的点在数字一。等于这应该是我们的宽度和0。所以这个将是我的点。

在Nai点。我们微分的最小参数。同样的方式。让我在这里写。第二个将是我们参数的最大值。所以让我们运行它。好的。让我把这个打印出来。但在底部。好的，如果我们运行它。然后停止它。所以现在你可以看到我们的点被重新排列了，所以我们得到了宽度。

然后0，0，和高度为0，我是指这是一个较低的值。所以，这里我们的点被重新排列。你可以看到我们的原始点是这样的。然后我们的排列点是这样的。所以现在我们有了新点，可以将它们发送回去。那我应该删除吗？好的，让我把它放成注释。所以如果你想检查，可以去检查。

然后我们可以写return。我的点，新。所以这将给我们最大的点重新排列。所以我们会说最大等于reorder。最大。所以如果我们现在运行这个，希望它能正常显示。看，这样我们的图像显示正常。我们获得了我们的单词视角。图像已经生效。现在。

问题是宽度太大了。我们需要缩小它。让我们设为360。好吧，摄像头不能，所以640，我的摄像头有这个问题，所以必须是640乘40。我们可以这样做。😔，所以。为什么它还在，好的，好的，好的。所以这应该是相反的。所以这个应该是640，而这个应该是360。让我们设为480。いや、間違まる。

所以这就是我们得到的。现在的问题是我们的原始图像是640乘480。所以不要期待这里有很多分辨率，但我在资源文件夹中放了一张图像。所以如果你查看资源文件夹，我们有一张纸质图像，这张图像分辨率非常高。是4000乘3000。

所以如果你在这个上应用相同的方法，最后会给你一个非常好的扫描图像。但是因为我们是从实时摄像头获取的，只有640乘480，所以分辨率并不好。但如果你能提高值，就会得到更高的分辨率。所以现在这样就好，但有一点我们可以看到，verp很好，但最后我们可以看到一些线条。

而且我们不想要那个。我们可以做的是在边缘周围稍微裁剪一下，以便获得更好的结果。所以我们可以在变形后减少一些像素，所以让我们把它放在verp中。

所以在这里我们可以说我们的。假设是图像输出。还是应该给它起个不同的名字？我们就给它起个不同的名字吧。图像。嗯。Croed等于。我们将裁剪我们的图像。或者我们将说我们的原始图像是IMG output。然后我们将从每一侧去掉20个像素，所以我们会说20。然后，图像输出。

点shape。添加零，然后我们将从这里减去20，就像这样。然后我们再说20。然后我们会说我们的图像输出。点shape，也就是在1-20。这是我们在裁剪示例中做过的相同概念。所以如果你不记得，可以再查看那一章。

一旦我们完成了这一点，我们需要调整图像大小，以便它与之前的大小相同。因为这样处理会更方便。所以，Cbed等于C2点resize，然后是我们的图像裁剪。然后是我们图像的宽度和高度。然后我们可以输出裁剪后的图像。所以，如果我们了解这一点。

现在我们得到了一幅更干净的图像，我们从每一侧移除了20个像素，现在它看起来更像是一张扫描的纸。好的，接下来，我们可以看看你所称之的工作流。我们可以添加我们的连接代码，这就是我们的叠加。如果我们想这么做，我们可以回去。我们可以去第六章。这里有叠加的函数。我们可以复制这个。

我们可以把它粘贴到当前项目中。然后把所有这些图像放在一起。那么我们应该把哪些图像放在一起呢？这只是一个形式，看看发生了什么。所以，还有另一个案例我现在会讨论，你会看到这也很重要。我们先把图像叠放起来，所以我们会说我们的图像。

数组等于我们要声明一个数组。所以在这里我们将放置我们的原始图像。然后我们可以放置我们的图像轮廓。然后我们可以放置。图像。最大的。在哪里那张图像阈值。所以让我们放下它，这样我们可以把它放在这里。图像阈值。然后，我们可以放置。图像工作。所以这应该给我们一个好主意。然后我们只需说。叠加图像。

所以我们会看到它叠加的图像等于叠加图像。我们将定义一个缩放比例。假设为0.6。然后我们将定义我们的图像数组。哦，抱歉，图像。然后在这里我们将复制这个并粘贴。粘贴。所以现在我们可以看到工作流。我们有我们的文档，然后我们获取我们所称的最大的轮廓，然后实际上这应该在这里。

这个应该放在这里，反过来。所以。它在哪里。所以我想这样更好。是的。所以这样更好。所以再次，现在我们正在重新缩放它。因为这个。它看起来有点奇怪。但如果我们单独打印出来，它应该没问题。每个工作是什么？

所以，在这里我们得到了我们的。最终结果。现在你会注意到的一件事是，如果我删除文档。它应该给我们一个错误。

来吧。现在，这个错误是因为我们没有定义任何东西，当它没有定义最大的时。它找不到最大的轮廓。所以我们需要在这里写下这个。所以我们会说我们要找到最大的轮廓。让我看看我们想把它放在上面还是这里。好的。是的，我们正在发送。最大的。

我觉得把它放在这里更好。所以我们可以说，如果我们的最大值不等于0或者它不为空，那么我们需要继续前进，所以我们可以说。如果最大值。点，抱歉，点的大小。不等于0。那么我们将进行这项图像工作，否则。这个也应该在里面。而且这个可以在外面。否则，我们将仍然显示图像，但我们将。

不显示轮廓，因为我们没有找到它们，我们将不显示工作。我们只会。用原始图像替换它。所以让我们看看这是否有效。

所以如果我移除那个，是的，当我移除它时，它什么都不显示，然后当我把它带回来时，现在它给我显示的是实时图像。

OpenCV 基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P15：项目3：车牌检测 - ShowMeAI - BV1zL411377L

在这个项目中，我们将从我们的网络摄像头开始，然后我们将检测不同汽车的车牌，我们将实时进行此操作，并且我们将使用之前在Fse检测章节中学到的级联方法。让我们从第一个章节开始。

使用网络摄像头，我们将复制那段代码。再一次，我们将其改为1。让我们运行它，看看是否正常工作。这里我有我的网络摄像头，它已连接，我们可以看到我们有几张汽车的图片，我们要检测它们的车牌。

一旦我们完成了这一点，我们将进入第9章，在那里我们做了我们的级联方法。我们将复制这个。啊。我们将在项目3中粘贴它。所以在这里获取级联，我们不需要一遍又一遍地定义它，尽管我们必须获取图像。我们从网络摄像头获取的图像，我们可以去掉这个，我们必须把它提上去。

在我们的参数中。所以在这里我们可以定义我们的参数。然后。我们将图像转换为灰度，这是可以的。然后我们检测。面孔。在这种情况下，我们可以说车牌。我们可以复制这个并粘贴到这里。所以我们应该说。车牌级联，例如。或者车牌。Goashk。

所以在这里我们可以说。然后再做一次。好的，它正在围绕它绘制矩形。现在，一旦我们检测到我们的对象，我们需要首先创建一个过滤器。所以我们只接受大于某个区域的对象。然后我们需要定义一种方式，在获取到车牌后可以保存我们的图像。

所以我们来做这个。首先，我们将添加我们的过滤器。为了做到这一点，我们需要找到我们的区域。区域等于宽度乘以高度。然后我们需要定义我们的最小区域，所以我们可以说如果我们的区域大于，例如，500。这是我们的最小区域，因此我们将说最小区域。我们将在这里定义它。

最小区域等于500。如果大于500，那么我们将其检测为矩形。接下来我们要做的是标记它。所以我们将说C2。点放文本。我们想把它放在我们的原始图像上。然后我们将放一个名字，所以我们可以说。号码，车牌。然后我们有我们的x和y。

所以我们可以写x和y，我们想把它放得稍微高一点，所以我们将减少，比如说5。然后我们将写上字体。所以，C2点。字体，我们可以选择任何，来。选择复杂小号。然后我们将设定1作为我们的缩放比例，接着我们将放一个颜色。我们可以定义颜色。然后我们将厚度设定为2。颜色我们可以向上去。并在这里定义为2，5，5，0，以及。

2，5，5。是的，然后我们可以提取我们的感兴趣区域，我们的车牌。因此，一旦我们有了矩形的x、y、宽度和高度，我们可以使用这些信息来获取我们的原始车牌图像。所以我们可以说我们的图像。我们的感兴趣区域图像是图像，我们的原始图像裁剪。

正如你所知，我们正在使用裁剪。所以第一个元素将是我们的高度。因此我们在说y。て。Y加上H。总高度。然后我们将说我们的宽度。告诉我们的，抱歉，不是宽度x。告诉我们的x加上宽度。所以这应该给我们车牌的区域。因此每当检测到对象时，我们需要在这里放置这个，每当检测到车牌时。

只有这样我们才会显示我们的图像。最后一件事是改变我们的级联。这是正面人脸。在资源中，我们有俄罗斯车牌号。所以我们将使用它。因此，我们将其更改为。俄罗斯。下划线车牌，下划线。数字。所以。让我们运行这个。好了，我们在原始图像上得到了我们的车牌。

然后我们提取我们的ROI，正如你在这里看到的。它有点小，更难抓取。但你可以看到，我们正确地得到了我们的图像。但是这里的颜色是蓝色，为什么是蓝色？是的，我们需要将其改为255，没问题。所以这是我们得到的，接下来我们可以做的是将这个图像保存在我们的扫描文件夹中。

所以在资源中，我创建了一个扫描文件夹。我们要做的是编写一段代码来保存这个车牌，并且还会给我们反馈，告诉我们已保存。因此，为此，我们将写C2。首先，让我们将其从Q改为S。每当按下S键时，我们将写Cv2，Cv2点权重。CV2。我是对的。

我们将写入文件名，所以我们会说资源，然后是扫描。在里面，我们将写入数字。车牌下划线。然后我们将为其添加一个字符串。在这个字符串中，我们将放入账户。这样我们可以同时保存多个不同名称的图像。因此我们可以说点JPG。然后我们会说这是我们的Ri图像。现在，这个计数是未定义的。

因此，我们需要定义计数。每次按下这个，我们需要将其添加到我们的计数器。所以我们不会中断。我们将说计数。加等于1。而且。我们需要在开始时定义计数。计数等于0。这样就能保存它。但我们需要一些反馈，告诉我们实际上保存得很好。

我们可以做的是创建一个矩形，然后我们可以在上面显示文本，以便我们知道它已经被保存。因此，我们可以写cv2点矩形，然后写入我们的图像。在这里我们将其放在0200，然后最后一点是640乘以，让我们说300。然后我们将放置颜色0，2，5，5，0。然后Cv2点填充。

然后我们将放一些文本，CV2。想法，放文本。我们将放上我们的图像，并且我们将说扫描。我们说扫描，已保存。然后我们将设置初始值，所以我们设置为 150 和 265。接着我们将选择字体 C2 dot font。我们来选一个随机的。然后。让我们把。

让我们将字体缩放设置为二。然后我们将放置我们的颜色。0。0 和 2，5，5。然后我们将把厚度设置为 2。最后，我们将显示我们的图像。所以我将展示。然后我们将写上同样的名称结果。我们将展示同样的图像。为了能正确看到它，我们将添加一个延迟 c2。

t 权重关键，我们将设置为 500 毫秒。所以如果我现在运行这个。😔，好了。如果我按下 S，它会说扫描已保存。然后如果我去下一个图像，我可以。再保存一次。我可以去下一个图像，也可以保存，所以这三个车牌都应该已经保存，如果我们去我们的扫描文件夹，这里。我们可以双击它，看到我们有三张图像，这是第一张。

这是第二张，这是第三张。

OpenCV 基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P3：第0章：安装 - ShowMeAI - BV1zL411377L

现在让我们开始安装。首先，我们将去 Python 或 Rg，然后我们将前往下载部分。在这里我们不会下载最新版本，而是下载 3.7.6。

由于它与 Open C 配合得很好，所以我们将点击下载，然后前往。

针对 Windows 版本。如果你有 Mac，你也可以下载 Mac 版本。一旦下载完成，我们将安装。确保将 Python 3.7 添加到路径中。安装完成后，我们将关闭对话框，并前往 pie charm。现在 Pycharm 是我们将用来编辑代码的 IDE。

这是一个代码编辑器，可以让我们编写代码，但它具有很多功能，可以帮助我们在编码过程中。所以我们将前往它的下载部分，并下载社区版，因为它是免费的。一旦下载完成，我们将运行安装文件。

在这里我们将把 dot pie 文件关联到 pie charm，并且我们还将直接将启动器添加到路径中。接下来，我们将重启计算机并运行 pie chart。

现在我们要创建我们的新项目。在开始项目之前，我们先看看项目解释器。现在必须是3.7。如果自动检测到，那么我们就可以开始了。接下来，写下“打开 TV”，换一托。然后点击“创建”。现在这是 P Char 环境，在这里我们有一个区域可以编写代码，而左侧是项目文件和项目文件夹。

如果我们打开我们的文件夹，我们只会看到环境，即创建的虚拟环境。现在我们需要在这个环境中安装库或包，所以我们将前往“文件”。“设置”。“项目”，项目解释器，然后在这里我们将添加并搜索。现在，我们将写“打开 C”。在这里我们有 Open CV Python，所以我们将点击“安装包”。

一旦安装完成，我们将关闭这个，按 O。现在我们将创建我们的第一个 Python 文件，所以我们将右键点击我们的项目。我们将选择“新建”，并创建一个 Python 文件。在这里，我们将命名为“第一章”。现在如你所见，在我们的项目中，我们有一个 chapter 1 dot by 文件。

这里是我们可以编写代码的地方。

现在让我们导入我们的 Open CB 包。我们将写“导入”，然后是 CV2，CVv2 代表计算机视觉。接下来，我们将打印“包已导入”。现在，如果一切正常，这应该输出“包已导入”。所以我们将右键点击第一章，然后点击“运行”。现在在控制台中，我们可以看到包已导入的消息。

这意味着我们的包已经成功导入，现在我们可以继续进行。

OpenCV 基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P5：第2章：基础函数 - ShowMeAI - BV1zL411377L

因此，让我们看一些在构建 OpenCV 项目时需要的基本函数。我们将从导入图像开始。我们将使用 imread 函数。我们将把文件定义为资源文件夹中的 Lina。现在，我们做的第一件事是将其转换为灰度图像，因此为此。

我们将定义我们的灰度图像 img_gray。它等于2。现在我们将使用来自 CV2 包的功能或函数，称为 cv2.cvtColor。基本上，cv2.cvtColor 将你的图像转换为不同的颜色空间。因此，你需要定义你想要转换的图像。

然后你必须定义你想要转换成的颜色空间。因此，这里我们将其转换为灰度图像。现在，传统上，我们使用红色、绿色和蓝色，也就是 RGB。但在 OpenCV 的图像约定中，通道是 BGR。因此我们将写 cv2.cvtColor。灰度图像。让我们输出它，看看会发生什么。我们将使用 cv2.imshow。

在这里，我们将写入文件名或窗口名称。假设我们称之为灰度图像。我们将显示我们的灰度图像 img_gray。然后，我们需要添加 cv2.waitKey，并将其设置为 0。让我们运行这个，看看会发生什么。这里是我们的灰度图像。现在，让我们进入下一个函数，即模糊。我们将声明我们的模糊图像。现在。

我们将使用 Rossian 模糊函数来模糊我们的图像，所以我们将编写cv2.blur。我们可以使用我们的原始图像，即彩色图像，或者我们可以使用灰度图像来添加模糊，所以我们选择使用灰度图像。接下来，如果你看到这里，会看到它说的 k size，也就是你的内核大小。

所以你需要定义内核大小，例如，我们可以说这是 7 x 7。所以它将添加相当多的模糊，内核大小必须是奇数，所以可以是 3 x 3、5 x 5、7 x 7。所以我们将写下这个，然后我们将说我们的 sigma_x 是 0。所以不要担心太多的细节。我们只是触及表面，看看如何快速启动。

所以我们将复制这一部分。然后我们将在这里写上 blur。在这里，我们也将其更改为模糊。让我们运行这个。在这里我们可以看到这两幅图像之间的区别。这是灰度图像，而这是添加了模糊的图像。接下来，我们将看一个边缘检测器。现在，这个特定的边缘检测器称为 Canny 边缘检测器。

为了找到我们图像中的边缘，我们将使用 cv2.Canny。我们将其称为 image_canny，然后我们将使用我们的 Canny 函数。我们将分配图像。现在我们将添加阈值值。所以我们有两个阈值。为了简化，我们将其设置为 100 和 100。所以你可以选择更高或更低。但同样。

这取决于你特定的情况。所以，让我们复制这个。然后我们将去写Canny。在这里我们将写Canny。所以让我们运行这个。这样你就得到了Canny图像，模糊图像和灰度图像。所以在这里我们可以看到，我们得到了很多曲线和边缘。如果你想减少这个，我们将改变阈值的值。例如。

我们可以将这个设置为200，将这个设置为150。所以让我们再运行一次。在这里你可以看到差异。现在，边缘非常低。接下来，我们将深入研究膨胀。现在，有时我们在检测一个边缘，但由于存在间隙或未正确连接，它不会被检测为一条完整的线。所以我们可以增加边缘的厚度。

所以为了做到这一点，我们将使用图像膨胀。然后我们将写CBv2点diallate。现在这里我们将使用Canny图像，因为我们在谈论边缘。然后我们必须添加一个内核。现在，内核只是一个我们需要定义大小和数值的矩阵。所以在这种情况下，我们需要一个所有值都是1的矩阵。

但我们还需要定义矩阵的大小。正如我之前提到的，有一个库或包帮助我们处理矩阵，而这个库是Ny。但是我们还没有安装它，所以我们将去文件。我们将去Sis。在这里我们将进入我们的项目。😔然后我们将添加numpy。并且我们将点击安装。

安装完成后，我们将返回并导入Ny作为N。每当我们想调用一个函数时，可以写NP点，函数名。所以在这种情况下，我们要定义一个内核。假设我们的内核等于2。Numpy点1，这意味着我们希望所有值为1。我们将定义矩阵的大小。

这是5乘以5。然后我们只是定义对象的类型，即无符号8位整数。这意味着值可以从0到255。所以我们向下走，在这里我们将添加我们的内核。之后，我们需要定义内核移动的迭代次数，这意味着我们实际上需要多少厚度。所以迭代等于2，假设为1。真的吗？

所以我们将复制这个并写上图像膨胀。在这里，我们将写膨胀图像。Dlation。图像。

所以让我们运行这个，在这里你可以看到。😔这是原始的Canny图像，而这是膨胀后的图像。

所以如果我们增加迭代次数，假设我们做一些戏剧性的事情，把它设为五。那么我们将看到一个巨大的变化。

在厚度中。

所以，我们接下来要学习的函数是扩张的相反，叫做腐蚀。因此，我们要让它变得更薄。为了这个，我们将把我们的图像定义为腐蚀图像。等于C2点Ero函数。再次，我们需要定义我们想要腐蚀的图像。所以我们将取扩张图像进行腐蚀。

然后我们需要再次定义内核，所以我们将保持内核不变。再次，我们需要定义迭代次数。所以在这种情况下，我们将设置为，例如，一次。那我们就把这个设置回一。然后我们将添加我们的图像。用于腐蚀。因此，这里是我们的腐蚀图像，这里是我们的扩张图像，以及原始的cadney图像。

OpenCV 基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P9：第6章：图像拼接 - ShowMeAI - BV1zL411377L

现在我们要学习如何将图像连接在一起，这在你有很多图像并且需要反复运行时会很有用。因此，管理所有这些窗口会很困难，所以我们会把所有图像放在一个窗口中。

让我们看看如何做到这一点，我们在资源文件夹中有一个名为 Lina 的图像。我们将用它自己来堆叠，所以首先我们将使用水平堆叠函数。所以在这里，我们将说 Nmpy dot。这些是 Npy 函数，而不是 OpenCV 函数。所以我们将使用 Numpy 的水平堆叠。我们将首先写我们的图像，第一个图像是图像。

然后再次显示图像。所以让我们显示这个，我是 show。让我们显示这个 Cv2。im show。我们的窗口名称是 horizontal。我们会写我们的图像。实际上，最好写成 I G。😔。Horizontal，然后 IMT。Horizontト。所以让我们运行它。😔，看吧。现在我们已经将图像在水平方向上堆叠在一起了。

现在让我们做垂直堆叠。图像垂直等于 NP dot for vertical stack。然后我们将定义图像和图像。所以我们会复制这个。粘贴下来，图像垂直。我们会称之为 vert。好的，现在我们有两幅图像，一个是水平堆叠的，一个是垂直堆叠的。现在这个方法有一些问题。

首先，我们无法调整图像大小，它会保持原样。所以如果我想在右侧再堆叠两幅图像，它会占用整个空间，或者可能会超出框架。另一个问题是，如果图像没有相同数量的通道。

这意味着它们不是 RGB，两个都可能是灰度图像，或者一个是灰度，另一个是 RGB。这样的话就会不工作，所以它们必须有相同数量的通道，因为我们在讨论矩阵。那么解决方案是什么呢？为此，我创建了一个小函数，可以调用它来处理这些问题。所以你需要知道的就是如何调用那个函数。让我们来看看那个函数。

我会在这里复制它。所以，我会。只是。注释掉这一部分。然后在顶部，我会添加这个函数。所以这里就是我们的函数。让我们把它放下来。你不需要担心这个函数的所有细节。你只需知道它如何将图像堆叠在一起，以及如何使用它，这就是你需要知道的。

让我解释一下它是如何工作的。你需要创建一个图像堆叠。例如，你可以说 image.Stack 等于。现在你将调用函数 Stack images，然后如上所述，你必须提到比例，所以你可以将所有图像缩小，也可以放大它们。所以我们假设我们将比例设为 0.5，然后你需要定义图像的矩阵。

假设我有图像，图像和。图像。这将给我们一个需要显示的水平堆叠。因此让我们复制一下。😔，我们将在这里写。图像堆叠。我们将在这里写，图像。なか。所以好了。现在它缩小了，我们有三张图像在一起。所以现在如果我们想要添加垂直堆叠，我们只需添加一个逗号，然后可以再添加一行。

不过，如果你在第一行有三列，那么在第二行也必须有三列，这其实很直观。因此你可以看到，轻松地将所有图像叠加在一起，即使其中一张图像的通道不同，你仍然可以将它们叠加在一起。让我演示一下，图像灰度等于C2点。

CBT颜色，然后我们可以将我们的图像和C2点颜色，BGR转灰，并且我们可以放在中间这里。灰度图像，所以让我们运行一下。好了，你有一个灰度图像与其他图像叠加在一起。

彩色图像。

OpenCV基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P1：第0章：opencv介绍 - ShowMeAI - BV1zL411377L

在三个小时内学习OpenCV。🎼大家好，欢迎来到我的频道，在这个视频中，我们将学习开始使用OpenCV所需的一切。我们将使用Python，因为它是最流行的编程语言之一，并为各个行业开辟了众多就业机会。

😊。

我们将从安装过程开始，一直到创建令人兴奋的项目，如检测颜色、形状、人类甚至车牌。

🎼所以如果你是初学者，不用担心，这门课程适合你。我们将跳过所有自愿的内容，专注于实际实施。

因此，你可以在简历中获得你一直想要的计算机视觉技能。🎼到课程结束时，你将熟悉OpenCV的核心原则，并应用不同的技术来解决实际问题。

如果你想了解更多关于这些项目的内容，不要忘记订阅并点击通知铃铛，因为我每周都会上传视频。所以不再多说，让我们开始吧。

🎼在开始之前，让我们看一下课程结构。🎼我们将从图像介绍开始，然后进行必要的安装。🎼接着我们将学习读取图像、视频和网络摄像头。🎼同时还会涉及一些基本的安全功能。🎼之后，我们将学习如何调整大小和裁剪图像。

🎼然后我们将在图像上绘制不同的形状和文本。🎼从那里我们将深入一些更高级的话题，例如文字透视连接图像。颜色检测、轮廓检测，甚至人脸检测。在理解基本原理后，我们将基于这些核心原则创建三个不同的项目。

🎼这些项目将包括虚拟画板、Bapor Scner和车牌检测器。

OpenCV基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P10：第7章：图像颜色检测识别 - ShowMeAI - BV1zL411377L

所以我们在导入我们的库，同时也在导入名为Labo的资源文件夹中的图像。我们使用IM show函数显示它，并添加延迟，以便它不会消失。所以这是我们的图像，我们的任务是检测图像中的橙色。因此，首先我们将其转换为HSV空间，所以我们会说图像。

HSV现在等于，正如你所记得的，我们一直在使用CVT颜色将其转换为灰度图像。因此，我们将使用相同的函数，C2。颜色将其转换为HSV。因此，我们将说我们希望转换我们的图像，并希望它是c2.dot color。颜色_。BGR到HSV。因此，这将把图像转换为HSV，我们可以复制这个。

然后我们可以检查一下我们的新图像。所以这里是我们的新图像，它是HSV的。我没有写一个新名称，所以它覆盖了HSV。这是原始图像，这是HSV，所以现在我们需要定义一些颜色值。一些我们希望颜色在其中的范围，因此我们将定义色调。

饱和度和数值的限制，在这个限制范围内，如果图像区域在这个颜色范围内，我们将抓取它，所以让我们这样做。但是需要注意的是，我们实际上并不知道这个特定橙色所需的最小和最大值。

我们将要做的是引入一些被称为滑块的东西，这将帮助我们实时调整值，以便找到我们颜色的最佳最小值和最大值。因此，为了引入滑块，我们将创建它。让我们在顶部创建它。

因此，我们将创建一个新窗口，比如命名为滑块。因此我们将说c2.dot命名窗口，我们将其称为track。Mars，然后我们将调整其大小，以便它看起来不那么奇怪，我们将在这里写滑块。现在这个名称应该是相同的，所以请记住不要拼写错误，然后我们需要定义大小。

假设640乘以240。然后我们将创建我们的第一个滑块，CB2.dot。创建，现在我们正在使用创建滑块函数。请记住，这里的T是大写的，因此我们首先将定义我们将使用此滑块更改的值。因此，这只是一个名称，我们可以写任何东西。我们将要更改的第一个值将是h的最小值。

接下来，我们将定义哪个窗口上放置这个滑块，因此我们已经将窗口命名为滑块，因此我们现在将使用它。我们必须定义当前值，因此当脚本运行时，它将使用什么初始值运行，我们将其设置为0，而我们h的最大值现在如你所知这里的最大值是360，但我们在这里没有360。

打开C，我们有直到1，79，这基本上是1，80个值。所以我们将放179，最后我们必须调用一个函数，每次滑块变化时都会运行这个函数，所以每次用户更改滑块时，它将调用这个函数，但我们将以另一种方式获取值，我稍后会展示如何使用，但现在我们确实需要定义这个函数，但我们可以说这是一个空函数。

在顶部，我们可以定义。空的。我们可以说只是传递。这就是了。这基本上不会做任何事情，所以这就是你创建滑块的方法，现在你需要做的就是运行一下看看会发生什么。哦。好的，所以一旦我们运行它，我们就会收到这个错误，提示c2。t resize。其实不是resize，而是resize window。所以我们将其改为resize window，然后再玩一次。

我们应该有一个，是的，我们在这里有滑块，所以我们有h最小值，你可以看到值基本上在变化。我们缺少的是，我们只需在这里放一些东西，它将接受一个参数，就这样。我们将再次运行，如果我们再次使用滑块。现在你可以看到U值在变化。最小值是零，最大值是179。

我们需要多少个值，我们需要六个值，因为我们将有h最小值，然后是h最大值。然后是饱和度最小值、饱和度最大值、值最小值和值最大值。所以我们将复制这个几次。然后我们将其改为Max。然后我们将其改为饱和度。饱和度，然后我们再次将其改为max。

最小值保持不变。这将是值。这将是值，这将是最大值。所以现在这些值的范围是从零到2，5，5。所以我们将写255，初始值我们保持不变，但对于最大值我们将保持在最大。所以这里我们将放179，这里我们放255，这里我们放255。所以如果我们现在运行它。

我们将有六个滑块可以移动。这很好。😔，是的，这基本上很好。那么接下来我们要做的是读取这些滑块值，以便我们可以应用到我们的图像上。所以在这里我们将使用获取滑块位置函数来获取我们的值。因此我们将说我们的边缘最小值基本上等于C2。CV2点获取。滑块。位置。

所以我们来写一下，我们现在讨论的是哪个值，这里的拼写必须完全相同。所以我们将在这里写下这个，然后我们要说它属于哪个滑块窗口？

所以我们的窗口名称是滑块。我将复制这个。然后在这里粘贴。所以确认一下。我们可以打印。边缘_最小值。现在，为了获得值，我们需要将其放入循环中，因为我们必须一次又一次地运行以保持获取那个值。因此，我们需要将图像改为摄像头或者。

只需添加一个循环，以便我们可以在这里写。是的。我们希望它持续运行。我们也会把这个放进去。因此，与其增加复杂性，我们只需在这里放一个，这就足够了。目前我们可以看到值是0。如果我们改变它，你可以看到值一直在变化。对吧。接下来。

我们将对所有这些进行应用。我们将复制这个，以便我们拥有所有的值。因此，我们将重复五次。这一次，将是最大值。然后是最小值和最大值，然后是最小值和最大值。然后我们将有饱和度。好的。然后我们有饱和度，然后是值。然后是值。就这样。

然后我们会在这里写最大值，这里是饱和度。饱和度，然后是最大值。这里是最小值，然后是值。然后，最大值。我们可以将它们全部打印出来，以确保它是正确的。我们将说H最小值。然后。H最大值。然后我们会说S最小值。S最大值和值。值。

最小值和最大值。那么我们来看看效果如何。😔，所以我们得到了017902550和255。因此，如果我改变我的值，你会看到滑动条实际上实时更改这些值。现在我们有了色相、饱和度和亮度的最小和最大范围。我们将使用这些值来过滤图像，以便在该范围内获取特定图像。

在该范围内的特定颜色。因此，现在我们将创建一个掩码，我们将说掩码。等于Cv2.inRange。因此，我们正在创建一个在这些颜色范围内的掩码。那么我们在谈论哪幅图像，我们在谈论。HSV图像，然后我们必须提供最小和最大范围。

我们将说这是下限，我们将说。这是上限。现在我们需要定义这个下限和上限，因此我们在这里写，让我们先处理下限。下限等于2。我们将创建一个N数组，所以让我在这里添加。导入numpy。作为MP。现在在这里，我们将添加一个N数组，所以N。数组。

然后我们将创建最小数组，即边缘最小值。然后我们有S最小值。然后我们有值最小值。唔发。他就没了么。以同样的方式，我们将为最大值做同样的事情，因此我们将说上限等于numpy.array，我们将添加最大限制。即Em。然后是S最大值。然后是vmax。好的，所以这将给我们掩码。

基本上，它将过滤并给我们该颜色的过滤图像。我们来看看效果如何。或者不需要复制。我们可以直接把这个粘贴在这里，我们可以说这是掩码，这将是。😔，掩码。运行一下，我们得到了掩码，这里有原始图像，这里有滑动条。

所以如果我移动这个，你可以看到图像变化的值。所以我们想把所有不需要的颜色保留为黑色，而把需要的颜色保留为白色。所以如果我想检测橙色，我会说这非常好。因此，我建议不断调整值，尽量让它更加平滑。最终。

你将获得一些不错的结果。现在我们有这些值。我们可以把它们作为我们的初始值。所以我们有019、110、4153和255，所以我们可以回到这里。我们仍然可以打开我们的轨迹条。然后我们可以在这里向上移动。让我把它放在一旁，我可以看看是什么。

所以这是零，然后这是19，这个是110。这个是2，40。然后我们有153。然后是255。所以现在如果我再次运行这个，默认情况下，我将得到蒙版。

对，接下来我们可以做什么。

我们可以得到我们的结果，这将是我们的原始图像。因此，我们不再得到这个黑白蒙版，而是得到实际的彩色部分，这里是橙色。我们可以通过使用这个蒙版来做到这一点。我们将创建一张新图像，所以我们可以说图像结果等于2。

我们将使用与运算，所以我们有位运算符。与运算，它将把两幅图像加在一起以创建一幅新图像。基本上，它检查两幅图像，在像素都存在的地方，它将其视为“是”或“1”。并将其存储在新图像中。

所以我们要做的是，我们有一个想要使用的原始图像。而我们的新图像将与原始图像相似，但会应用一个蒙版。这是我们之前创建的那个蒙版。让我们来看一下图像结果。图像结果，我们应该在这里更改名称。

让我们运行这个。好了，现在我们得到了彩色图像，所以如果你没有明白，基本上我们正在检查这两幅图像。

蒙版和原始图像，我们正在检查这些白色像素，看看我们从这个图像中得到什么，并从中创建一张全新的图像。

这就是我们正在做的事情。因此，我们可以做的一件事是添加我们上一章的功能，其中我们合并了图像，这样我们就不必一次又一次地处理所有这些图像。所以如果我们回到之前的章节，我们有堆叠函数。

我们可以复制这个并把它带到这里。是的，让我们把它带到这里，然后现在我们可以向下。这是顺便提一下，跟踪函数，所以抱歉是堆叠函数。所以它是堆叠图像。所以我们可以向下走，而不是单独显示所有这些图像。我们可以只显示堆叠图像。我们可以说是堆叠。或者我们可以说I M G堆叠。

I M D 堆栈仍然相等。现在我们必须编写我们的函数，内容是。股票图像。我们必须定义比例，比例。让我们将其保持在0.6。然后我们必须定义图像数组。因此我们要在这里放。我们将把我们需要的图像放在这里，所以我们可以放。两个图像，然后两个图像。好的。

所以我们将创建IMG，然后创建IM G HSV。然后在新的角色中，我们可以创建。我们可以添加遮罩，然后是图像。结果。接下来，我们只需要显示最终图像。所以我们可以说开始。图像，我们将在这里写IMD样式。现在让我们移除所有这些，然后再玩一次。

看，这样我们就有了一幅整齐的图像，所有这些图像堆叠在一起，向我们展示了所有的值。所以现在我们可以在一侧查看轨道部分，并且可以实时看到结果的直接应用。所以，让我们检查一下结果是什么。是的，就是这样。所以这就是你如何检测颜色。

OpenCV基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P13：项目1：VR绘画 - ShowMeAI - BV1zL411377L

对于这个项目，我们需要找到我们的颜色，并需要使用网络摄像头找到它，然后我们可以在找到颜色的地方放置不同的点，以创建绘画示例。所以我们首先需要网络摄像头，所以我们将从不同的项目中提取代码，然后将它们合并，以便我们可以看到如何有效地创建不同的项目，所以我们要回到第一章。

这里是我们的网络摄像头代码，所以我们将复制这个。然后我们会把它粘贴到我们的项目中。正如我们所见，我们正在导入我们的库，设置帧的宽度和高度，这些是ID号三和ID号四，然后我们还在设置亮度，设为150，然后我们的设备现在不是零，而应该是1。

然后我们进入宽循环，在这里我们获取图像，然后使用IM显示函数展示它，这差不多就是这样。所以如果我现在运行这个，它应该会显示网络摄像头。就这样。这里是我们的网络摄像头。

让我们看看是否能看到，是的，清晰可见。所以一旦我们有了这个，接下来的步骤是找到我们的颜色，为了找到我们的颜色，我们需要引入颜色检测的代码，这在第7章或第6章。不是第7章。所以这里是代码，我们不需要堆叠。

我们试图简化它。所以我们不需要那个。我们将要做的是复制我们边缘检测的主要代码。这基本上就是上限、下限和掩模。所以这是我们所需的主要内容。我们还需要将其转换为HSV空间。所以将普通图像转换为HSV。

所以让我们先复制这个，我们将在这里复制它。然后我们将定义一个函数来查找我们的颜色。所以我们会说，查找颜色。然后我们将输入一张图像。至少现在我们会把它保持为一张图像，然后我们会将这张图像转换为HSV空间。

然后我们将使用我们的上限和下限。2。所以，让我去掉那个。在这里我们有上限和下限，然后我们能做什么呢。我们可以看看它是否正常工作，所以cv2。我展示。我们可以放，比如，图像，我们需要展示我们的掩模。这只是为了测试，我们稍后会去掉它。

所以我们不想只找一种颜色。我们想找到不同的颜色。因此每当我们调用函数找到颜色时，我们想找到所有不同类型的颜色以及存在的内容。我们希望将其视为输出。所以我们可以做的是。在这里顶部。我们可以定义一些作为我们颜色的最小和最大色调的列表。

我所说的是什么意思？让我写下来。我们将说我的颜色。等于一个列表。现在。这是一个列表。让我。常见的盘，烦人。所以我的颜色基本上是我们想要检测的颜色列表。因此我们需要给出最小和最大色调和饱和度值，为此我写了一段名为颜色选择器的代码，基本上它帮助我们使用网络摄像头选择正确的色调和饱和度值，所以这几乎是相同的代码，但增加了我们在颜色章节中使用的网络摄像头。

在这里我们有我们的网络摄像头，颜色是橙色，所以让我找出它的值。你需要做的是把橙色保持为白色。

其余的你需要删除。所以在这里你可以看到。你需要一直向下。是的。我会说这是一个好点，所以如果我把它移动一下，也还不错。但我的手的颜色也被检测到了，所以我们需要把它去掉。😔，把它稍微往下调一点。这样就好多了。所以我们需要记下这些值。

所以是5，107，019，255，所以我们将创建一个列表。

在这里，在那个列表里，我们要把这些值写下来，所以让我把它写下来。我们有五个。我们有五个。5，10，7，0，19，2，55，然后255。这些是我们的值。你可以在这里看到。因此我们将创建一个这些值的列表，包含不同类型的颜色。在哪里。哦，发生了什么？我们将写下我们想要检测的所有不同颜色类型。

所以我已经为蓝色、非蓝色、紫色和绿色做了这些，我们就复制一下这些值。这是其中一个值。然后我们还有另一个值。在这里。这些是我们的值。所以第一个是橙色，然后是紫色，接着是绿色。这些是你可以从颜色选择器中找到的值。一旦我们完成这些。

现在我们可以简单地。创建我们的掩膜。所以在这里。我们可以看到。没问题，我们需要添加nupi。所以。导入数字。需要N。我们需要做的第二件事是。写下我们的值。所以我们知道这里的部分基本上是前面三个值。然后这一部分是其他三个值，抱歉，是这里的其他三个值。

所以我们能做的就是简单地写下。那。我们的。你把我的颜色列表叫什么。基本上。我的颜色。然后我们可以定义，比如说我们选择第一个元素，也就是零。然后我们写下从0开始。从0到3，我们需要这些作为第一个元素。所以。我们可以在这里定义需要我的颜色作为输入。然后我们可以在这里做同样的事情。

这将是上限，从三到六。所以这应该给我们其中一个，也就是第一个，我认为是橙色，所以让我们运行它。这是我们需要运行的之前的代码。项目1。所以让我们运行它。现在我们也需要调用这个函数。所以在这里之后，我们要调用我们的函数。嗯。

我的颜色。所以让我们转动一下。

看吧，我们得到了掩模，如果我放入我的橙色。颜色。你可以看到它被正确检测到了。但问题是我们仅仅检测到了橙色。我们需要检测到这个列表中的所有颜色。为此。我们需要添加一个for循环，这样我们可以保存。

假设颜色。我的颜色中的颜色，对于这些颜色，我们将创建一个掩模。所以我们不需要写下这个，我们可以用颜色来替换它。颜色，然后再次。颜色。因此，如果我们想显示出来。我们不能有一个通用的名字。我们需要给一个变化的名字。让我们使用。所以第一个元素对它们每一个都是不同的。

所以我们可以把它作为一个名字，所以我们可以说字符串，然后颜色。第一个元素。这应该给我们三个不同的窗口。所以如果我们运行它。

看吧，所以我们得到了三个不同的窗口。暂时忘记命名，我们只是测试一下，如果我放入橙色，我可以看到橙色。如果我放入紫色，我可以看到紫色，然后如果我放入绿色，我可以看到第三个绿色的。如果我想添加更多颜色，我可以简单地将它添加到列表中，这样就能给我。

更多颜色，比如说，如果我现在移除这个。让我移除它，这样只会给我两个掩模。所以它将不再显示绿色。

通过这种方式，我们创建了某种通用的东西，可以用于多种颜色，所以你可以不断添加。现在对于我们检测到的每个掩模，让我注释掉这个。对于我们检测到的每个掩模，我们需要找出在图像中找到的这个对象的位置。现在要找到这个，我们需要获得轮廓，并需要近似包围框，以便找到对象的位置。

为此，我们需要进入我们前几章的代码中，我们学习了如何找到轮廓，如果我们回去。这是找到轮廓的代码。因此，我们要做的是直接获取这个函数。我们不需要区分不同的形状，所以我们会一直获取到我们的边界框。我们将复制这个。在项目中，我们将粘贴它。这里。

这是我们的获取轮廓函数，现在我们需要稍微更改一下，以便获得我们所需的相关信息。因此，改变的东西不多。让我们去掉任何东西。图像轮廓。好吧。我们可以创建一个新图像。我们可以说，假设图像。结果等于图像拷贝。因此，这将是包含所有最终信息的图像。

所以所有的绘图和所有内容都将在这个图像上，因此我们可以复制图像结果并在这里替换。所以它将在这个图像上绘制轮廓。然后。我们不需要的，好的。我们可以去掉参数，不需要长度或对象。就这些。所以我们现在可以做的就是看看我们是否在正确的轨道上。

我们只需要看看它是否正确打印。因此从寻找颜色中，我们将发送我们遮罩的图像来找到轮廓，所以我们会发送这个。我们会说获取轮廓，然后发送遮罩。因为我们在调用这个函数，它应该在这个图像上绘制，让我们看看是否有效。那么发生了什么，好吧，我的意思是，是的。

我们移除了那个，因此不应该显示任何遮罩，让我们试试看。橙色，绿色。紫色，所以它们都没有很好地工作。让我们找出原因。当我们发送遮罩时。哦，好吧，因为我们没有在这里放图像结果。所以我们需要显示图像结果，因为那才是有元素的地方。让我们运行一下，看看，橙色，绿色和紫色，完美。

现在我们知道我们得到了那些，并且周围有边界框。我们需要做的就是发送这些值。现在我们可以发送中心点。但是我们想从笔尖开始绘制，而不是从检测到的物体的中心开始。因此我们会发送笔尖而不是中心。我们要做的是返回。

所以这里我们将返回。我们将返回x的值，加上我们的宽度，除以二。因此它在中心。然后我们将按原样发送y的值。所以这将给我们笔尖的顶部点以及它的中心。如果没有，如果不大于500或者没有检测到，我们仍然需要返回一些东西。

所以我们需要将这些声明为零，我们可以说x，y，w和高度。以防我们稍后需要它，我们可以将它们全部设为零。因此，我们可以获得这些。这将返回这个值，所以我们需要在这里获取这个值，以便我们可以使用它，所以我们将其放在这里作为x和y。获得该值后，我们可以在周围绘制一个圆圈，所以我们可以说Cv2.dot.circle。

我们需要在图像结果上绘制它。我们的中心点将是x和y。然后我们将定义半径，假设为10，然后我们需要定义颜色，暂时设为25，5，0和0。然后我们将写C2.dot.filled，因为我们希望它填充。因此，如果我们现在运行看看会发生什么。如果我去这里，是的。

我现在得到了蓝色点，我可以看到。我得到了正确的点。现在再次，这是边界框的中心，所以如果我围绕边界框旋转，它将是边界框的中心，而不是轮廓的中心。解决这个问题有点棘手，所以我们不打算深入细节，但现在如果我们保持笔直应该没问题。

我们需要更改的一件事是颜色，所以它不应该是蓝色。它应该是我们正在检测的颜色。因此，我们可以移除轮廓。我们不再需要轮廓，我们知道我们正在正确地检测，但我们需要更改这些对象的颜色，因此我们需要定义我们的颜色值，例如。

如果检测到这个，我的绘图颜色应该是什么？我们可以说这就是我的颜色值。再一次，我们需要将其创建为一个列表，并在该列表中定义所有我们想要显示的颜色。我们有三个，因此我们将定义三个。接下来，我们将在这里写下我们的值。

那么你如何找到这些值呢？在这里我们可以看到一个示例网站，你可以找到RGB值。如果我选择橙色，现在橙色，如果我点击它，你可以看到它是2，55，153和51。这就是我的橙色值。那么我可以在我的代码中使用这些值。

但是再次提醒，你必须确保以BGR的格式书写。所以让我在这里写下来，它是BGR，而不是RGB。因此我们这里将有51，然后153，然后255。同样，我们可以找到紫色和绿色，对于紫色，它是255，0和255，对于绿色，我们都知道它是BGR，所以它应该是0，255和0。

这些是我们的颜色，现在我们可以根据这些值绘制圆圈的颜色。发生了什么？我们可以说，我们需要我的颜色值作为输入。如果我们继续，当我们发送这些值时，我们也需要我的颜色值，所以我们可以说。我们可以说，好吧，我们需要一个计数器来实际计算次数，所以我们将计数设为0。

每次计数时，我们需要知道我们在谈论哪个颜色。所以我们可以在这里说count加1。因此，在我们主要的蓝色这里。我们可以说my color values。我需要获取我计数器索引的值。因此，我的计数现在。不管我的计数是什么，我需要从这个我们所称的列表中获取那个值。

所以如果计数等于0，它将得到这个值。计数是1，它将得到这个值。所以我可以在这里写。呃。计数。所以这应该给我们我们所称的标记的正确颜色。让我们运行一下。如果我有紫色，它给我紫色，如果我有橙色，它给我橙色，稍微有点难以看到。

但是你得到了手势，然后你有绿色，所以我们得到了绿色。这很好，我们得到了正确的颜色和正确的值。现在我们需要做的是绘制这些点。因此，绘制实际上很简单，我们将创建一个点的列表，每次都显示它，我们将循环它。

所以在底部，我们先去顶部，我们将创建一个名为My pointss的列表。在这个列表中，我们将有三样东西，我们将有x的值。我们将有y的值，我们将有颜色的值，或者不是颜色本身。让我们放置颜色的索引。所以我们可以说，如果它是零，它将是这种颜色，如果是1。

它将是这种颜色，依此类推。因此，我们可以放置这个而不是实际的东西。让我复制一下。让我把它放在这里作为注释。所以。所以我们可以说我们可以循环这个my point，每次检查x和y的值，并在这个点绘制这个颜色的圆圈。

所以这很简单。为了做到这一点，我们可以创建一个新的函数。称为drawaw在画布上。所以，我们可以把它命名为Draw。在画布上。接下来，我们需要什么呢？我，是的。我们需要那些点。我们还需要颜色值。带颜色的值。因此，我们将说对每一个点。在我的点中。

我们需要做的是迭代，我们只需要绘制一个圆圈。让我从上面复制。这里。你复制它。这个圆圈。我们可以把它放在这里，我们需要做的是在我们的图像结果上绘制。因此，这一次，值是在点内。

所以我们会说point的第0位是我们的x，point的第1位是我们的y，point的第2位是我们的ID。所以这将给我们这个颜色的点。现在，我们需要做的是每当我们找到颜色时。我们需要发送给绘制。好的。因此，我们可以说我们的新点。

点等于我们从颜色中得到的任何值。然后我们需要绘制它们。因此为了绘制它们，或者我们应该先这样做，让我们回到上面，并在这里返回一些东西。因此一旦我们找到颜色，我们需要返回我们的新点。但是我们需要确保这些点没有被正确检测，这些不是00，如果是00。

如果x和y，如果我们返回的值是00，那么我们不需要做任何事情。我们不需要绘制它。它将仅仅添加到内存中。所以我们可以说在计数之前。我们可以看到如果x不等于0。并且如果y不等于0。那么只有在这种情况下我们才会附加我们的点。所以我们将说新点。点附加。

我们将说我们要写下X、Y和计数，因为那是我们的ID，我们需要每次定义新点。因此每次新点都会变化，所以它将从一个空列表开始，然后附加并返回这些值。所以在这里我们需要写返回。不在循环中，我们需要在这里写返回。

然后我们将返回我们的点。因此每次它都会添加到这些点上。它将把这些新点发送到这里。现在一旦我们有了新点，我们可以检查新点是否实际上存在。所以我们将说，如果我们新点的长度。

我们得到的东西并不等于0。那么，哦，那是什么呢？等于0。那么我们需要遍历我们的点，所以对于新点。嗯，新点。我们将添加我的点。我的点，思想附加。我们将添加我们的新点。那么，为什么我们在这里放一个完整的循环，因为我们得到的是一个列表，所以我们不能将一个列表放在另一个列表里面，然后在画布上运行我们的代码，因为那样是不行的，我们需要所有的点，而不是一个列表里面有一个列表，所以这是一个列表，我们需要将其分解为点，这就是我们在这里放循环的原因。所以对于新点，在我们的新点中，我们将逐个添加到我们的点中。

最后，我们需要做的就是在这些点可用的情况下绘制它们，所以我们可以说如果我的点的长度。不等于0。那么我们需要绘制它们，因此绘制。绘制在画布上和我的点，并使用我的颜色值。所以这应该在正确的值中绘制所有颜色，让我们看看。

所以这里有我们的紫色，来吧，你可以看到它在绘制紫色。然后我们有橙色，它在绘制橙色。然后我们有绿色，所以它在绘制绿色。所以你看，这很简单，而且是一个非常通用的代码，你可以在其上进行添加，它并不是硬编码的，这种颜色等于这种，这种颜色等于那种，我们并没有创建很多硬编码的掩码并将它们放在一起。因此，如果你想添加一种新颜色，这非常简单，你需要做的就是去添加到我的颜色和我的颜色值。例如，如果我想做蓝色。

我检查了蓝色的值，你可以使用颜色选择器代码找到这些值。你可以添加这些，我们已经知道蓝色的基本值是BGR，因此它将是2550和0，所以这将添加蓝色。如果我们现在运行它，让我在这里尝试一下蓝色。

就这样。所以现在它也能检测蓝色了。这就是添加更多颜色的简单方法。好在它能够同时检测所有颜色。如果我们看看这里，我们有这四种颜色，可以同时检测它们。你可以看到效果不错。

OpenCV基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P2：第0章：图像知识介绍 - ShowMeAI - BV1zL411377L

所以让我们从图像介绍开始。那么图像是由什么组成的呢？假设我想显示数字3。我将采用一个框的数组，每个框可以是填充或空的。

所以要写数字3，我们会给一些框上色以创建那个形状。现在，一些框是白色的，而一些框是黑色的。我们可以将所有黑色框表示为0，所有白色框表示为1。在这个例子中，我们有10乘10个框。如果我们想要更多细节，可以增加框的数量。实际上。

这些框是像素。你可能听说过VGA、HD、全高清和4K。这些都代表固定数量的像素。例如，VGA是640乘480。

HD的分辨率是1280乘720。这意味着VGA的宽度是640个像素，高度是480个像素。目前，图像只有两种颜色，黑色和白色。这被称为二值图像。为了获得更多细节，我们可以有一个包含更多级别的图像。这意味着我们将拥有一个值的范围，而不仅仅是0和1。

在这里，我们可以看到2、6和16级灰度的区别，但图像仍然不是很清晰，所以我们将使用8位值。这将为我们提供256的分辨率，其中0是黑色，255是白色。这意味着我们现在在白色和黑色之间有254种颜色。换句话说。

我们有254种灰度。

这个图像现在被称为灰度图像。

对于彩色图像，我们有三种灰度图像，分别表示红色、绿色和蓝色的强度。简而言之，RGB将这些图像相加可以得到完整的彩色图像。这意味着一个彩色VGA图像的分辨率是640乘480乘3。

OpenCV基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P4：第1章：图像视频摄像头数据读取 - ShowMeAI - BV1zL411377L

所以我们将学习的第一件事是如何读取图像、视频和摄像头。所以为了读取图像，我们有一个名为I am read的函数。所以让我们开始声明一个变量来存储图像，我们将称之为IMg。然后我们将使用我们的包，CVv2。

然后在那个包中，我们有函数I am read。现在，这意味着我们在读取一张图像。现在，我们只需要提到这张图像所在的路径。所以我创建了一个resources文件夹，里面有图像Lina.pNG。所以，我们将定义这个路径。所以它在resources中，然后是Lena.pNg。

所以这将从我们的resources文件夹中导入图像，但现在我们需要显示它。所以为了显示，我们有一个叫做IM show的函数，我们将使用我们的包CB2。im show，在IM show中我们必须定义两个参数。第一个是窗口的名称。所以我们可以说是我们的输出。然后我们需要定义我们想显示哪张图像。

所以我们将说IMG。所以让我们运行这个。现在图像确实出现了，但它立刻消失了。所以为了添加延迟，以便我们可以看到，我们将写CVv2。weight key，然后添加延迟，如果我们输入0，则表示无限延迟。但如果我们添加一个值，意味着那么多毫秒，例如1000将意味着一秒。所以目前为止。

我们将输入0并运行。所以这是我们的输出图像。接下来我们将学习如何导入视频。所以我们在resources文件夹中有一个名为test video的视频，所以让我们导入它。我们将删除之前的内容。所以现在我们将创建一个视频捕捉对象。

所以我们称之为cap。C，V2。点。视频捕捉。所以现在在这个视频捕捉中，我们只需要定义视频所在的路径。我们将输入resources。然后，我们将说。我们会提到视频的名称，也就是test。下划线video点M4。所以这将导入我们的视频，但现在我们需要显示它，正如你所知道的，视频只是一系列图像。

所以我们需要一个宽循环来逐帧处理。所以我们将添加一个白循环。喂。Zhu。现在我们将捕捉我们的图像。所以所有这些将做的就是将我们的图像保存在这个变量中，然后告诉我们是否成功完成。所以这个变量将是布尔值，即true或false。接下来，我们将展示这个结果。

所以我们将像之前一样使用IM show函数，然后我们将输入我们的视频，例如。然后我们会说I G。现在我们将添加一些内容，增加延迟并等待键盘Q按下，如果我们想退出循环。所以你不需要详细了解它是如何工作的。

你需要知道的是，这会增加一个延迟，并寻找按键的单词“key pressQ”来打破循环。所以让我们运行这个，看看会发生什么。这里我们可以看到我们的视频。现在，这个视频相当短，所以它播放后就关闭了。你可以看到这里。如果我们按“cu”，它将会关闭。所以很好。现在我们已经成功导入了一个视频。接下来。

我们将学习如何使用网络摄像头。使用网络摄像头与导入视频非常相似。所以我们将写下摄像头的ID，而不是文件路径。如果你只有一个网络摄像头或者有一个连接的笔记本电脑，你可以按零，这将使用默认的网络摄像头。如果你有多个摄像头，可以在过程中添加ID。现在我们将创建这个摄像头对象。

然后我们将为它定义一些参数。我们希望它有一个特定的大小。所以我们将定义宽度，ID号为3，设置为640。然后我们将定义高度，ID号为4，设置为480。接下来的代码大致保持不变。所以让我们运行这个，看看会发生什么。这里你可以看到我摄像头的实时画面。

所以你可以看到，亮度不是很理想。所以我们可以从设置中改变亮度，ID为10。比如我们可以写100。现在你可以看到，亮度要舒服得多。

OpenCV基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P6：第3章：图像缩放与截取 - ShowMeAI - BV1zL411377L

让我们看一下Open TV约定。

在数学中，绘制图形时，X轴的正方向朝东，Y轴的正方向朝北。在Open C中，X轴是一样的，但正Y轴朝南。为了更进一步理解，我们来看一张图像。假设这张图像是640×480，图像的原点就在这一点。

此时，最大宽度和高度将是。看看更多的点，我们可以进一步理解约定。

首先我们要学习如何调整图像的大小。现在要调整图像大小，我们需要知道图像的当前大小。这里我们有一个简单的例子，我们导入库，然后导入一个名为Lamo的图像，这是兰博基尼的缩写，我们只是在展示它，让我们看看我们的图像。

所以这是我们的图像。现在要找到图像的大小，我们将写打印。然后我们将检查图像的形状，所以用 It dot shape。如果我们再运行一次，它会给我们462×623×3。第一个462是高度，623是宽度，3是通道的数量，即BGR。现在，为了调整大小。

我们将使用调整大小函数。所以我们将写。IM G。调整大小等于C2点res。在这里我们将写我们想要调整大小的图像，即我们的主图像。然后我们需要定义调整大小的宽度和高度。这里我们首先定义宽度，然后是高度，假设我们想把宽度设置为。

目前我们有623。让我们把它改为300。我们可以把高度改为200。现在让我们展示这个图像。这里是我们的原始图像，下面是我们调整大小后的图像。正如你所看到的，我们成功地调整了像素数量。如果你想再次检查形状，可以写打印，而不是图像，我们可以写图像调整大小。

所以如果你再打印一次，你可以看到上面的原始图像和下面的调整大小的图像。以同样的方式，你也可以增加像素数量，但当然它不会增加质量，但可以增加像素数量。例如，1000×500。所以这里我们有一个拉伸的图像。所以是的，你也可以这样做。

接下来我们要学习如何裁剪图像，裁剪在你想要图像的特定部分时非常有用。现在图像本身只是一个像素的矩阵或数组。所以我们可以以数组或矩阵的形式删除它。我们可以写。图像，裁剪。等于。图像，这就是我们想裁剪的主图像。

但是现在我们不需要使用OpenCV函数。我们可以直接使用矩阵功能，所以我们可以定义宽度和高度的起点和终点。例如，现在有点棘手，因为高度先来，然后在OpenCV函数中宽度在上面。

宽度先来，然后是高度，所以这里我们先有高度，然后是宽度。😊。所以我们想定义想要保持的高度，我们设定最大高度为462，所以我们打算保持从0到200，范围是0到200。

然后我们要保持的宽度，比如说，从200到500。所以，从200到500。现在我们要显示这个。所以让我们运行它。😔，你看，这就是你裁剪后的图像，所以我们可以隐藏我们的。重新裁剪的图像。然后你看，这就是直接来自主图像的裁剪图像，如果我们能把它放回去。

它会到这里，是的。所以我们所做的是，如果可以的话。是的，如果我们可以这样做。我们可以更好地看到数字，所以高度我们从0裁剪到200。这是你的起点0，到这里是200，所以这个区域到这里是200。然后宽度是从200开始，所以我们从这个点200开始，一直到500。

这是这个要点。所以这就是你如何裁剪一张图片。

OpenCV基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P7：第4章：形状与文本 - ShowMeAI - BV1zL411377L

现在我们要学习如何在图像上绘制形状，我们将学习如何绘制线条、矩形和圆形，同时还会学习如何在图像上放置文本。所以首先我们将创建一个填充了零的矩阵，现在零表示黑色。我们将使用Ny库来实际创建我们的矩阵。所以我们将写图像。

等于NP.dot zeros。现在，在里面，我们将定义我们的矩阵的大小，将是512乘以512。然后我们只需显示我们的图像。所以让我们在这里写下来。Cv2.dot im show。然后我们有窗口，即图像，然后是图像本身。所以如果我们运行这个。😔，你会看到，这就是我们的块状图像。现在，这就是。

灰度图像因为它只有512乘以512的像素或方块。我们可以通过打印出来来确认这一点，我们可以写图像.dot shape。这是检查图像或矩阵的维度的方式。正如我们在这里提到的那样，这是512乘以512。但现在如果我们想添加颜色功能。

我们必须给它三个通道。所以我们将写这是512，或者这是512乘以512乘以3。这给了我们从0到255的值。接下来我们要看看如何给这张图像上色。如果我们想给整个图像上色，我们只需写IG。我们会说我们想为整张图像做这件事，然后定义颜色，例如我想让它变成蓝色，所以我会写255。

255和0和0，所以如果我们现在运行这个，你会看到整个图像变成蓝色。现在，中间的这个冒号是什么意思？如果你还记得前一章我们做裁剪时，使用了宽度和高度的限制。这是同样的概念。所以例如，如果我在这里写200和300，然后我会写另一个范围。

第一个范围是高度，第二个范围是宽度。所以假设我在这里写100到300。如果我们现在运行这个，你会看到上色部分仅是我们在这里定义的范围。如果我们想给整个图像上色，我们只需写一个冒号，这意味着它是针对整个图像或整个矩阵的。现在继续，我们将学习如何创建，先把这个恢复为黑色。🤢

让我们也将这一行注释掉。现在，我们将学习如何创建线条。对于线条，我们有Cv2.dot line函数。所以Cv2.dot line。然后我们必须定义我们在谈论哪个图像。所以我们将说IMG，也就是我们的图像。然后我们必须定义线条的起点和终点。

起点，假设我们放00。终点，让我们放30和300。然后我们需要定义颜色，所以我们将说0，然后255。再说255。这将给我们绿色。然后我们可以定义厚度。虽然不重要，但你可以定义厚度，所以假设我们将其设置为三。

所以让我们运行这个。😔，你看，现在我们的图像是绿色的，抱歉。我们的图像现在有了一条绿色的线。它从00开始，延伸到300，300。现在，如果你想把它延伸到尽头，我们可以做的是直接用宽度和高度，而不是给一个数字。所以我们知道图像的宽度和高度可以从形状中获取，形状矩阵有三个元素。

高度、宽度和通道，第一个是0，也就是高度，所以在这个注释中我们必须先定义宽度，我们会在这里写1，然后写image.dot shape。然后我们会写这里的0。这是高度。这是高度，这是宽度。

所以如果我们运行这个，我们应该会得到一条对角线。好的，太好了。接下来我们将继续到矩形，所以我们会写cv2.dot rectangle，遵循相同的约定，你必须写下图像，然后定义点。

假设是0，0，然后我们必须定义结束点。所以那将是角落点，对角点，假设是250和350。好的，然后我们将添加颜色。这次我们改变颜色。所以我们将设置为0，0和2，5，5。然后我们需要定义厚度。所以厚度，假设是2。

让我们运行这个，得到你的矩形。现在你可以增加厚度。但如果你想填充这个区域呢？你不能只是不断增加厚度直到它填满，你知道的。虽然你可以这么做，但这不是个好主意。不过C2实际上有一个功能可以做到这一点，你可以写CVv2.dot filled。

你必须用大写字母书写，这样你才能用它来填充你的矩形。接下来，我们将继续移动到小的部分，先把它放回去。然后，我们将继续到圆形。所以我们会写C2.dot circle，然后我们会写我们的图像。我们必须定义这个圆的中心点。所以我们假设是450。

然后我们必须定义半径，假设是30，然后需要定义颜色。颜色我们可以设置为2,5,5,2,5,5。我觉得这会是某种蓝色的阴影。然后我们把厚度设为5。看看，这里来了。好的，现在你有了这个圆。你可以看到我们的中心点是450，这意味着我们从这里开始到这里，400，从这里到这里是50。

我们已经得到了淡蓝色的效果。接下来，我们要学习如何在图像上添加文本。我们有一个叫做Cv2.t put text的函数。我们会像之前一样写我们的图像，然后定义你想要显示的文本。所以我们可以在这里展示，比如说，open.CV。应该说是Open TV，然后我们会写下起始位置。

假设我们想开始。设置为300，然后。设为百。好的，然后。现在这个有点不同于之前，我们需要定义文本的字体。CV2库中已经有几个字体，但数量不多。不过我们有一些，所以你可以写cv2。font。C we2 dot。Fons，然后会显示出一堆字体。

我们不需要任何花哨的东西。所以我们只会选择第一个。然后我们有了我们的缩放比例。接着。我们有了颜色。我们设为1，50，然后0。然后我们有我们的。厚度。让我们运行一下，看看效果如何。所以你看，我们以绿色写下了Open CVv。让我们，把它稍微调低一点。设为200。好的。

让我给你展示一下厚度和缩放比例对文本的影响。如果我把它调高到2。现在你会看到它变得更大，实际上已经超出图像本身了。所以让我们把它调回1，顺便提一下，你也可以设置小数位。所以你可以写0.5。那样它会变得非常小。

然后你可以定义厚度。例如，我们把它设为1。在这里你可以看到差别。

OpenCV基础教程，安装、原理、实战，3小时带你搞定这个热门计算机视觉工具库！＜实战教程系列＞ - P8：第5章：透视变换 - ShowMeAI - BV1zL411377L

现在我们将学习如何在图像上使用透视以获得其鸟瞰图。我们这里有一张名为cards的图像，位于资源文件夹中，我们所做的就是使用IM show函数显示它。所以如果我们运行这个，我们将得到我们的图像。

我们要做的是尽量将这张黑桃国王变得平坦。因此我们需要这四个点。使用这四个点，我们将应用透视的概念。首先我们要做的是定义扑克牌的四个角点。我已经记下这些数字，我们只需输入它们，因此我们将声明点。

作为一个浮点数数组。在里面，我们将有四个不同的点。所以让我们输入值，我有111。然后我们有2，1，9。这是针对之前提到的这张特定图像和那张特定扑克牌。因此这是188。然后1，54。如果你想获取这些值，你可以在Windows上打开画图。

当你在底部移动光标时，它将给出像素的值。所以。这些是我们的点。现在，对于每一个点，我们需要定义我们所指的哪个角落。这是左上角的第一个点吗？这是最后一个点吗？

所以你必须定义所有这些。在point2中，我们将对其进行定义。Loat 32。然后我们还有四个点。首先，我们有我们的0，0。然后我们有宽度和0。接着是0和高度。最后是V1高度。现在，我们没有定义宽度和高度。这就是为什么会出现错误。所以让我们定义宽度和高度。一个扑克牌通常是2.5乘3.5英寸。

所以我们将保持纵横比。因此我们可以设置为250乘350。现在我们将得到我们的矩阵，即透视变换矩阵。这个矩阵可以通过C2获得，我们有一个函数来获取透视变换。所以，获取P。透视变换，就这样。所以你必须定义这些点，点1和点2。

现在我们可以根据这个矩阵获得输出图像。因此我们可以说图像输出等于C2。点verp透视。Wp。透视，然后我们需要定义我们的源图像。接着我们必须定义我们的矩阵。然后我们必须定义之前定义的宽度和高度。那就是宽度和高度。所以，现在，如果我们输出这个图像。让我们看看C。

B2点I am show。然后，我们可以说。输出。然后我们有我们的图像输出。它是双重的，好的。让我们运行这个。😔，就这样，所以我们基于这些点得到了这张图像的透视效果。

PySpark 大数据处理入门，带你玩转 Python + Spark 大数据操作与分析！＜实战教程系列＞ - P5：L5- Pyspark DataFrames 分组和聚合函数 - ShowMeAI - BV1sL4y147dP

。

大家好，我的名字是 Krisnaak，欢迎来到我的 YouTube 频道。所以伙计们，我们将继续 Pipar 系列，在这段视频中我们将看到分组和聚合函数。😊，我实际上已经创建了大约四个关于 Pipar 的教程，这基本上是第一个教程。这又是数据框的一部分。

我们为什么要再次使用分组聚合函数进行某种数据预处理。让我们开始处理这个特定的数据，为这个特定的问题我创建了一些具有三个特征的数据，比如名称、部门和工资，你有一些数据，比如 Kris 数据科学的工资。

对，类似这样的内容。因此在这里简而言之。如果我想基本了解这个特定数据，可能会有一些部门，其中 Kris 和其他人授课，基于不同的部门，他们获得不同的工资。所以让我们看看如何执行不同的分组和聚合函数，以及我们如何进行预处理或获取一些从这个特定数据中检索的结果。首先我们要做的就是导入 Pipar。

SQL 导入。Spark 会话，和往常一样，我们需要创建一个 Spark 会话。那么在这之后，我们要做什么呢？我将创建一个 Spark 变量。所以我会使用 Spark 会话，点构建器点。应用名称，我想大家一定对此很熟悉。但我再试着给你展示一下。所以让我把它写为 aggregate。点。获取或创建。所以现在我实际上已经创建了一个 Spark 会话。

好吧，如果我去检查我的 Spark 变量，这可能会花一些时间。所以这里是你所有的信息。关于这个特定的 Spark 变量。现在。让我们继续尝试读取数据集。现在，我将写 D F 下划线 pi spark。然后在这里我会写 Sp 点读。点 CSV，CSV 文件名基本上是 test。3 点 CSV。

记住，我会在 Github 上提供这个特定的 CSV 文件。然后我会使用 header 等于 true。逗号推断模式等于2。现在。这是我的 dear 下划线 osscope by spark。接下来我将在下一条语句中写 Df 下划线 cope pipar 点 show。此时你将能够看到我实际上可以看到所有的数据集，这里我有名称。

部门和工资在所有这些特定信息上。如果我真的想查看模式或列，例如哪些列属于什么。就像数据类型，我可以使用 DF 下划线 cope Ipar。点打印模式，现在你可以看到名称是字符串，部门是字符串，工资基本上是一个整数。

现在，让我们执行一些分组操作。首先，我们将从分组操作开始。可能我想按名称分组，并尝试查看平均薪水是多少。你知道吗，假设我们在这里拿一个具体的例子。所以我会写 Pf dot underscorecope bypar dot group by。

假设我想去检查在这个特定数据集中，谁的薪水是最高的。所以我首先按名字分组。如果我执行这个，你可以看到我们将得到一个返回类型为组数据的某个特定内存位置。

你应该始终知道，伙计们，group by 聚合函数是一起工作的。首先，我们需要应用 group by 功能。然后我们需要应用聚合函数。所以在这里，聚合函数我真的想要检查，只需按 dot 然后按 tab。在这里，你将能够看到很多不同的函数示例，比如聚合、平均、计数、最大值、平均值、π 以及很多模式。现在我将做的是使用这个 dot sum，因为我真的需要找出哪个是最高的薪水。

😊，然而在所有这些员工中，谁的薪水是最高的。所以我会说 dot sum。如果我执行它，你将能看到我们得到了一个 sQL dot data frame。里面有姓名和薪水的总和。这非常重要，因为我真的想要薪水的总和。记住，我们不能对字符串应用 sum。这就是为什么它在这里没有执行的原因。

它只是给你名字，因为我们按名字分组。这个 dot sum 将只应用于这个特定的薪水。现在，如果我去写 dot show，你将能够看到。😊Sudanhu 在这里的薪水是最高的 35000。Sunny 有 12000。Krissh 有 19000。

Mahesh 的薪水是 7000。所以如果你去看这里，Sudanhu 基本上在这里。在大数据中。所以如果你计算，总体他的薪水应该是 35000。类似地，你可以计算我在这里的薪水。🤧在这里通过简单计算这一点。你还可以计算 Sunny 的薪水。你也可以看到我的 H。

所以这只是一个例子。在这里我会写一些内容。我们已经进行了分组。做得很好。最高薪水。并且在整个观察中可以确定。我们可以得出结论，Sudanhi 的薪水是最高的。好吧，现在让我们向前迈一步。再向前一步。现在我们将尝试按部门分组，以找出哪个部门提供最高薪水。好的。

我们将进行一个按部门分组的操作。哪个部门提供最高薪水。假设这是我的。这个是我的需求。好的，和不同的需求组合在一起。我只是想给你展示一些例子。所以我将复制这个。南将会做。使用这个部门。好的，然后我基本上将说 dot sum dot show。

如果我执行它，让我看看，部门是一个错误的列名，所以我会写部门，它是部门。所以让我现在写 S。如果我去看看，IOT 在这里给这所有员工的薪资大约是 115000，因为我们在进行总和，大数据给的薪资大约是 15000，数据科学的薪资是 4300。现在假设我去看看大数据这里是 404080008000 和 13000。

130015000，所以我希望我得到的答案是，是的，大数据实际上给我们 15000，所以你可以去计算，假设你想找出平均值，你也可以找到平均值。好吧，让我在这里写，只需复制这个整体内容，粘贴在这里，写我，写而不是总和，我会写平均值，所以默认的平均薪资。

在这里你可以看到，对于某个特定员工，I O T 的薪资大约是 7500。因为这个平均值将基于在该部门工作的人员数量，对吧。所以这样你实际上可以找到。现在，我还可以检查一件事。伙计们，我可以复制这个。我可以尝试找出有多少员工实际上是基于部门工作的。

所以我可以使用 dot count。如果我去执行这个，可能这就是一个方法。好的。现在你会看到在 I O 中有两个人，在大数据中有四个人，在数据科学中也有四个人。所以 4 加 4 加 8，总共有的员工在这里基本上是 10。现在，我还可以直接应用聚合函数来查看。

这些都是一些示例，再次强调，你可以通过让我使用 Df Ppar 进行不同的分组。假设我说 dot aggregate，好吧，在里面我只需提供我的键值对。假设我说，让我找出工资的总和。我想要找出整体的薪资总支出。

所以你将看到总支出大约在 73000 左右。我们也可以直接应用聚合函数，此外，这些都是在应用分组函数后我们基本上应用的聚合函数。现在假设这些可能是薪资，我想要找出假设我举这个例子，我想找出获得最高薪资的人的薪资，抱歉。

所以在这里，我将写 max dot show，而不是 dot sum。现在你可以看到 Sudansha 在这里获得 20000，Krisish 获得 10000，我获得 4000，对吧。所以所有这些特定数据是 Kris 在数据科学中获得的薪资为 10000，所以它基本上挑选了，并没有选择两个记录，但至少当它按名称分组并显示这个特定数据时，你将能够看到。让我们看看我是否也能看到这一点。

所以分组，如果我评分并写下最小值。这里你将能够看到不同记录下的最小值。当我分组时，你将看到Suanhu的最低薪资是5000，而Kris的最低薪资是4000。

我们还可以获取那个特定的信息。现在让我们看看有哪些不同类型的操作。平均值也在其中。所以如果我写AVG，这就和平均数一样。基本上这是可能的平均薪资。你可以查看这些功能，了解这些操作的必要性。

一件重要的事情是，你确实需要进行大量的数据预处理和检索技能。你可以查看这个，并根据自己的需要执行不同的功能。所以我希望你喜欢这个特定的视频。可能在下一个视频中，我将开始介绍Spark Mlib库，我们将解决一些机器学习算法问题。

所以我希望你喜欢这个特定的视频，下周见。祝你有美好的一天，谢谢。

PySpark 大数据处理入门，带你玩转 Python+Spark 大数据操作与分析！＜实战教程系列＞ - P4：L4- Pyspark DataFrames 过滤操作 - ShowMeAI - BV1sL4y147dP

。

大家好，我的名字是 Kushak，欢迎来到我的 YouTube 频道。所以我们将继续这个 Pipar 播放列表系列。当我开始这个系列时，有很多人请求我完成 MysQL 与 Python 的播放列表，别担心。现在既然你们有这个特定的请求，我每天至少会尝试上传一个 Pipar 视频和一个 SQL 视频。我也想完成这个播放列表。

但由于时间原因，我没能创建更多的材料，因此有些滞后，但别担心。主要目的是为你们上传更多的视频，这样你们就能更好地跟随，能够在未来的职业转型中利用这些内容。所以请确保耐心等待，我会并行上传这两个系列，并尽力完成这个播放列表。

是的，大家好，我的名字是 Krna，欢迎来到我的 YouTube 频道。

大家好，今天我们在 Pi Park 数据框的教程中，这个视频我们将讨论过滤操作。😊，过滤操作对于数据预处理技术非常重要。如果你想根据某些条件，某些布尔条件来检索一些记录，我们绝对可以通过过滤操作来实现。

现在大家，请确保你们跟随这个 Pipar 的播放列表，我会随着进展上传更多视频。另外，还有很多人抱怨希望上传 SQL 与 Python 的内容，别担心，我会并行开始上传 SQL 与 Python 的视频。

我很抱歉因为一些延误，我一直忙于某些工作，但我会确保尽量上传所有视频。所以并行的 SQL 与 Python 也会被上传。那么我们开始吧。首先，让我创建一些单元格。今天我使用了一个数据集，一个小数据集，叫做 test1.csv。在这里，我有一些数据，比如姓名、年龄、经验和薪水，我将用这些数据展示一些关于过滤操作的示例。首先，每当你想使用 Pipar 时，必须确保安装所有必要的库。

😊，库，我将使用 from pyspark.sql import SparkSession，这将帮助我们创建一个 Spark 会话，这是我们基本上在使用 Pipar 时的第一步。因此我们将使用 SparkSession.builder.appName。

然后我将我的应用程序命名为data frame，并基本上编写get或create函数。这实际上将帮助我快速创建一个spark会话。我想这对你们每个人来说都是非常熟悉的。现在让我们继续，尝试读取特定的数据集。

所以在这里我要做的就是创建一个变量Df underscoreosco I spark，我将使用这个spark变量.dot read或.dot csv。在这里，我将考虑我的数据集test one。😊，Dot csv。在这里，我将确保选中了这个特定的选项Hesical为true，并在模式中。

physical为true。我想这就是我实际上向你解释的全部内容。然后如果我写D F dot pricepar dot show。在这里你将能够看到你的数据集。好的。它正在读取，我们来看看输出。这个是我的全部输出。现在，伙计们。正如我所展示的，我们将进行。😊，过滤操作。

我将尝试根据一些条件检索一些记录。记住，过滤器在pandas中也是可用的，但在那里你尝试用不同的方式来写。让我向你展示如何使用pie spark进行过滤操作。好的。所以过滤操作。让我把这个做成markdown。这样看起来更大。看起来很棒。

让我再做一些完美的单元。现在，第一步，我该如何进行过滤操作。假设我想找出工资低于20000的人。好的。小于或等于20000。我可以这样写。小于或等于20000。😊，现在为此。我们有两种写法，第一种方式。我将尝试使用过滤操作。

所以你有像.dot filter，这里你只需指定你想要的条件。假设我写工资小于或等于20000。记住，这个工资应该是这里列的同名。当我写.dot show时，你将能够看到这些特定的记录，你会看到小于或等于20000的有四个人Sunny Paul Herun Subumm，在这里你能够看到所有这些信息以及经验，现在这是其中一种方式，可能我只想在设置了这个特定条件后挑选两列。那么我可以这样做，我可以使用这个，然后基本上写.dot select，在这里我将指定我的名字，可能我想要名字和H。

Name comma H。所以.dot shop。我这样做。现在，这就是你可以实际做到的，再次。在这里你可以看到name underscore age实际上是存在的，你能够获取那个特定的信息。在此之后。可能我想做一些操作。你可以实际做小于大于等你想要的任何事情。可能我想放两个不同的条件。那么我应该怎么做。

让我们看看，好的，我会写D D F Ppar点。😊，Fter。这里我将指定我的第一个条件。假设这是一个方法。这是使用过滤操作的一种方式。还有，伙计们，我正在写的这些条件，我也可以写成这样。看这个。如果我写D F pie spark的工资。

假设工资是。😊，小于或等于20000。我也可以这样写。我也会得到相同的输出。所以在这里你会看到相同的输出。现在，假设我想写多个条件。我该怎么写，实际上很简单。我会这样做。这是第一个，这是我的一个条件。

所以我只是要使用这个条件。我也可以使用与操作，你知道的。所以我会说和或任何你想要的操作。可能我想说Df underscorecope pi的工资大于等于2000 20000，而且我可能想要Df ppar的工资。

😊，工资。大于等于15000。所以我将能够获取所有这些特定记录。好的，然后，我会尝试将其放在另一个括号中。确保你这样做。否则你会收到错误信息。好的。😊，非常非常简单，伙计们。让我们看看我实际是如何写的。它是这样的 Df underscore Pi 点过滤器。

Df Pipar的工资小于或等于20000且大于等于150。如果我执行，你将能看到在15000到20000之间的记录。你也可以写或，然后你将能够得到所有不同的值。这是一种你可以基本上指定的过滤操作，请记住。

当你检索与任何数据集相关的一些记录时，这将非常方便。你可以尝试不同的方式。这是你实际提供列名并在内部放置条件的一种方式，这个Pi spark实际上是Pipar数据框。

理解这一点，你就能正确获取输出。所以，是的。这就是这段视频的全部内容。希望你喜欢它。希望你喜欢这个过滤操作。试着从你这边做一下。好的，还有一个操作基本上是未完成的。我也可以写成这样C。

每个人我基本上可以。😊，说，好吧。也许我可以使用这个操作，称为非操作，让我们看看。这个非操作将如何出现。好的，基本上。逆条件操作，我们基本上这样说。所以我会使用这个。好的。在里面，我可以放一个非条件，就像这样。

所以我会说这是一个不等于Df of5par的工资小于等于200的情况。所以任何大于20000的将会在这里给出。好的，所以这是逆操作。你可以说是逆过滤操作。所以，是的，这就是我会说的逆过滤操作。我实际上向你展示了我们在这里讨论的内容。

希望你喜欢这个视频，如果你还没有订阅，请订阅频道。我会在下一个视频中见到你。祝你有个美好的一天。谢谢，再见。😊！

PySpark 大数据处理入门，带你玩转Python+Spark大数据操作与分析！＜实战教程系列＞ - P2：L2- Pyspark 数据帧 - ShowMeAI - BV1sL4y147dP

。

大家好。我的名字是Krisushnaak，欢迎来到我的Udish频道。所以大家，我们将继续Pipar系列。在本教程中，我们实际上将看到什么是Pipar数据框，我们尝试读取数据集，检查列的数据类型，我们基本上在Pipar中称之为schema，然后我们将看看如何选择列并执行索引描述功能，这与pandas相似，然后我们将尝试看看如何添加新列以及可能删除列，这只是第一部分。所以让我把它写成第一部分，因为之后还会有一部分。

为什么这段视频很重要，因为在Pipar中。如果你计划应用M，机器学习库确实需要先进行数据预处理，可能在第二部分我们将尝试处理缺失值，并看看如何修改行，如何可能设置过滤条件，好吧。接下来我们继续，在继续之前，我要做的是，我们首先要有一个。

😊。

设置一个名为test1的变量。我有三列，一个是姓名，年龄和经验。然后我有一个数据集，如Kris 31，10，就这样。所以Sunny对了。这是我保存在同一位置的一些数据集。现在我要做的第一步，像往常一样，关于Pipar的第一步是构建Pipar会话。现在。

为了构建Pipar会话。我会逐行写代码。所以请确保你也和我一起做，这肯定会有帮助。所以我要写从Pipar。😊，点sqel。导入。Spark会话。然后我将创建一个变量Os，抱歉。

然后我将开始创建一个关于我的会话的变量。所以我将写Sp等于Sp会话点。我们基本上写builder点app名称。在这里我只打算把我的应用程序名称设置为实践。我可以说，或者让我写数据框实践或数据框，就像这样。

因为我们在练习数据框的获取或创建函数。这就是你实际开始一个会话的方式。所以再一次，如果你是第一次执行，这会需要一些时间。否则，它是完全可以的。所以这是我整个的spa，它在内存中运行，正在运行的版本。

而且，显然，当你在本地运行时，你基本上会有一个主节点。好的，应用名称是数据框。所以首先我们尝试再次读取数据集。😊让我们现在读取数据集。我已经给你展示了多种方式，一种是通过读取选项，一种是通过读取。由于这是一个CSV文件，我们将首先尝试读取它。第一种选项是看看我们如何实际读取它，然后我会给你展示多种读取方式。好的，我会写Spark.dot。

Re.dot.options。在这个选项中，我们基本上说的是键值对。对。所以我将其设置为header等于true，这样，你知道的，它应该将我的第一行视为标题。这里我会写head为true，在CSV内部。

我给我的数据集命名为test1.cism。现在当我执行这个时，我想你会看到数据集。所以你能看到的，好的，这是一个数据框，你有特征，比如姓名、年龄和经验。所以如果我想查看完整的数据，我只需写.show。现在我可以很清楚地看到我的整个数据集。让我将其保存在一个变量Df_underscore_co_pipar中。

好的，这是我的整个数据集。首先，我们怎么检查架构呢？让我们检查一下架构。好的，架构基本上意味着数据类型，就像我们在pandas中写的Df.dot.info一样。我们可以在这里写。所以你可以看到我在这里写了Df下划线Ipar.dot。😊打印。想必应该可以正常工作，打印架构。没有类型是字符串架构，哦，抱歉。

所以我已经写了.show并保存到一个变量中。我会去掉这个.show。让我再执行一次。现在如果我在这里写print schema，你将能看到姓名、年龄和经验。但默认情况下，它将其视为字符串。尽管在我的Excel表中，我们已经写入了值，可能这些应该是字符串。

这里应该是整数，那么这里也应该是整数。但为什么它将其视为字符串呢？原因可能是它默认将其视为字符串，因为除非我们在CSV中给出另一个选项，这个CSV有一个选项叫做推断架构。

好的，如果我不将其设置为true，那么默认情况下，它将考虑所有特征为字符串值。所以我现在执行这个。现在如果我去查看Df_underscore_P.dot.print schema，你将能看到我得到的姓名为字符串，年龄为整数，经验为整数，等级为二级。

这基本上是它可以有空值。所以这。😊一种读取方式，还有一种我会试着给你展示的。这相对简单，所以我可以将头和推断架构都包含在一个操作中，所以我会写B_F_underscore_co_p，spark等于Spark.dot.read。然后是dot.csv，在这个CSV中。首先，我会提供我的测试文件，CSV。好的。

然后在这里我将继续写 header。可能等于 true。我可以写 schema 为 I。因此，当我这样写时。如果我写 D F underscore。Picepar.dot.show。在这里，你将能够看到我的整个数据集。好的，所以这里是我的整个数据集。现在，如果我去查看并再次执行这个 schema，它可能会给我同样的方式。

就像我们在这里的情况一样。好的，所以在这里你可以看到姓名是字符串，年龄是整数，经验是整数。完美。那么我们做了什么呢？我们了解了这一点。如果我去查看这个的类型。😊。如果我去查看这个的类型，这基本上是一个数据框。Pandas 也有数据框。

所以如果有人在面试中问你，什么是数据框。你可以基本上说，数据框是一种数据结构，你知道的。因为在里面你可以执行各种操作。所以这也是一种数据结构。好的。那么我们实际上做了什么呢？我介绍了数据框并读取了数据集。现在检查列的数据类型。为了检查列的数据类型，我们已经写了 print schema。好的，现在我可以在此基础上再做一件事。让我们看看选择列和索引。首先，让我们理解一下。

基本上哪些列存在，如何获取所有列名。因此，为了获取列名，你只需写 dot.columns，好的。当你在这里执行时，你将能够得到列名，比如姓名、年龄、经验。完美。这是完全正确的。现在，这是我的 D。现在。

假设如果我想提取一些头部元素。我将能够提取，因为在 pandas 中你也有 head。假设我想获取前三条记录。我将以这种特定格式获得，通常是在列表格式中，使用 pandas 时。

我们通常以数据框格式获取数据。所以在这里你会看到姓名、年龄和经验的组合。好吧，就像这样，这是我的第一行。这是我的第二行。这是我的第三行。好的。现在，我们来讨论下一件事，我该如何选择一列，你知道吗。我可能想提取一列并查看所有元素，就像我们在 pandas 中做的那样。

首先，让我这样写。😊。Pspar.dot.show 这里将能够看到所有列。现在。如果我真的想只提取姓名列。好的，我该怎么做呢，好的，让我们。让我们看看，现在为了提取姓名列。

有一个非常简单的功能，我们写作 Pipar.dot.select。😊。在这里我只需给出我的姓名列。现在一旦我执行这个，你将看到返回类型是数据框，好的，返回类型是数据框，姓名基本上是一个字符串。现在如果我写 dot.show，我将能够看到整个列，好的，当我这样做时，我将能够看到这个，如果我尝试找出这个的类型。

对不起，如果我去掉这个 dot show 并查看类型，这基本上是一个数据框。Pipar dot sql dot data frame，dot data frame，而不是 pandas dot data frame。好的，相对简单。现在，假设我想选择多行，比如说，多列。我想选择名称和经验，可能我想选择这两列。我该怎么做呢？

我在这里做一个改变，最开始我提供了我的一个列名，之后我会提供另一个列，即经验。😊 然后我会执行这个。现在，一旦我在这里执行，你会看到我得到了一个有两个特性的数据显示框，一个是名称，另一个是经验。现在，如果我去写 dot show。😊

在这里，你会发现我的所有元素基本上都在这个特定的数据框中，选择多行的方式非常简单，不过切片在这里确实不管用，因为我尝试过切片，但没成功。好的，如果你有任何疑问，始终查看文档。

😊 Pi park 文档，基本上很简单。好的，这是一种选择列并查看行的方法。现在让我给你演示一下，如果我只想选择，有一种方式像是 C。如果我写 D 的 Pipar 的名称。如果我在这里执行，你会看到列名。

返回类型将在这里是列。如果我直接选择，因为在 pandas 中，我们就是这样直接选择的，对吧？然后我们就有这些列。我们只能理解这个特定的特性，它基本上是一个列，它在说“好的”，没有更多的信息，我们无法获取数据。

不会有显示函数，它会提示这是一个错误。所以通常我们在想要获取或选择任何列并查看时，基本上需要使用这个特定的选择操作，也就是我的函数。

好的，这些事情都完成了，大家试着理解一下。现在我们来看如何检查数据类型。有一个功能，叫做 D types。在这里，你会看到名称被标记为字符串，年龄被标记为整数，经验也是如此。D types 与 pandas 非常相似，我们在 pandas 中也使用过大多数功能。我们实际上做了哪些事情呢？

让我们查看数据名称读取数据。😊 检查数据类型，选择列和索引，检查描述选项，类似于 pandas，因此我们也可以检查描述选项。让我们看看。Picepar dot describe。如果我执行这个，你会看到它给你一个数据框的摘要，内容是字符串，这些信息都在。现在当我写 dot show 时。

😊，好的。你将能够看到这一切，基本上是以数据框的形式呈现。😊。你可能在想，为什么这个 nug 值会出现均值和标准差。因为即使在这里，它也会考虑字符串列。基本上，具有字符串数据类型的值在这里，显然。

你没有任何东西。所以最小值和最大值基本上是在索引上取的，因为在第二个索引中。你将能够看到崩溃，然后太阳在那之后。好的。在第四个索引中，剩下的所有信息实际上都是存在的。好的。所以这基本上和我们实际上看到的描述选项一样。😊，你知道的。

可能在我们的 pandas 中，对吧，所以我们实际上也是这样做的。好的。所以描述选项也完成了。那么现在，让我们去看看添加列和删除列。好的，添加列和删除列非常非常简单。大家。如果我们需要添加列。我将把评论写在这里，添加列。

在数据框中，这个数据框是 pipar 数据框。好的，现在为了添加列。我们有一个很棒的函数，叫做 Df Pi spark dot。这里有一个叫做宽度列的东西，好的，现在这个宽度列如果我查看功能，它会通过添加一个类或替换同名的现有列返回一个新的数据框。好的，所以这里我要给的第一个参数是我的列名。假设我想选择。

让我来选择经验。😊，所以我会说经验，好吧。这可能会是我在两年后的新列。如果经验在两年后会发生什么，你知道的。最初候选人有10年经验，两年后将变为12，对吧？所以我们会尝试放置现在的值。这是我的新列名，应该有什么值，所以我会写 Df P spark，在这里我会说我可能会取那个 spa 经验。😊我会乘以并加上 2，因为两年后经验会增加 2。

我只是用一种方式解决这个问题。我要随意放置任何值，大家随意。好的，你可以实际查看。好的。现在在此之后，这只是需要的两件事。现在如果我执行它，你将能够看到一些操作会发生。在这个数据框中，你有1，2。

第3和第4个特征。如果我想查看完整的数据集，我可以写点显示。😊。一旦我执行它，我们将在这里看到，经过两年的经验不过是 12，10，66，因为 10 加 2 就是 12，你们非常简单。这个宽度列基本上就是这样，你也可以在这方面做不同的事情。

所以这就是你如何在数据框中添加列。再说一遍，伙计们。这不是就地操作，你基本上需要将其赋值给一个变量以便反映。如果我想让它反映，我确实需要像这样赋值。现在如果我去看看，抱歉，首先。让我去掉这个 show，show 不会给我们正确的结果。😊，好的哦。

没有属性宽度列。好的，抱歉，这里有一个问题。我会。我会读取这个数据集，因为我完全替换了它，对吧。现在我会再次执行它。现在没问题。现在，如果我在这里写 dot show，你将能够看到所有元素都正确显示。现在。

这与向数据框添加列有关。现在。我可能还需要删除列。所以删除列。让我们看看我们如何实际删除列。删除列相当简单。就像我们通常删除的功能默认情况下，取列名。

你可以提供一个列的列表。你可以给一个单独的列名。所以假设我说经验在两年后。我想删除这个。因为谁知道两年后会发生什么。所以让我们删除这个。为了删除它，只需像这样执行，然后去看看 dot show。

在这里你将能够再次找到没有那个特定列的内容。这不是就地操作，你需要将其赋值给一个变量，非常简单。所以让我把它赋值给一个变量。是它调用并请确保你删除这个 dot show。dot show 现在是一个功能，如果我写这个 dot show。

在这里你将能够看到所有元素。很好，现在让我们继续。看看如何重命名列。所以我们这样做是因为你真的需要在数据预处理方面非常优秀。好的，所以我会写 thought，还有另一个功能，叫做 width。😊，列重命名。好的，现在在这里，你只需给出你的现有列名和新列名。

假设我这里的现有列名。我会说 name，然后我会说 new name。好的，然后执行它。现在如果我去写 dot show，试着看看这里的元素，你将能够看到，name 旁边会有一个叫做 new name 的东西，对吧。这就是我实际上要讨论的内容。

我在这里再写一个要点。我们也讨论了重命名列。对。是的，这只是数据框的第一部分。第二部分将尝试进行一种称为过滤操作的内容。在过滤操作中，我们将尝试查看各种操作，伙计们，这将非常惊人。你将能够学到很多东西。所以我希望你喜欢这个特别的视频。

如果你都喜欢这个频道，请订阅。我在下一个视频见。祝你有个美好的一天。谢谢你们。伙计们，继续分享。继续支持，我在下一个视频见。拜拜。😊。

PySpark 大数据处理入门，带你玩转Python+Spark大数据操作与分析！＜实战教程系列＞ - P3：L3- Pyspark DataFrames 处理缺失值 - ShowMeAI - BV1sL4y147dP

。

嗨，我的名字是Krisna，欢迎来到我的UD频道。所以大家，我们将继续Pipar系列，我已经上传了两个关于Pi Sp的视频。今天我们实际上开始了对Pipar数据框的理解，今天我们将继续。这可能是教程3，关于数据框操作的第三部分，在这个视频中我们将看到如何处理缺失值。

空值。所以简而言之，这些事情我们都会尝试做，我们会看到如何丢弃列，我们会看到如何丢弃行，然后我们会看到在丢弃行时，可能基于空值尝试丢弃行，然后我们将尝试看看丢弃功能中的各种参数，以及如何通过均值、中位数或众数处理缺失值。所以在这里我将写作均值、中位数和众数，可能所有这些我们实际上都会再次看到。

主要的是我真的想向你展示我们如何处理缺失值。😊。

缺失值，这非常重要，因为在pandas中我们也会尝试在技能中做到这一点。我们有一些重要的函数。所以让我们继续。每当我们通常开始一个Pipar时，当我们使用Pipar工作时，我们真的需要启动一个Pipar会话。所以我希望到现在为止你们都熟悉了。因此我写Pipar.sql，我将要导入。

Spark会话。好的，然后我将创建一个变量并命名为spark。然后在这里我将写spark session.build。好的，点app name。让我将这个应用名称设置为practice。好的，因为我只是在练习一些东西。然后我写get or create并执行这个。

所以这可能需要一些时间来执行。是的，它已经成功执行了。现在为此，我刚刚创建了一个非常简单的数据集，内容如下。我有一个列，包含姓名、年龄、经验和薪水。这些都是我的候选人姓名，可能有一些值留空了，你可以看到一些值留空了。所以我们将尝试看看如何丢弃空值，或者如何处理这些缺失值。

所以让我们继续，首先，为了读取数据集，我将写spark.read。😊。点CSsv，在这里我将使用CSsv文件名test2.cv，它保存在与此特定文件相同的位置。无论如何，我将在这个GitHub中提供链接，并且我将使用header=true，可能还有infer schema=true。

我将能够正确获取数据集，所以当我读取这个时，你会看到这是我实际上获得的数据框，如果你想看到整个数据集，你可以使用点显示。这里就是你的整个数据集。你有空值，完美。那么。

让我做一件事。让我把这个保存在一个变量中。所以我会写 D F 下划线 co I spark。那么如果我去检查一下。点显示。这是我的整个数据集。好的，完美。到这里我们差不多没问题。我们在这方面工作得很好。我们知道实际上已经读取了一些数据集，现在，可能是第一个。

让我们开始看看如何删除列。删除列非常简单，伙计们。假设我想删除名称列。那么我只需使用 D F 点 drop 并提供我的列名，就像这样。对吧？所以列。😊，对，列名，假设我写 Df 点价格 spark。这里的列名将是名称。所以让我写成名称。

我基本上可以去查看我的点 show。然后你将能够看到所有实际写入的功能。这非常简单，我在之前的课程中也可能给你展示过，好的。基本上就是这样删除你的特征或列。但是我们主要关注的是删除非值。所以现在。

让我写 Df 点 by spark 点 show。所以这是我的数据集，现在让我们看看如何根据空值删除特定行。这里，我只需使用 D 点 by spark 点 na 好吧，有一个叫做 N 的东西。然后你有 drop、fill 和 replace。所以首先，我会从 drop 开始。现在，在这个特定的 drop 中，记住如果我什么都不提供。好的，然后执行它。

在这里。你会看到所有空值的行都会被删除。所以你会看到最后三行不在，对吧。所以在这里你可以看到到 shubum 这个特定的值是存在的。其余的所有行都被删除了。完美，对吧，所以完全没问题。

所以这里，简而言之，你所做的是每当你使用点和 a 点 drop 时，它只会删除那些实际存在 na 值或空值的行。好的，完美。这些都没问题。如果我去搜索 drop，有两个主要功能。一个是如何，另一个是阈值。还有一个是子集。

那么让我们尝试理解这个特定的功能。现在，首先，我将开始如何。😊。任何等于如何，我就这样写。好的。所以假设如果我写 D F 点 Pipar 点 any 点 drop。如果我的。如何的值可以有两个值，一个是 any，一个是 all。好的，一个是 any，一个是 all。

如果选中的值为任何下拉或行，且包含任何空值。即使只有一个空值，好吧，一个空值或两个空值，或者全部为空值。你知道，默认情况下，它会被删除。好的，但所有等于什么？我们何时使用所有，这基本上意味着假设在你的特征中，你有。

假设在你的行中，所有值都是空。在这种情况下，你有361个值。这不会被删除，但如果在某个记录中所有值都是空，那只有在这种情况下它才会被删除。好的，所以让我们看看这是否能工作。绝对不会工作，因为我知道至少有一个值是存在的。

1个值，1个非空值总是存在的，对吧？如果我使用的是所有，它将删除那些完全为空的记录。默认情况下，这个值应该是任何值，所以默认情况下，它是任何值，基本上意味着是否有一个空值或两个空值。

你只是要删除那些特定的记录，基本上很简单。这就是怎么回事。现在，让我们继续尝试理解阈值。这是什么阈值。我会告诉你这个阈值是什么。现在，让我先用这个，好的。我知道如何处理任何值，但还有一个选项叫做阈值。

在阈值中，我们所做的是假设我写，设定阈值为2。这基本上是说。在这个特定情况下，如果阈值值为2，好的，首先执行一下。你会看到最后一列被删除了。好的，最后一行被删除了，为什么被删除？因为我们设定了阈值值2，这表示至少需要两个非空值。

😊好的，至少两个非空值。现在，这里你有两个非空值，比如40000。好的。这里，你只有一个非空值。由于这个原因，它被删除了。如果你在这里有两个非空值。看看34和10，这没有被删除。这在这里也是一样，3410，对吧，34，10。如果我在这里给你展示3410和38000，至少这里你有三个非空值，那里你有两个非空值。

所以这里，每当我们设定某个阈值为2。这基本上会检查在特定行中，是否至少有两个非空值。如果有，它就会保留该行，否则，它就会删除，这就是你可以检查的。

所以如果我去查看一个，你会看到所有这些特定的行都在那，因为它会去检查。这里有非空值，如果我把它设为三，好的。让我们看看结果会是什么。😊现在，你可以看到至少剩下的所有内容都被删除了，对吧？看这里，你只有两个非空值，这里你加了三个。

这是3410，38000和nu。所以在这里你可以看到这个值。这是关于阈值的理解。现在，让我们继续下一个，称为子集。所以我将在这里写为subset，因为这是我draw feature中的第三个参数。请记住，这些特征如果你曾在pandas中工作过，都是相当简单的，我们正在处理的也是子集。

在子集中，我们实际上可以提供。假设我在子集里说，去掉阈值。我不想保留任何阈值。假设我只想从特定列中删除N值，可能只从经验列中。然后我可以将其作为子集，从经验列中你可以看到在记录中所有的na值。所有这些记录都被删除了，所以你可以这样应用。

假设你想在年龄中应用它，你也可以在年龄列中应用这个，任何没有值的记录都会被删除。所以这是关于子集的内容。我希望你们能理解，伙计们。这非常好，因为我们实际上正在尝试应用我们在pandas中所做的事情，这在处理缺失数据时非常方便，好的。😊，我们继续下一个内容。

让我们去填补缺失值，填补缺失值。现在。为了填补缺失值，我将使用Ipar.dot fill。🤧。好的，抱歉，any.dot fill。好的，里面这个fill将接受两个参数。一个是值，另一个是子集。好的，现在假设我这样给出值。

假设我说缺失值。如果我写.dot show。那么它将把所有的n值替换为缺失值。所以你可以看到这里有一个null值。所以缺失值，缺失值，缺失值缺失。假设你真的想在特定列中执行缺失值处理。

然后你可以像这样写你的列名。这将是我的X subset。好的。我也可以这样提供多个记录。看，我还可以提供多个exs，比如经验，commarma，可能是年龄。Goma。H。在列表中，当我这样提供时，这种功能将在两列中发生，简单得多。所以伙计们。

现在下一步，我们要做的是选择一个特定的列，可能会通过该特定列的均值或中位数来处理缺失值。所以现在如果我查看我的D.dot spice spark，看看我的.dot show值。

这是我的整个数据集。现在我将采取这个经验列，并可能用经验的均值替换空值。为此，我将使用一个填补函数。大家。

如果你了解填补函数，我们基本上是通过Scikit-learn来使用它，在Pipar中也有一个填补函数。所以我将复制并粘贴代码，让它非常简单，从Pipar的Ml.feature中填补，输入我的输入列，即年龄、经验和薪资。我可能想对这里的每一列都应用，然后我只是说，对于年龄、经验和薪资，我将找到这个.format来输出列，并将策略设置为均值，你也可以将策略更改为中位数、众数等。

我将执行这个，执行顺利，然后我们将写fit和transform。所以填补.fit和Pipar的.transform。一旦我执行，😊，你们将看到我们将创建多个列，命名为underscoreco imputed。所以你可以看到age underscoreco imputed，简而言之，我们尝试了一种均值功能，这基本上意味着空值被均值替换。在这里你可以看到，这个空值被替换为28，类似地，这个空值被替换为10，抱歉5。这是经验填补列，你会看到每当有空值时，它都被经验列的均值、年龄列的均值和薪资列的均值替换。如果你真的想使用中位数，只需将均值更改为中位数，然后在这里执行，现在你将能够看到中位数值，这里是你的初始空列，抱歉，这里是具有空值的列，这里是所有基本上填补了值的列。

我希望你们喜欢这个特别的视频，大家这是关于教程3的。在这个视频中，我们尝试了解如何删除列、删除行，以及如何检查与删除功能和处理缺失值相关的各种参数，使用均值、中位数和众数。

你也可以尝试众数。这取决于你，你完全可以试试看是否能够做到。所以我希望你喜欢这个特别的视频。如果你还没订阅频道，请订阅，我会在下个视频中见到大家，祝你有个美好的一天。

谢谢，再见。😊！

PySpark 大数据处理入门，带你玩转Python+Spark大数据操作与分析！＜实战教程系列＞ - P6：L6- Pyspark Mlib 简介 - ShowMeAI - BV1sL4y147dP

。

所以，Spark Mlib也有出色的文档，涵盖了各种示例。在这里你可以点击示例，基本上查看这份特定的文档。你可以看到不同类型的示例，看看它是如何完成的。但就Spar Ml而言，有两种不同的技术。

一种是RdiD技术，另一种是数据框API。现在我们要做的是，数据框API是最近的，你知道，它在各处都很有名。因此，我们将专注于数据框API。这就是我们在Pipar中非常好地学习数据框的原因。因此，我们将通过数据框API学习，并尝试看看我们如何基本上解决机器学习的用例。

现在，让我们来看一个非常简单的例子，伙计们。永远记住，文档提供得非常好，你可以在这里检查并阅读所有这些内容。让我们继续，看看我们实际上可以做些什么。😊

在这个特定的例子中，我将处理一个简单的机器学习问题陈述。所以让我为你们打开一个特定的数据集，然后可能会尝试一下。好的，这就是我的数据集，伙计们，我知道这里没有很多记录。好的，我有一个数据集，其中包含姓名、年龄、经验和工资。😊

这只是一个简单的问题陈述，旨在向你展示Sp在MLla库中是多么强大。接下来的视频中，我会详细解释回归算法以及我们如何理论上进行实现，所有内容我已经上传了。

你可以看到这里，我将在这个教程之后进行讲解。这基本上是教程6。我会尽量在之后添加它。😊！

每当我上传线性回归算法之前，请确保观看这段数学直觉。好的，我也在播放列表中上传了这个特定的视频。所以在这个教程26之后，因为我也把它添加到了我的机器学习播放列表中。在之后，你也会找到我们讨论线性回归时，如何深入实现，这段视频也会上传。所以让我们继续。这里是我的全部数据，伙计们，这是我的数据。现在我需要根据年龄和经验来进行操作。

我需要预测薪水，这是一个非常简单的用例，数据处理不多，转换不多，标准化也不多。我只会采用这两个独立特征，并根据年龄和经验来预测这个特定人的薪水。

好的，这就是我将要做的。😊！

所以这是一个完美的例子。再一次，细节上，我将尝试逐行向你展示如何基本实现。可能在接下来的几期视频中，我将讨论线性回归等内容。如果我查看这个特定问题，这也是一个线性回归示例。那么让我们先来，和往常一样，我将创建一个 spark 会话。

所以我将使用 frompar do sql import spa session，然后我将使用 spark session do builder.dot app name，这里我实际上是在创建一个 spark 会话。让我执行一下，我觉得这你应该很熟悉。如果你熟悉这个，那么我在这里要做的是，我们只会读取这个特定数据集，使用 test1.dot csv，header 设置为 true，first schema 设置为 true。

所以当我去查看我的训练时，所有的特征都在这里。完美。我也会给你这些数据。别担心。现在，从这些特定数据中，如果我去检查我的打印模式，你将能够看到我获得的特定信息，这是我整个打印模式。😊特征包括姓名、年龄、经验和薪水。现在，如果我去查看训练的列。

这是我的训练列。现在，大家一定要记住，在 Pipar 中，我们使用不同的原理或机制，或一种数据预处理方法，通常我们所做的是。通过使用在 Ecala 中可用的机器学习算法，我们基本上进行训练测试划分，没错，然后我们首先。

将其划分为独立特征和依赖特征，没错，我们使用 x 和 y 变量。然后我们通过在 Pipar 中进行训练测试划分，采用不同的技术。我们所做的是，是的，我们基本上需要创建一种方法，将所有独立特征分组在一起。因此，我可能会尝试创建向量组装器。我们通常称之为向量组装器，我实际使用的类将确保我所有特征都像这样分组在一起，形成年龄和经验的形式。

在这里，我的两个主要特征是年龄和经验，它们是我的独立特征。所以它会像这样为每条记录分组。它会像这样分组。好的，对于每条记录，它会像这样分组。然后我将把这个分组视为。😊不同的特征。

所以这基本上将是我的新特征。对，记住，这个新特征是我独立的特征。所以我的独立特征在年龄和经验的分组中看起来是这样的，这将被视为一个新特征，这正是我的独立特征。因此，我必须以这种特定方式进行分组。为了分组，我们在Pipar中这样做。

我们使用一种叫做向量组装器的东西。因此，这个向量组装器基本上在pipar do ml dot feature中存在。我们使用这个向量组装器，使用两个东西。一个是输入列，所有我们要进行分组的列。因此，两个列，一个是年龄，另一个是经验。对，我们不需要考虑姓名，因为姓名是固定的，它是一个字符串。是的。

如果有分类特征，我们需要做什么，我们将把它转换为一些数值表示，这在我即将发布的线性回归、逻辑回归和其他视频中的深入实现中会向你展示。但在这里你将能够看到，我将以列表的形式获取输入列年龄、经验，然后我将尝试对其进行分组并创建一个新列。

这里叫做😊，依赖特征。这就是我实际上在做的。因此，如果我去执行这个向量在相似的地方。所以在这里我得到了我的特征在相似的地方，然后我进行点变换。我对我的训练数据进行点变换。这基本上是我的训练数据。当我这样做时，当我在这里输出点显示。

你将能够看到我有所有这些特征，并且创建了一个新特征，称为独立特征。好的，所以我们实际上创建了一个独立特征。你可以看到这里的年龄和经验，年龄和经验，年龄和经验。因此，这是我实际得到的分组行。简而言之，我所做的。

我已经将这两列结合在一起，并将其作为一个独立特征。好的，现在这将是我的输入特征。好的，这将是我的输出特征，我们将尝试训练模型。好的，因此在这里现在如果我去查看输出点列，我有姓名、年龄、经验、独立特征。现在我从中做什么。

让我们看看我实际感兴趣的数据集。😊因此，在这些中，我只会对这两个数据集感兴趣，对，特征和薪水。薪水将是我的输出特征。y变量，对，这将是我的输入特征。因此，我要做的是，我将选择输出点选择独立特征和薪水。

我将把它放入我的最终器下划线数据中。这就是我实际上在做的。如果我现在去查看我的点显示，你将能够看到整个内容。😊现在，这些是我的独立特征。这些是我的依赖特征。现在，第一步，我们要做什么？我们进行训练测试拆分，就像我们在Scal中所做的那样。为了进行训练测试拆分。

我在我的最终数据中使用一个叫做随机拆分的函数。记住，大家。我会尽量逐行解释，当我在做一个更大的项目时。目前这只是一个介绍课程。我真的想告诉你们事情是如何实际进行的。这基本上就是我的训练测试拆分。所以让我在这里写下注释。😊

训练测试拆分。我将使用线性回归，就像我们从 S 类库导入一个类一样，类似地通过使用 Pipar.ml.regression 导入线性回归。然后我进行随机拆分，比例为 75% 对 25%。这基本上意味着我的训练数据将占数据的 75%，而我的测试数据将占 25%。然后我将在此使用线性回归。你需要提供两个重要变量。一个是特征列。

有多少个特征列在这个独立特征中是完全存在的。所以我在这里给出，标签列也是如此。这是我需要提供的第二个特征。这是我的输出特征。所以在我提供这两个内容并对训练数据进行拟合后。

我将能够找出我的系数。这些是我的系数。这些是我的截距。现在我可以评估并查看我的输出。通过使用这个评估函数，我们将能够看到输出。在里面会有。😊，附加变量。它将包含输出。好的，这就是我的预测。这是我的薪水，真实值。

这是我的另一个内容。如果我真的想找出其他重要的指标参数。让我们按一下 tab 键，你将能看到平均绝对误差_结果.均方误差。所以如果我看到这个特定的词值，你将能够理解模型是如何实际表现的。这只是一个非常简单的例子，大家，别担心，我会深入解释。

可能在接下来的几期视频中，我们将从线性回归开始。现在，请记住，下一个视频是关于线性回归的深入实现，理论部分你可以在这里看到。我已经添加了视频。好的，我希望你喜欢这个视频。如果你喜欢，请订阅频道，我们在下个视频见。祝你有个美好的一天。😊

PySpark 大数据处理入门，带你玩转Python+Spark大数据操作与分析！＜实战教程系列＞ - P7：L7- Databricks 简介 - ShowMeAI - BV1sL4y147dP

。

大家好。我是Krishna，欢迎来到我的频道。所以大家，我们将继续Pipark系列。在这个特定的视频中，我们将了解这个Databricks平台。记住，大家，在我之前的视频中，我已经上传了所有关于Pipark与Python的内容，直到Pipar M。

我告诉过你，在这个特定的视频中，我们将讨论线性回归，以及如何借助Pipark实现线性回归。但在此之前，我真的想帮助你了解什么是Databricks平台。这是一个很棒的平台，你可以在这里使用Pipark，或者与Apachepark合作。

还有一个关于这个特定平台的惊人之处在于，他们还为你提供了集群实例。所以如果你有大量数据，想要进行并行处理，或者想要在多个集群中分配数据，你绝对可以借助Databricks做到这一点。

😊。

现在，如果我真的想使用这个平台，有两种方式：一种是社区版本，另一种是付费版本，例如Azure或AWS云，你实际上可以在后端使用它。Dataricricks还帮助你实现ML flow，而这个ML flow与CICD管道有关，所以你也可以进行这些实验。

总之，这是一个很棒的平台。我在我的YouTube频道上会专注于展示社区版本，并且在接下来的视频中会尝试使用AWS和Azure进行执行。

我们将尝试做的是，每当我们创建多个实例时，知道我们会尝试在这个特定的云平台上创建多个实例，我们还会尝试从S3 bucket中拉取数据，S3 bucket是AWS中的存储单元，并尝试向你展示如何处理庞大的数据集，所有这些内容会随着我们的进展而展示。现在让我们了解一下这个Databricks是什么。

它是一个开放和统一的数据分析平台，适用于数据工程、数据科学和机器学习分析。记住，Databricks实际上帮助我们执行数据工程，当我说数据工程时，可能是在处理大数据，它还帮助我们执行一些机器学习算法，可能是任何类型的数据科学问题陈述。

😊，你将能够做到这一点，可能会涉及三种云平台：一个是AWS，一个是Microsoft Azure，还有一个是Google Cloud。如果你真的想开始，可以先从社区版本开始，你只需访问这个特定的URL，输入“try databs”，然后输入所有你的详细信息以免费注册。

一旦你注册并开始免费使用，你将在右侧看到两个选项，你可以看到你想免费使用的社区版本，而在左侧则会有一个选项，告诉你需要与这三大云平台合作，你也可以选择那个。

现在，我将尝试向你展示一个社区版本，它会非常简单，非常容易。让我们进入社区版本。实际上，社区版本是这样的，如果你真的想使用云版本，可以点击升级，好的，点击升级，这就是社区版本的URL，注册社区版本时，你将能够获得这个URL，明天你可能会想使用云服务。

你只需点击这个升级，现在你将看到三个选项，一个是探索快速入门教程，导入和探索数据，创建一个空白笔记本，还有更多你可以在社区版本中完成的任务，比如创建新笔记本或创建表格。

创建一个集群，创建新的Mflow实验。我希望我已经向你展示了Mflow实验，我们还可以通过将其与后端数据库结合来创建这个MLflow实验，然后我们可以导入库，读取文档。😊！

可以完成很多任务。首先，我们需要做的可能是创建一个集群。现在，为了创建一个集群，我会点击这里的创建集群。你可以基本上写下任何集群名称。我会说Apache，或者我会说Py spark集群。假设这是我想要创建的集群。好的。

然后这里默认情况下，你可以看到8.2 scalar。选定的是spark 3.1.1。因此，我们将使用spark 3.1.1。如果你记得，我在本地也安装了这个特定版本，默认情况下，你会看到他们提供一个15 GB内存的实例和更多配置，如果你真的想升级你的配置。

你基本上可以点击这里。好的，记住在免费版本中，你将能够在一个实例中工作，除非它空闲超过两个小时，否则它将断开连接。所以在这里你可以看到一个驱动程序，15.3 GB内存，2核和一个D。

所有这些功能都在这里。你还可以理解什么是debut，de是数据砖单位。如果你想点击这里，你将能够理解debut究竟是什么，好的，你将能够选择一个云，并基本上与之合作，完美，到这里一切都很好。

让我们开始，创建集群。现在，一旦你看到集群正在创建。你这里还有很多选项，比如笔记本、库、事件日志。Spark UI驱动程序日志等等。这并不是说你只能在这里使用Python，你这里有很多选项。所以假设我去点击库。如果我点击安装新库，你将有一个选项来上传库。

你也可以从Mayn的Pi安装库。我们基本上在Java中使用这些库，然后你会有不同的工作空间。所以我将做的是，假设你选择管道，如果你想安装一些库。

我喜欢Tensorflow，或者你可能想选择ks，你可以这样写，我可能想要一个scale learn。你知道，所以我可以用逗号分隔并开始安装它们。好的，但默认情况下，我知道我将使用Pi Sp，所以我不打算安装任何库。让我们看看这可能需要多长时间，这里只是执行。

让我们回到我的主页。所以除了这一年，你还能够上传数据集。那个特定的数据将给你一个环境，像你如何在do中存储数据。好的，所以在集群创建之前，现在集群已经创建了，你可以看到Pi pocket处于运行状态，记住这个集群只有一个实例。如果你想创建多个集群，我们必须使用云平台1，这将是收费的。

好吧，所以我在这里将点击导出数据。现在大家看，你可以上传数据。你也可以从S3桶中获取。然后你也可以从S3桶中获取。这些我会试着给你展示。然后你也有Dfs，你知道。😊，还有D V F F。你基本上会存储在这个特定的格式中。

然后你有其他数据源，比如Amazon Re script Amazon kindnesses。Amazon Kinnesses主要用于实时流数据。好的，然后你有Cassandra。Cassandra也是一个No SQL数据库，还有JDBC最后搜索。因此，也有不同的数据源，我们还会尝试与合作伙伴的集成。

所以它们也像实时捕获在数据湖中，还有更多的东西在这里。因此，你绝对可以看看这个。现在我将做的是，点击这里尝试上传数据，让我看看。我将上传数据集。我会去我的Pipar文件夹。所以这里是我的路径，我将上传这个测试数据集。

或者我会尝试上传这个测试文件。现在，你可以看到数据集已经上传。现在它说要通过 UI 创建表格，在笔记本中创建表格。如果我去点击这个，你知道的。所以这里你将能够看到这是代码。这是创建表格的完整代码。

但我真正想做的是我不想创建表格，而是尝试执行一些我们到现在为止已经学过的 Pipar 代码。好的。所以我将做的就是删除这个。我不想要它。我将删除这个，好的。好的。

让我现在读取数据集。在这里，你会看到我的数据集路径基本上是这个。它是一个 CSV 文件，包含 schema 头部 schema，所有这些内容都在这里。所以让我也删除这个。让我开始读取数据。因此默认情况下，Sp 已经上传。所以我写 Sp dot。Sk dot。

阅读 dot cv。我希望它能正常工作。首先，请记住，这是我的文件位置。文件位置，好的，文件下划线位置。然后我还会使用两个选项。一个是将 header physicalical 设置为 true。然后我有 infer schema 一旦我执行这个，现在你会看到第一次菜单执行时会显示启动并运行，所以我们将启动集群并运行它。我将点击它，创建失败，拒绝请求，因为节点总数会超过限制。这是为什么呢？让我们看看我们的集群，我们只有一个集群。

好的，这里有一些示例已经被提取出来。所以让我删除其中一个。好的。让我执行这个。好的，我会去这里。空格让我删除它，好的。完美。现在我将尝试读取这个。让我们看看。

再次，它显示创建集群失败，拒绝请求被拒绝，因为节点总数会超过限制，并且它不允许我们执行超过一个文件，我想。正因为如此。我只是重新加载它。现在看看。

现在它已经执行了，C 伙计们，之前有两个文件。所以因为这个原因，它不允许我运行。现在我删除了一个文件并重新加载了一个文件。好的，现在你可以看到它正在运行，你也可以按 shift tab 基本上查看一些提示，就像我们在 Jupyter notebook 中所做的那样。现在在这里你会看到我的文件运行得非常顺利，显示了 Df，显示它是 pipar dot sql do data frame do data frame 现在让我执行其他内容。

现在假设我想D点打印。看，我只是使用那个选项卡功能打印架构。如果我去看这里，你将能够找到所有的值，对吧，简而言之。这基本上现在在我的集群实例中运行，对吧。我将能够上传任何大型数据，可能是50GB的数据集，也可以从S3桶上传，接下来的视频我会向你展示如何从S3桶做到这一点。

但我接下来要向大家展示的，将会尝试通过数据运行所有这类问题语句，以便你们能够学习。好吧，现在让我再做一件事。这是我的D点显示。好吧，这是我所有的数据。可能我只想选择某些列。我实际上可以写D点选择，在这里。我只想说薪资点显示。

我只是选择薪资点显示在这里，你将能够看到。所以你想做的一切，你都能做到。请记住，在这里，你将能够找到大约15GB。而且你绝对可以执行任何类型的事情。好吧，这里也有相同的选项，就像我们在😊，你知道的。

在Jupyter Notebook中，每个选项都有，你将能够在Jupyter Notebook中找到所有这些特定选项，对吧，所以这基本上在15.25GB的集群中运行。好吧，在那个特定集群中，你有两个核心，然后你有Spark 3.1.1和Spark 2。

12。你将能够看到所有这些特定信息。所以我想要的是，请尝试为自己创建一个特定的环境，然后尝试启动它，尽量把一切准备好，从接下来的视频中，我们将尝试看看如何执行，如何实现问题语句，如何实现不同的算法，可能我还会向你展示如何从云端上传数据集，比如AWS，我们将从AWS开始，因为它有很多功能。

而且随着我们继续学习，可能会学到更多的东西。所以我希望你喜欢这个视频。如果你还没有，请订阅频道，下周见，祝你有美好的一天。谢谢你。Manal，再见。😊。

PySpark 大数据处理入门，带你玩转Python+Spark大数据操作与分析！＜实战教程系列＞ - P8：L8- Databricks 中的 Pyspark 多元线性回归实现 - ShowMeAI - BV1sL4y147dP

。

大家好，我叫Krisnak，欢迎来到我的YouTube频道，今天我们将继续Pi Park教程，在这期视频中，我们将进入第8个教程，利用Pipar实现线性回归。

😊，这是我在这里创建的整个播放列表，我还放了一段关于线性回归理论理解的视频。在教程8中，我们将选择一个问题陈述，并尝试解决它，可能是一个回归问题。

我们要讨论的第一个算法是线性回归算法，我们将尝试解决问题。这是一个多元线性回归问题，我们将在databs中进行。之前我已经给你们介绍了databs，我希望你们已经创建了账户并开始使用。如果你不知道如何创建账户，请观看教程7，整个播放列表链接将在描述中提供。

😊。

这是我的Datas社区账户。请记住，在社区版本中我们只能创建一个集群。我未来可能会购买升级版本，并尝试展示如何创建多个集群，但那需要使用一些云服务，比如AWS或Azure。现在首先。

我将使用什么数据？这就是我将使用的全部数据，这组数据称为小费数据。这意味着顾客在餐厅用餐时，基于总账单给予的小费，或者我也可以根据所有这些参数来解决这个问题，推算出顾客可能支付的总账单。这就是我要解决的问题陈述。这里你可以看到这是一个多元线性回归问题，具有多个特征。

让我们继续。首先，我将点击浏览并上传这组数据。😊。

为了上传这组数据集，我在我的路径中有这组数据。因此我可能也会将这组数据集分享给你们，所以不用担心。让我快速上传数据集，好吧。Ppar，好的，你可以看到这是我正在上传的小费数据集。

让我现在打开它，你将能够看到你的 tips 数据将直接上传到这个 Dfs 中。所以在这里你会有一些像文件存储/表的东西。好的。现在你可以做的事情是，点击这个 Dvfs，在文件存储上你可以看到，可能你也可以点击表。在这里你有这个 tips.dot.csv。我在之前的视频中也上传了所有这些数据。

可能我之前只是在使用这个。好的，但在这里我只是关注 tips.do csv。现在我将在这里做什么？让我们进行第一步。记住在数据湖中第一步是我们需要创建集群，好的。😊

现在就创建一个集群，默认是在社区版中。Datas 实际上帮助你创建一个集群，仅一个集群。好的。但是如果你使用的是付费版，升级版，它实际上会帮助你创建多个集群，如果你拥有 AWS 云的额外资源。

所以我就要点击集群，创建一个新的集群。我会说这是我的线性回归集群，好的。😊 然后我将使用这个运行时 8.2 的标量。这个就在这里。我只需点击集群，其他所有内容在这个实例中的几乎都是相同的。你将获得 15 Gb 的内存和其他所有信息，你可以查看。

你也可以获得两个课程和一个我 debutbu。好的，这个我之前实际上已经讨论过了。所以我将去点击集群，这将需要一些时间。记住，大家，如果你真的想使用任何类型的库，只需点击这里。😊

安装你想要的库，比如如果你想使用 seaborn，你想使用 scarers，你想使用 TensorFlow。所以在这里你可以基本上输入它们及其版本，你将能够安装它，好的，但现在我不需要任何库，我只会使用 spice plug，这就是我的菜单。所以，大家在这里点击集群，你可以看到，可能过了一分钟，这个特定的集群实际上已经创建了。好的，现在再次返回主页。

你可以创建一个空白笔记本，我已经创建了一个笔记本，以便我可以编写基本代码，所以我现在就打开它，开始这个过程。首先，我有一个称为文件位置的东西，我知道我的文件位置基本上是tips.csv，文件类型是csv，然后我正在使用spark do3.dot csv文件位置，header设为true，schemeche等于2，然后让我写Df.dot show，这实际上可以帮助我检查整个数据。好吧，我现在就要在你面前执行它，让我们逐行来，我会尽量把所有代码写下来，这一定对你理解有所帮助，所以请确保你也跟我一起输入代码，这样会更好地理解。好吧，现在我要执行这个，你会看到我的集群开始运行，然后你可以看到正在等待运行命令，我们可能会看到它。

我稍微缩小一下，这样你就能更好地看到。再说一遍，大家，第一次启动这个集群时会花一些时间。好吧，spark作业正在运行，现在你将看到我的数据集。😊这是我上传到这个特定文件位置的小费数据集。所以这就是我整个数据集：总账单、小费、性别、吸烟者、时间、大小，完美。现在让我们进入下一步，我将写Df.dot print schema。

所以我也可以使用tab，你知道的，它将加载整个内容。现在你可以看到这是我所有的特征：总账单、小费、性别、吸烟者、时间。所以这里是你所有的特征，比如double，性别是字符串，吸烟者是字符串，日期是字符串，时间是字符串。请记住，你可能会想：克里斯，我为什么要在databs中做这些，目的是让你理解它如何在集群中运行。现在我只有一个集群。

这基本上意味着这个特定集群中的最大内存大约是15 GB，但请理解，如果你处理的是100 GB的数据，这种处理会在多个集群中进行分割。因此，你将能够在即将到来的工作中处理大数据。现在我觉得这就是全部，大家，让我们来理解一下我的独立特征，独立特征是我的小费特征、性别、吸烟者、时间和大小，而我的依赖特征基本上是总账单。

根据所有这些特征，我需要创建一个线性回归算法，能够预测总账单。所以现在我在这里要写Df.dot columns。如果我想检查我的列，这里就是我的列，我可以看到这就是我的确切列，我实际上有这么多列。关于这个特征的一件事，你们有性别、吸烟者、日期、时间等列，这些都是类别特征，对吧？而且你知道，这些类别特征需要转换成一些数值，只有这样我的机器学习算法才能理解。所以让我们看看如何处理类别特征。这里我就写一个评论。

😊，好的。处理类别特征，对吧。现在我会尝试展示如何处理这种类别特征。现在。在Pispar中，我们知道在正常的电子表格中，我们尝试使用单热编码，使用普通编码，尝试使用不同的编码。同样，我们也可以在这里使用相同的编码，借助Pipar。因此，对于这个特定的过程，我们有一个叫做字符串索引器的东西。所以我就说从Pispar中，你知道，从Pispar.dot ml.dot feature。

😊，好的。我将导入一个叫做字符串索引器的东西。所以我会使用这个字符串索引器。这个字符串索引器实际上会帮助我们，基本上将字符串类别特征转换为一些数值特征。数值特征基本上是有序编码。比如如果我有性别，像男性或女性，它会显示为零和一。

在这里你会看到大多数类别的口头编码。现在你可能在想，单热编码是什么过程，我将在接下来的几个视频中尝试用不同的机器学习算法展示给你。之所以这样做，是因为一次学习一件事情更好，对吧？所以我会尝试展示所有这些例子。现在让我们继续，看看如何将这些类别特征如性别、吸烟者、日期和时间转换。

可能时间也是类别特征，看看这里。如果我看到这里的所有特征，让我做一件事。好吧，我就写D.dot show。😊，所以这是我所有的特征。快速查看，如果我去看，这个时间也是一个类别特征。所以快速的，让我们继续看看我们基本上如何使用这个。让我也删除这个东西。

或者让我稍等一下写一下。所以我实际上导入了一个叫做字符串索引器的库。现在我在这里要做的是创建一个索引器对象，命名为这个。我会写字符串索引器。😊，首先，我需要提供哪些是类别特征。现在，记住在这个字符串索引器中。

如果我按shift+tab，可能在这里你能看到我需要提供输入列。😊，所以让我加快一点，我需要提供输入列，并且我需要提供输出列。我还可以选择提供多个输入列和多个输出列。所以让我尝试这两种情况。好的，首先，让我尝试输入列。

所以在输入列中，我将提供我的第一个值。现在假设我真的想把性别列转换成。😊，我的类别特征。所以我在这里写输出列。好的，然后我会说sex_indexed。现在，这里我们实际上在做什么，伙计们。我实际上是在给我的性别列，而这个性别列将通过字符串索引器转换成一种独热编码。

好的，现在在下一步，我要做的就是写df。好的，我可能只会使用df，或者我可以创建另一个数据框。所以我会写df_score，可能会看到，因为我不想改变那个df，然后再运行那段代码，现在我会说indexer。

😊，点fit。好的，我肯定可以使用fit，然后可以使用transform。所以这里也是几乎一样的，只有伙计们fit_transform。这里我也要使用df。好的，然后如果我去看看df.df_score，现在你就能看到这个性别列将会创建一个额外的sex_index列，并且在这个特定列中会有独热编码的值。

所以我们去看看这个。一旦我执行。😊，完美，我觉得它正在运行。可能会需要一些时间。现在你可以看到我有一个额外的列，叫做sex_indexed。无论是女性值，值为1；无论是男性值，值为0，对吧。

所以我们处理了这个特定的列，并且基本上把这个类别特征转换成了独热编码。现在，我们还有许多特征。所以我要做的就是再次使用这个索引器。好的，我可能会在这里写。现在我将指定多个列。所以第一个列我已经更改了。我将把它更改为其他东西，sex。

代替性别，它将变成smoker。😊，好的，smoker。但是我给你们展示过。代替写输入列，现在我必须写输入列，对吧。所以在我给出的多个列中，这就是smoker。然后如果我看到还有一个特征是day和time，day和time是更多的两个特征。

所以我会在这里写day_。所以伙计们，现在我写了smoker、day和time。类似地，我会在这里再写三个列。第一个列应该是因为我要创建独热编码，所以我可能会在这里创建一个新列。这将是我的smoker_indexed，我在这里关闭括号。

我的第二个特征基本上是day underscore index，对吧？我的第三个特征可能是time underscore index。所以在这里我将创建三个特征，然后我给index dot fit Df underscore R，好吧。因为现在我有了我的新数据框，然后我将说Df underscore dot show。现在一旦我执行它，大家。我希望它不会给我们错误，好吧，它在说给出的Para输出列的无效参数值，无法转换类，所以我必须将其作为输出。

所以那就是问题所在，所以现在你将能够看到它执行得非常顺利。现在这里你可以看到所有可用的特征，sex underscore index，smoker underscore index，day underscore index和time underscore index，所有你在这里看到的都是编码，比如0。

12，对吧？我们现在已经将所有字符串值转换为该特征中所有可用的类别值的数值。现在我的模型肯定能够理解。好的，现在我们完成了，大家。接下来是什么步骤我们基本上要讨论的，现在步骤非常简单，因为我们已经创建了这个特定数据集。现在我们要做的是有一个叫做向量组装器的东西。现在总是记住，大家，在Pipar中，无论何时我们有所有这些特征，我们需要将所有独立特征分组在一起，而将依赖特征分开。

好的，大家，我们将从Pipar写作。😊，Dot。Ml dot feature。我将导入一个叫做向量组装器的东西，所以我将使用这个向量组装器。这实际上将帮助我们将独立特征分组在一起，而将一个依赖特征分开。那么让我继续写向量组装器，然后我将初始化它，第一参数我必须提供的基本上是我的输入列，在这里我的输入列有哪些，我先看看，在此之前让我快速做一件事，就是创建一个单元格。

😊，好的，向上移动一个单元格，创建一个单元格，或者让我删除这个，然后可能让我写一下。Df underscore R dot columns。好的，那么我们有多少列呢？所以我有关于列的所有信息。所以我这里的输入列，第一件我肯定要提供的是我的小费列，因为小费是必需的。

小费是第一个独立特征，它是一个数值特征。然后我有像sex underscore co indexed这样的东西。好的，我将复制这个并粘贴到这里。这是我的另一个输入特征。记住，大家，我们真的需要遵循顺序。

现在我的第三个特征基本上是烟雾指数。在这之前，我还可以指定大小，好吗？所以我会指定大小、性别指数、吸烟者指数，好吗？然后我可能还会创建天数指数。好的，指数逗号。我只是会使用时间指数。好的，所以这些都是我的独立特征，关于这一点，请记住这些将被分组在一起，我还必须说如果这些被分组在一起，让我们创建一个新特征，并给这个整个组命名，好吗？所以在这里我只是会说输出列等于，并且在这里我只会指定这些是我的独立特征，所以我会将整个东西命名为我的独立特征，简单得多。现在让我做一件事，创建一个叫做特征组合器的变量，这样就能转换这些值。特征组合器等于向量组合器，在这里我必须提供我的输入列和输出列，非常简单。接下来我要做的步骤是，输出等于，我只是会说点转换，因为我确实需要转换，并且这需要从我的 D_艺术中转换。好的，让我执行一下。

😊 它已经执行完毕，你可以看到整个输出，所有这些我创建的都是我的独立特征。现在在独立特征中，我们需要创建这些独立特征，这是 Pipar 中给出的规范。请始终记住，我们需要创建一组特征，并且这些独立特征可能会一起完成。现在如果我去看我的输出，点显示。

😊 在这里现在你将能够看到我能看到另一个特征，或者让我写上输出点选择，因为所有特征可能已经分组在一起，很难在一个屏幕上看到所有特征。我只会拿这些独立特征，点击点显示。现在一旦我这样做。

😊 在这里，你将能够看到所有这些特征。请记住，这需要按相同的顺序显示。第一个特征是小费，然后是大小、性别_指数、吸烟者_指数、天数_指数、时间_指数。所以这些是我的独立特征。现在我只有一个特征，在这里你可以看到它仅仅列出了所有特征，就像这样，这是创建的第一个主要步骤。好的，现在让我们进入下一个步骤。现在我知道我的输出是什么，接下来我要做的是，在这个整个输出中，如果我去查看我的输出。

😊 输出点显示，在这里你将能够看到所有特征都在输出点显示中可用。所以在这里你将能够看到所有特征都可用。现在，你知道哪个是你的输出特征，对吧？所以这是我的依赖特征，而这些独立特征是我的独立特征。那么我接下来要做的就是选择输出。

或者我会说这基本上是我的最终数据，我将提取两列，即 output dot select。😊在这里，我将给出我的两个特征。我将说一个是独立特征。好的，独立特征。我希望这个名称是正确的。否则，我会再确认一次。让我在这里点击。

独立特征和总账单，完美的逗号。总账单。好的，现在如果我去执行这个，我只是在提取这两个特征。现在，如果我去查找 finalize data dot show，现在我将能够看到两个重要特征。也就是独立特征和总账单。记住，这都是我的独立特征。

这是我的依赖特征。😊到目前为止，这非常简单。如果完成了，大家。下一步是我将复制和粘贴一些代码。我将应用线性回归。所以首先，从 Pipar do ml dot regression。我将导入线性回归。然后我将采取这整个最终数据，并进行 75% 和 25%的随机拆分，然后在我的线性回归中。

我将把我的独立特征提供为特征列。这是线性回归中需要给出的两个参数。一个是特征列，这里我将提供独立特征。第二个基本上是总账单，它是我的依赖特征。现在我只需在训练数据上进行拟合。一旦我这样做，我的回归模型就会被创建。

这可能需要一些时间。现在你可以看到所有的信息。你获得了关于训练和测试的惊人信息，记住，大家。我们制作的这个独立特征，是以 UDt 的格式呈现的。😊你可以看到 Uity 的全称，这根本不是大问题。好的，现在我有我的回归器。

所以我将要做的是说 regressor dot coefficient，因为这是多重线性回归。所以我将使用回归器的系数。这些都是我的参数或不同的系数。因为我大约有六个参数。所以这些都是六个不同的系数。

永远记住，在线性回归中，你将根据特征的数量拥有系数。你也会有。😊，截距。所以我将说截距。好的。这基本上是我的截距，0.923。现在你有了这两条信息。现在是时候评估测试数据了。

所以我将说 attached。这基本上是我的预测，对吧。让我写成这样。预测。好的。预测。我将写成 bread，underscore results。结果等于这个，这将是我的结果，好的。testest 没有定义。

为什么test未定义，因为这应该是测试数据。其实我很抱歉，没关系。你会遇到一些小错误。好了，现在如果我真的想查看我的预测结果，去看看bread的预测。会有类似于预测显示的东西，好的。😊如果你这样写，你将能够获得整个预测，好的。

所以记住在这个预测中，这是你的独立特征。这是你的总账单。这是你的实际值，这也是预测值。实际值，预测值。实际值和预测值在这里，你可以比较一下效果如何。你知道，通过查看你的总账单和预测值，效果非常好。相当惊艳。

你能看到数据。我将写下我的最终比较。好的，最终比较完美。我对此很有信心，你可以看到它。让我们看看其他一些信息，比如我们可以从中检查到什么。我们可能想查看R平方。

所以你可以写，你基本上可以写回归。如果我按下tab键，这个系数截距。然后你就会丢失。还有一些称为R平方的东西。如果我去执行这个。这基本上是我的R平方，或者让我写下来。😊我想预测。预测结果。

我不认为R平方是在哪里。让我们看看是否能够看到R平方值。稍等，我正在查看文档页面。哦，抱歉。我不需要在这里使用回归器。所以这里我将使用预测结果，让我计算R平方。所以这是我的R平方。类似地，你也可以查看预测结果的平均绝对误差。

所以你有平均绝对误差。你还有预测结果的均值平方误差。这三个值你可以确认一下。所以这里是你的平均绝对误差。这里是你的均方误差。这些是我的性能指标，我一定会有的。每当你们面临任何问题时。

只需确保查看Apache Spark的文档。这样，你绝对可以解决整个问题陈述。现在我给你一个作业。尝试在Google上查找，看看如何保存这个特定文件，可能是以pickle格式，或者可能是临时模型的pickle文件。你知道这非常。

非常简单。你只需使用回归保存，但试着看看如何保存这个特定的pickle文件。现在这就是关于这个视频的全部内容。希望你喜欢，现在就尝试解决其他任何问题陈述。

尝试在接下来的录像中做到这一点。我还会尝试展示如何进行独热编码，可能你也能学会。所以我希望你喜欢这个视频。如果你还没有订阅频道，请订阅，因为下周我会有精彩内容。祝你有美好的一天。

谢谢你们，大家再见。😊。

PySpark大数据处理入门，带你玩转Python+Spark大数据操作与分析！＜实战教程系列＞ - P1：L1- Pyspark介绍和安装 - ShowMeAI - BV1sL4y147dP

大家好，我的名字是Krisna，欢迎来到我的YouTube频道。那么，大家，我们将开始Apache Spark系列，特别是如果我谈到Spark，我们将专注于如何使用Spark与Python。所以我们将讨论一个叫做Pi Spark的库。😊

我们将尝试理解为什么实际上需要Spark，并且我们可能还会覆盖很多内容。有一个叫做Mlib Spark Mlib的东西，它基本上会告诉你如何在Apache Spark中应用机器学习。你知道，通过这个叫做Pipark库的Spark API。此外，我们还会在未来看到，一旦我们理解了Pipark库的基础知识，我们如何实际预处理我们的数据集，如何使用Pipark数据框，我们也会尝试了解。

我们如何在云平台如Databricks、Amazon、AWS中实施或使用Pipark，你知道，因此所有这些云我们都会尝试覆盖，并且记住Apache Spark非常方便。让我告诉你，给你一些理由，为什么Apache Spark非常好，因为你要理解，假设你有大量的数据。好的，假设我说我有64GB的数据，1。

8GB的数据，你知道，我们可能有一些独立系统，知道，在那里我们可能有32GB或64GB的内存。现在我正在工作的工作站有64GB的内存。因此，最大到最大，它可以直接上传一个32GB或48GB的数据集。但是如果我们有一个1.8GB的数据集，你知道，那个时候，大家。

我们不仅依赖于本地系统，还将尝试在分布式系统中预处理特定数据并执行任何类型的操作。分布式系统基本上意味着将会有多个系统，你知道，我们可以在这些系统上运行这种作业或处理，或尝试做我们真正想做的任何活动，Apache Spark肯定会帮助我们做到这一点，这真的是非常棒。而且，是的，人们非常想要这种类型的视频。所以我们将如何进行这个特定的播放列表，我们将首先。

从安装开始。我们将尝试使用Pipark，因为它也是Apache Spark，这是一个与Python一起使用的Spark API。当你实际使用Python时，我们基本上使用Pipark库。而且，是的，我们也可以使用Spark与其他编程语言，如Java、Scala等，我们将从基础知识开始，了解我们如何读取数据。

我们如何连接到数据源，可能我们如何使用数据框，在这个Apache Spark中，这是你的Pi。😊他们还提供你数据结构，比如数据框，这与Pandas数据框非常相似，但支持的操作有所不同，我们将逐一查看，然后我们将尝试进入Mlib Apache Spark Mlib，基本上称为Spark Mlib，它将帮助我们执行机器学习，在这里我们将能够执行一些机器学习算法任务，包括回归、分类、聚类，最后我们将尝试看看如何在云中执行相同的操作，我会向你展示一些示例，我们将有一个庞大的数据集，我们将尝试在分布式系统的集群中进行操作，并看看我们如何使用Spark，对吧？所以这些内容基本上都会覆盖到。现在Apache Spark的一些优势以及为什么它如此著名，因为它的工作负载速度是普通的百倍。

更快，你知道，这基本上意味着。如果你了解大数据，当我们谈论大数据时，我们基本上是在谈论巨大的数据集，对吧？如果你听说过这个叫做MapReduce的术语，Apache Spark的速度比MapReduce快得多，快100倍。好的。

并且它的一些优势在于易用性。你可以快速用Java、Scala、Python或R编写应用程序，正如我所说的。我们将专注于Python，并将使用一个叫做Pipark的库。然后你还可以结合SQL流处理和复杂分析。当我谈论复杂分析时。

我基本上是在谈论这个Mlib机器学习库，它肯定能与Apache Spark良好协作。Apache Spark可以在Hadoop、Apache Mesos、Kubernetes、独立模式或云端运行。当我谈到AWS DataBricks等各种云服务时，我们肯定可以工作。它实际上在集群中运行，集群基本上意味着分布式。因此，这些都是一些示例。

现在，如果我谈到我们将使用哪个版本的Spark，我们将使用3.1.1，并尝试进行工作。如果你在这里搜索一下，你可以看到SQL和数据框架，以及Spark流处理，机器学习被称为机器学习。除此之外，如果我查看概述，你会看到Apache Spark是一个快速的通用集群计算系统。

它提供了高效的API，可以在Java和Python中进行扩展，这使得并行作业的编写变得简单，支持通用计算图的优化引擎。所以它基本上是用来处理大量数据的。😊而且简短，你知道的。这非常方便。我们将尝试工作。现在，如果我去搜索这个Python中的Spark，你知道，这个页面基本上会打开，我们将讨论如何安装它。

在这个视频中，我们将尝试安装Pipar库。如果我谈到Pipar库，你会发现Pipar库非常棒。这个库是如果你真的想在Python中使用Spark功能的话，你基本上会使用这个特定的库。让我们继续，看看我们能多快做到这一点。

😊是的，我们如何快速安装特定的库，并检查我们可以实际做些什么。好的，所以我们将尝试看看所有这些内容。那么让我们开始吧。请确保在使用Pi时创建一个新环境。所以我创建了一个名为my的新环境。在这里，首先，我将尝试安装Pi库。

所以我将安装Pipar，让我们看看在这方面我们将专注于安装。我们将专注于读取一些数据集，并尝试看看我们实际上可以做些什么。好的，完成这个之后，我们可以看到我们的Pi已经安装。为了检查安装是否完美，我将写import Pi。所以这看起来完全正常，它正在工作。我们能够看到Pi基本上已正确安装。现在你可能会遇到某种问题。

这是关于Pipar的，所以这就是我告诉你创建一个新环境的原因。如果你遇到某种问题，😊请告诉我你遇到的错误，可能在评论区写一下。好的，现在我们来做一件事。我会打开Excel表格。好的，可能我会试着创建一个。

一些数据集，我会说名字，可能我会说名字。还有H，对吧。假设我在这里写的名字是squan，还有31。我会说Suan S。对吧，Shoan Shu。我会说，好的，30。可能我会再写一些名字，比如Sunny。可能我还会给出数据29。

所以这三个数据我们将尝试看看如何读取这个特定的文件。好的，我要保存它。让我们看看。我会将其保存在与我的Jupyter笔记本相同的位置。嗯，我创建了一个文件夹，我想。你可以将其保存在任何打开笔记本文件的位置，对吧，所以这不是必要的，只是确保你没有看到我的文件。好的。

我正在保存它。好的，我将其保存为test 1。在这里你可以看到。我将其保存为test 1.dot CSV。所以我会保存它。让我们保持这个特定的文件已保存。好的，现在如果我可能想要，你知道。😊！

用pandas读取。所以我们写的是pd.read_csv，对吧。我基本上使用这个数据集，叫做testest1.CSV，对吧？所以当我在这里执行时，你将能看到这个特定信息。现在，当我真的想用Pipar时，首先，记住。

我们需要启动一个spark会话。为了启动spark会话，首先让我创建更多字段。请看这个。请遵循创建pass会话的特定步骤。所以我将写from Pipar，Dot sqL，Import Spark session。好的，然后我将执行这个。你可以看到它表现得很好。然后我会写，抱歉。我不知道打开了什么。

所以我将创建一个名为spark的变量，可能我将使用spark session.builder。我会说应用名称，这里我只会给我的会话命名。好的，所以它将是练习。假设我在练习这些东西。然后我可以说获取或创建。所以当我实际执行时，你将能看到一个spark会话会被创建。

如果你第一次执行，它可能会花一些时间，除此之外，如果我多次执行，那你就能使用它。现在在这里你绝对可以看到，当你在本地执行时，总是只有一个集群。但当你在云中工作时，你可以创建多个集群和实例。好的。

所以你将使用的spark版本是v 3.1.1，在这里你可以看到，这基本上存在于主节点，当你可能在多个实例中工作时，你将看到主节点和集群的信息。好的，这与Spark有关。现在我将写Df of pipar，我将尝试读取一个数据集。😊，关于spark。好的，现在为了读取一个数据集，我可以写什么。

我可以写spark.Read，然后有很多选项，比如CSV格式、JDBC、parquet、scheme或文本等，所以这里我们将采用CSV，我只是写tips1.Teps 1 do C，对吧。如果我试着在这里执行，我收到一些错误，说这个特定文件不存在。

让我看看。我想这个文件是存在的。嗯嗯嗯。让我看看，为什么这个没有执行。Ti 1.D F file open。这里我能看到test 1.CV。好的，抱歉，我没有写那个CSV文件。我想是test 1.CSV。好的，这现在工作了。现在，如果我去看D dots Pipar，它显示这两个字符串，对吧，这两列C0和C1。现在你可以看到，伙计们。

我创建了这个特定的 Cv 文件，它只是将 A B 作为默认列，可能它在说 C0 和 C1。所以我们实际上可以做的是，可能如果你真的想看到整个数据集，你可以基本上像这样看到 Df underscore Pipar dot show，在这里我们能看到 name 和 age，我真的想把我的列名或 age 作为我的主要列。但当我直接读取这个 Cv 文件时。

可能我们得到了 underscore c0 underscore C1。为了解决这个问题，我会使用不同的技术。所以我会写 spark dot read dot option，这里有一个叫做 option 的东西，在这个 option 中，你可以基本上提供一个选项。

😊，Header，像我看到的，会有一些像 key value 你将在 option 中提供的东西。所以你可以这样做，你可以写 header.commer true。这样，第一列第一行的值将被视为你的 header。如果我写 Csv 以测试1，现在，我就要读取这个 test1 数据集。

Test 1 dot CS Sv。现在，一旦我在这里执行这个，你会看到我能够得到现在的 name 字符串和 H 字符串。好的，但让我们看看我们的完整数据集。所以在这里，如果我现在执行这个，我将能够看到整个数据集与这些特定的列。好的。所以让我迅速地将其保存在我的 Df underscore Pi spark 中。😊，现在。

让我们去看看 type of D F underscore pi spa。好的。现在，当我在这里执行这个时。你们会看到，大家，当我在阅读这个 Df 的时候。对，当我使用 pandas 的帮助来查看这个类型时，你会看到有 pandas dot code do frame do data frame。但在这里，你会看到，当你在读取这个特定数据集时。

它是 Pipar do sQl do data frame do data frame 类型。是的。所以 pandas 数据框是 sQL dot data frame data frame。是的。大多数 API 几乎是一样的。功能也是一样的。随着我们继续前进，还有很多东西我们会学习。但。😊，如果我快速想看到我的。可能，我不知道 head 是否会工作。让我们看看。是的。

head 也可以使用。所以如果我使用 dot head，你可能会看到我在这里基本展示的行信息。现在，如果我真的想看到关于我的列的更多信息，我可以使用一个叫做 print schema 的东西，现在这个 print schema 就像 Df dot info。

这实际上会告诉你关于列的信息，比如 name 是字符串，age 也是字符串。好的，这些都是你在安装之后实际执行的一些基本操作。我要强调的主要原因是，尽量安装这个 Spark，并为我的下一个课程做好准备，我会尝试向你展示如何更改数据类型以及如何处理数据框。

我们如何实际进行数据预处理，如何处理空值和缺失值。我们如何删除列，如何做各种事情。这些内容基本上都会在那儿讨论，如何删除列。所以我希望。😊。

像这个特定的视频。这只是我对PySpark的介绍，好的。我们将继续下一个环节。可能。我还会在我的GitHub上提供这些信息，那里我们可能会，好的，PySpark已经在那儿了。

我。基本介绍，好的，所以我们将尝试完成这个，我们会尽量涵盖所有内容。在下一个环节中。记住，大家，我们的主要目标基本上是让你理解我们如何在云端工作。在此之前，我们真的需要了解所有基本知识，关于Pipar。但确实，这是一个令人惊叹的库，它将帮助我们实现所有与Python相关的Spark API功能。

所有与机器学习相关的内容，我们也可以借助Pi来完成。所以我希望你喜欢这个视频，我们下个视频再见，祝你有个愉快的一天。谢谢大家。😊。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P1：1）Python介绍和设置 - ShowMeAI - BV1yg411c7Nw

大家好，我的名字是Brian，我们要学习Python 3。这个视频系列面向完全的初学者。所以如果你没有任何编程经验，这就是你需要观看的内容。现在，我们将在这个特定的视频中介绍如何安装、配置和测试Python 3。我会尽量每周做一个视频。所以一定要经常回来查看，因为我会尽快更新这个系列。

😊，让我们开始吧。好的，第一步非常简单。检查Python是否已经安装。现在，你可以并且可能应该使用你的操作系统文档来确认是否已安装，但一个非常快速的方法是打开命令行。你不知道如何打开命令行，我强烈建议你去谷歌搜索一下如何打开命令行。

这并不难，一旦你到了这个步骤，输入类似这样的内容。Aan。3。如果你看到这里有“Python”，然后是某个版本，那就已经安装好了，可以跳过下一步。然而，如果你没有看到这个，如果出现命令未找到或未知命令的提示。

然后你需要跟随下一步，实际上安装Python。特别说明，很多文档会提到输入“Python”这个词。这是Python的旧版本，这是Python 2。

看到这里，完成Python 2，我们将使用Python 3。

好吧，假设你打开了命令行并尝试Python 3，但得到了一个“命令未找到”或“未知命令”的提示。你需要安装它，去Python.org然后进入下载页面。

从这里你可以选择所有版本，或者进入你特定的操作系统。我们将去所有版本，它会尝试自动检测你正在做的事情。然而，你可能需要选择你的操作系统。你们中的大多数人可能都会使用Windows，所以我将直接点击Windows。

然后点击Python 3版本的最新一个，注意这是Python 3，而不是Python 2。然后向下滚动。他们把这些混在一起了。你会注意到，你猜对了，有一个tar包，适用于Mac。然后还有适用于Windows的内容，Windows有大多数选项，这就是为什么会有点混乱。

说实话，我会选择这个。Windows X 86 64可执行安装程序。这将是一个离线安装程序，应该包含运行所需的所有内容。你将下载这个可执行文件并运行它。你可能会被提示以管理员身份运行，并且在安装完成后可能需要重新启动计算机。

你绝对需要回去仔细检查。你应该能够打开命令行并输入Python 3。如果你无法到达这一步，你可能需要去谷歌查找你的特定错误信息，以弄清楚发生了什么。

现在Python已安装和配置好，我们可以打开命令行并输入Python 3。我们需要测试这个东西，确保它确实按照我们预期的方式工作。首先，我会把这个拖上来，以占据屏幕的其余部分。我们在一个叫做交互式Shell或交互模式的环境中。

我们不会太多地使用这个，因为，嗯，这有点繁琐。如果你拼写错误，几乎不可能回去修正它。所以我们将使用一个IDE。不过现在我们只是测试，我希望你做一些类似的事情，比如说。X等于5乘以3。现在我们要输入单词print。然后，假设X。注意这在括号里。

所以我们稍后会介绍所有这些，现在我们只是简单的测试。你应该在屏幕上看到15。坦率地说，输入Python 3并查看版本才是真正的测试，这是否有效。然而，我想给你展示如果你想的话，有一个交互模式。不过，再次提醒。

回去编辑配置真的很困难，你会犯错误。所以我们根本不打算使用这个。我们将使用IDE或集成开发环境。我们将在下一步中介绍它。

说到集成开发环境，实际上有很多很多。如果你在谷歌上输入Python IDE，你将会得到很多。

数以百万计的结果，因为字面上有成千上万的ID。坦率地说，你不需要任何花哨的东西，你可以使用一个简单的文本编辑器。真的。IDE实际上就是一个非常花哨的文本编辑器，具有很多额外功能。你可能会发现很多文档说IDLE直接与Python一起提供，但这已不再准确。

你必须单独安装它。个人而言，我不喜欢它。我觉得它不是最好的，Pycharm是另一个不错的选择。但我们将使用一个叫做Visual Studio Code的工具。我知道很多人并不是微软的粉丝。

你不必强迫自己使用这个，虽然这是我将用于这一系列的工具，而我可能会在过程中随意更改ID，具体取决于我想编写的代码，因为Python让这变得非常简单。

我使用Visual Studio Code的原因是，它非常简单，直接，这就是它的样子。

所以我在这里要做的就是添加一个文件夹。

我将进入Python 3。关闭这个。现在我需要添加一些扩展。这就是我喜欢Visual Studio Code的原因。你可以扩展它以支持几乎任何语言。所以我将说Python。你会看到，很多，我是说，非常多。我可以永远向下滚动，几乎到无穷无尽的地步。

有很多扩展，但它很出色地将最佳扩展放在最上面。你可以看到这个家伙。从微软，2600万次观看，5星评级，你只需简单地去。好的，你真的需要它吗？这是个好问题。因为你可能会花几个小时去安装这些扩展，却不知道自己真正需要什么。

所以我们将稍作绕行。回到这里。这只是我们打开的文件夹。我将说新文件。我们称之为test.py。它会自动为我们推荐扩展。Python文件以.py结尾。所以它检测到这个扩展并说，嘿。你想使用推荐的扩展吗？

所以我想说，为什么不呢？它将自动去安装它们。并且会显示已安装。并且在全局使用，搞定了。我们甚至可以点击这个小齿轮图标来玩一下。如果我们真的想的话。让我们回到文件，或者我们可以在这里使用，取决于你想怎么去。现在这是我对Visual Studio Code唯一的真实批评，它确实会稍微混乱UI。

所以偶尔你会看到我关闭一些东西。我将开始使用这个家伙。好的，来总结一下这个视频。我们将创建一个叫做hello world的程序。这是你在任何编程语言中都会制作的第一款应用程序，实际上是程序员的入门仪式。它非常简单，只是在屏幕上打印出“hello world”这几个字。

这就是我们如果没有完全配置时会遇到一些障碍的地方。所以在你面前应该是我们迄今为止所做的一切，你应该有你的IDE，无论你使用的是什么，即使只是一个简单的文本编辑器。你应该有一个名为test.pyy的空白文件，文件名并不重要。最后但同样重要的是。

你应该能看到Python解释器。我有Python 3.6.9。如果你想，可以切换到不同的版本，只需注意你可以使用不同的版本。我将输入单词print。然后我们给它加上括号。括号里的任何内容，它都会尝试打印出来。现在用Python。

你可以使用双引号或单引号。我有使用双引号的习惯，但实际上选择哪个都无所谓。然后输入单词“hello”和“world”。点击保存。现在你应该有一个小图标，上面写着在终端中运行 Python 文件。如果没有，你可以在这里找到几个选项。

开始调试和在不调试的情况下运行。如果你是新手，立刻就会觉得这些意思不明。调试听起来真的很糟糕。那么这到底是什么意思呢？调试是编程中的一种特殊模式，如果你的代码中有错误或故障，它会引导你解决问题，或者更确切地说，会指出它们，以便你可以修复。

通常，我会在不调试的情况下运行，因为这样会快一些。你应该在屏幕上看到类似于“Hello world”的内容。所有这些看起来都很糟糕，但实际上发生的事情是你有 Python 3 的安装路径，然后你猜到了它在后台所做的一切。

它在调用这个启动器，并且说运行这个脚本。最终结果就是这样。现在，因为我不是“Hello World”的忠实粉丝，因为它太过简单，所以我们实际上。要去掉它。我们想回到之前做的事。交互式 shell。在那里我们要说 x 等于 5 乘以 3。我们正在创建一个变量，接下来我们将在下一个视频中讨论变量。

但我们现在要做的就是简单地打印出来。保存这个，然后我将继续运行。

你可以看到，这里有 15。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P10：10）Python字典：键值对与索引 - ShowMeAI - BV1yg411c7Nw

大家好，我是布赖恩。在这个视频中，我们将讨论 Python 3 中的字典。那么什么是字典呢？它是一个键值对，更确切地说，它是一个由键索引的列表。如果你想更具体一点。你注意到括号了吗？这实际上是一个由键索引的集合。

😊，这可以是任何不可变类型，这意味着任何不可变类型意味着不可更改？

所以让我们来看看，创建和使用字典需要什么。让我们看看实际创建字典需要什么。我们将用两种不同的方法来完成这个。我们将用困难的方法和简单的方法。首先，我们先用困难的方法。我必须说 D 等于。我们有了我们的括号。

我们需要一个键值对。所以让我们创建这个键。它将是字符串 pet。Polen。现在我们需要一个值。我们说，狗。就这样。这就是所有内容。现在，如果我们想再创建一个，我们只需用逗号分开。现在我们需要一个键。我们称这个为 age。B 将是五。让我们再创建一个。

我们称它为 name。它的值将是 spot。我总是很难为宠物取名。然后将字典完整打印出来。看，这就是它。宠物狗，年龄 5，名字 spot。现在，让我们用简单的方法来做。我将说 D 等于，我们将调用 diic 函数。兔子名字。在课堂上大声说出来，看看大家的反应。

但我们将说 pet 等于。狗。年龄等于。5，名字 spot。所以这里真正发生的事情是它为你做了所有这些格式化。这就是我称之为简单的方法。最终结果。然而，完全相同。它们是完全相同的，无论你以哪种方式创建它。

只要知道，你必须有一个键值对，例如，pet dog H5 name spot。让我们看看键和值，以及我们如何获取它们。实际上还有第三种类型，它叫 items。我们将首先处理这个。所以我们将说 print。然后我们调用 F。Items。我们将调用字典的 It 函数。保存并运行。

这将返回一个 di underscore items，正如你所猜的那样。看看这个东西。这太疯狂了。所以我们有一个包含元组的列表。但它真正做的是将其打包成单独的项目，以便你可以非常清楚地看到键值对。对我们来说并不是非常有用，我们真正关心的是，嗯，键和项目。

那么我们来快速查看一下。我只想说keys和values，我之前提到过items。好吧，我们想查看键和值。保存并运行，瞧，我们返回三种不同的东西，di_underscore_items，di_underscore_keys，di_underscore_values。但我们得到的是这个字典中所有的信息，正好在这三个函数中。

看一下项目返回的内容几乎是所有打包好的信息，关键是。这将告诉我们可用的键，因为要记住，所有内容都是键值对。所以当我们查找某个内容时，我们不能按索引查找，而是必须通过键查找。这就是这些键存在的原因。你可以轻易将这些键设为整数或其他类型的数字。

但我们已经将其作为字符串处理。我们还可以获得值dogg5和spot。没有键的话，这些值几乎没有用。所以在接下来的部分中。我们将看看如何实际获取这些值。

让我们看看如何从一个键获取一个值，因为这些是键值对。之所以称之为键，是因为它解锁了值的大门，让我们看看我的意思。因此我想格式化这个，我要说。Name，让我们将其大写。然后我们要说D，你倾向于这样做，D0。让我们在键错误中运行这个。

这是什么意思，键错误，它意味着未找到该键。我们没有名为0的键。然而，我们有一个名为name的键，还有一个名为PE和age的键。所以你必须使用键来获取值。让我们演示一下。看，名字是spot。现在，你会注意到我有不同的引号，我有单引号和双引号。

这里有一个非常有趣的问题，如果我们在单引号内再使用单引号。坏事很快就会发生，我们会得到一个无效的语法错误。你会想，现在等一下。应该将这些括号中的内容视为一个独立的实体，但实际上并不是，因此你确实有。我们在之前的视频中讨论过的引号问题。

好吧，现在我们对这一点有了初步了解。让我们深入研究一下键错误。我们称之为测试。假设blah是一个我们知道不存在的键。实际上，这里的情况是它正在查找任何该值的键。

如果找不到它，会抛出键错误。在这一切的最后，我们将向你展示一个使用一些简单逻辑的小技巧，我们还没有讨论过，以解决这个问题，确定键是否存在。但现在，请知道你必须拥有该键，否则它会抛出错误。所以请记下这一点，如果未找到键，我们会抛出一个错误。

让我们看看将项目添加到字典中有多难。其实并不难。这简单得可笑。你只需这样做。就这么简单。你只需说字典，然后一个未使用的键等于一个值，它会自动添加。这真的很酷。现在，你应该注意，我们只是复制并粘贴这个。

如果键已经存在会发生什么？所以我们在这里添加。那么，接下来会发生什么呢？让我们运行一下看看。它只是简单地改变了。这就是我所说的键是不可变的。我们不能改变这个键。我们可以删除它然后重新添加。但一旦这个键在这里，我们能做的只是更新值或删除它。键本身无法改变。

让我们看看移除项目需要什么。我们老朋友，删除语句。所以我们要删除。你猜对了，那个技巧。现在这就是我所说的键值对，当我们运行它时。如果我们删除一个键，那个键关联的值也会被移除。你在这里看到。技巧滚动。

我们已经删除了它，现在它就简单地消失了。它不在里面。这很简单。但要理解的是，一旦你删除了键，值就消失了。然而，如果你试图删除值，键会存在，但你会得到一个空值。这可能会导致一些问题，这是一个更复杂的话题，我们将在未来的视频中讨论，我只是希望你注意到这一点。

我收到了很多关于这个视频系列的好评，有人说，嘿，伙计，你的速度有点慢。我意识到这些是给初学者的，但我现在想要更多。所以我们将给你一个即将到来的小预览。我们将测试存在性，并做一些叫做循环的事情。

这两者可能对新手程序员来说有点挑战，但如果你是经验丰富的程序员，现在只想学习一下。让我们过一下，先搞定它。所以我们说，如果，这就是基本逻辑。我说，名称。在。李可文。然后按回车。我们在这里做的是一个if语句，这是一种逻辑。如果。

这个键在字典中做某事。现在，Python有这个小家伙，在最后有一个冒号，表示嘿，这不是语句的结束。还要期待更多。然后你必须有。它可以是空格或制表符。其实没关系，但必须是相同的数量。如果你来自其他语言，你可能会期待这样的东西。你可能会想。

为什么需要制表符？嗯，如果你考虑一下，你的代码。是的。如果你去掉制表符，效果就是这样，所以这很合理。但很多初学Python的人无法理解制表符或空白，这让他们很沮丧。

所以。这就是我之前说的，我们要测试这个键是否存在，然后再尝试访问它。如果这个键不在字典中，就会抛出一个键错误，但我们是说如果。所以，只有当这个键在字典中存在时，我们才会运行这段代码。我们会在未来的视频中更详细地讨论这些内容，但我已经听到很多人说嘿。

他们现在想要更多，所以有一个，现在让我们来讨论循环。这是另一个让人感到困惑的事情，尤其是在新手阶段，因为他们是新手。他们不理解这些东西。没有人向他们解释过。什么是循环呢。你小时候有没有遇到麻烦，你的妈妈或爸爸说。

你知道，继续这样做，直到我告诉你停止，这基本上就是你在告诉计算机做的事情。你会说四。K。在这些。这可能会让完全新手感到困惑。再次强调，你必须有那个空白。我们接下来打印。让我们格式化一下。接下来我会解释这个。但此刻。

你要在这里和我一起大胆尝试。所以我们得到了我们的键。然后我们会说字典，然后是具体的键。如果你是新手，这看起来很糟糕。但让我们运行它，确实有效。所以它在说。狗狗，H 5名字spot。这就是我们正在做的事情。那么这里发生了什么呢？我们在说对于每个键。

那个“in”关键字又出现了，字典的键，记得我们在这里提到过。对于字典中的每个键，打印出该键及其相关的字典值。再次提醒，你必须有那个制表符。我们将在未来的视频中涵盖循环，但这是因为人们一直在说我们想要更多，现在就想要更多。所以，如果你对这两个内容感到困惑。

不用担心，我会制作一个未来的视频来深入探讨这些内容，我们会讨论它们，我确实是说深入探讨。但如果你是一个有经验的程序员，这样做非常简单。如果你在理解这些制表符时遇到困难，只需想象成这样。你有一些代码。然后，通常你会做这样的事情。

Python在这里试图帮助我，但你会有类似的代码，把它替换成那个。当然，你这里会有一些。糟糕的代码，我知道。假设这里是糟糕的代码。但然后你将这些去掉，它就变成了那样。这就是为什么Python比其他语言更简洁，相较于像Java这样的语言。

Javascript，因为它将所有特殊字符移除了。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P11：11）Python流量控制：If - Else - Elif - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好。我是Brian，让我们继续我们的Python 3之旅。在这个视频中，我们将讨论if else和ElF。这三者是什么呢？其实很简单，这是流程控制。当我们谈论流程时，我们在谈论应用程序的流，而这是流程控制的基本构建块。

在深入之前，我们需要谈谈一些基本理论。别担心。我会保持超级简短。我们有一个变量。我们称之为X，而x为真。一个非常简单的布尔值。我们可以打开它。我们可以关闭它。现在，我们在讨论流程控制。把流程控制想象成，当你还是个孩子时，你的父母看着你说。

如果你这样做，那么将会发生这个。这就是我们要讨论的本质。这是一个决策。理解起来并不是特别困难，但确实需要一些解释。所以X等于真。我们有我们的if语句。如果它将在某种条件下运行。条件。大多数情况下将评估为真或假。所以我们将说如果x等于真。

那么，做一些事情。如果它为真，我们将有一些代码会运行；如果它为假，我们也会有一些代码会运行。现在，这并不总是这样。我所说的意思是，有时候这边根本不存在。你只会评估为真，但你可以做这样的事情，比如说，如果它是真的。就这样，否则就那样。它可以像一本书一样阅读。你可以字面上说，如果Bob.Equals快乐。

如果Bob不高兴，那就做其他事情。就是这么简单。然而，你需要明白这是几乎所有应用程序的基本构建块。这叫做流程控制，你在控制应用程序逻辑的流。好吧。足够的理论。让我们直接开始。我们将查看if条件，所以。

我们将创建一个叫做X的变量。并且我们将说它是真的。这只是一个布尔值。我们以前见过这个。现在我要说if，你会注意到在VS代码中，它给了我们这些小模板。我们只会做普通的if。我们将说if x。Polen。

现在我们想打印一些内容。让我们运行这个，看看会发生什么。结果显示是的。所以我们的编程逻辑是x为真。如果x，注意我刚刚说的if x。我们可以说if x.Equals true。那它将打印出来。但它知道，你实际上不需要那样。还要注意这一点的深入。

我们之前谈过这个，还有这个冒号，所以如果你来自其他编程语言。这实际上是底层的样子。你有这些括号，大家都喜欢，C++、C#、JavaScript，以及所有C风格的语言，代码基本上是有缩进的。而Python省略了这些，所以所有这些都转换成那样。而且它更简短，更容易阅读。

你不需要担心那些奇怪的波浪线了。现在你可以继续执行。只要它在同一个缩进下。例如，如果X为真，则打印yes和again。看看yes和again。现在我们要说else，这就是我们返回的地方。需要在这里告诉Python我们还有更多内容要处理。

我们将简单地打印哦。当我们运行这个时会发生什么？好吧，x为真。所以如果x，然后它会运行这个。否则，它将运行那个else很有趣，因为else说。如果这没有发生，那么就运行这里的代码。每当你看到这些缩进时。把它想象成一个代码块，实际上称为作用域。

所以这将是一个作用域，这也将是一个作用域。这是一个更复杂的话题，我们将在未来的视频中讨论，但我希望你知道它的存在。让我们继续运行，你会看到yes和again，它从未打印no。我将说help，意思是确保这在屏幕上真的很突出。再运行一次。我们从未看到它。为什么，因为这是对的？如果x。那么打印这个。它从未跳到L。

所以让我们更改这些默认值。你会感觉到编程逻辑是如何进行的。X现在为假。它会说如果X。打印这些else，打印那个。那么这里会发生什么呢？它会到达x并说，不，X不为真。所以忽略这个代码块，而是跳到else并运行这个代码块，看看help。

按预期工作。

我们实际上讨论的是条件评估。它们基本上会是真或假，意味着真，就运行；假，就不运行，或者做一些完全不同的事情。让我们来看一些条件评估。我将说x等于100，y等于25。

所以我只是创建了两个小变量，我们将说如果。我们要说y等于x。我们想告诉Python还有更多内容要来。我们要打印这个。注意我在一行上完成这一切。你不一定需要做这些制表符缩进。如果你愿意，可以在一行上完成所有内容。所以我们在说如果y等于x。

注意有两个等号。如果你这样做，你是在说让y等于x的值。我们不想要那样。我们想在这里测试相等性。我们将说，be个潮。通过复制和粘贴的魔力，我们可以稍微加快这个过程。我们将查看我们的条件评估器。所以我将说如果y不等于。

然后我们可以说小于。所以如果 y 小于 x。而我想说大于。所以如果 wise 大于，这里真正要表达的是，你可以基于值进行一些非常复杂的决策。它们非常简单，易于理解，你所需要的只是理解符号。例如。

这个家伙看起来超级混乱，但我们在说如果 y 小于或等于。注意你有这个复合条件，所以现在这变得非常复杂，并且你把它都放在一行中。但这样做是非常方便的。你也可以做确切的应用，但你可以说大于或等于。我们来测试一下。

所以我们要运行这个，你可以看到它并没有打印出所有内容。它说不等于、小于和小于等于，那么这里到底发生了什么？

我们在评估 y 与 x，所以我们在说 y 是否等于 x，实际上并不相等。它们是两个不同的值。所以它不会运行这段代码。这就是我所说的条件评估会变为真，执行代码，或者为假，不执行代码。还有其他方法，但我们保持超级简单。

然后我们在说如果 y 不等于 x，这将评估为真，因为这两个是不相等的。那么打印这个出来，果然我们看到了。不等于。我不会逐行讲解，但你可以查看并看到这些哪个评估为真，例如。y 大于 x 吗？当然不是，25 小于 100，所以这永远不会运行。

而且我们在这里看不到它。现在，如果我们改变这个值。你会注意到输出也会变化。现在它不等于，但它大于或大于等于。这是极其酷且灵活的。现在，你开始理解我们的计算机是如何做决策的。它基于简单的 if 逻辑。😊

如果这个语句或这个条件评估为真，那么执行一些特定的代码。

好吧，这一切看起来都很酷，但看看这个。这有点混乱。它只是一大堆 if 语句。阅读起来非常困难。没有缩进。然后你得逐个阅读才能找到你想要的。我们来谈谈 LF，这实际上是一种切换解决方案，当我说切换时。

其他语言有一个叫做 switch 的概念，就像想象一个大型的灯开关面板，你可以开关它们。Python 并没有这个概念。有变通的方法，但它并没有这个特定的概念。所以让我们看看如何绕过这个。我要说 x 是 10。现在我们想要一个开关组。

我们希望能够随意开启和关闭代码。所以我将说如果。X 等于 25。那么我们只需打印出。Segals 25。现在，我们想把这个合并成一个不完全新的 if 语句的东西。我们希望这一切保持在一行，因为信不信由你，这实际上是两个不同的语句。它们将分别执行。所以我们要做的是 L F。X 等于 50。

所以现在它将把这一切作为一行来读取，因此它将说如果 x 是 25。执行这个，否则，如果 x 是 50，执行这个。我们可以将这个概念不断扩展。继续。说如果 X 是 75。然后我们可以说 100。我们可以结束这个，说你知道吗。如果我们没有找到任何这些开关，使用 L A 语句。

我们可以简单地说 else，然后做一个称为捕获所有的内容。如果没有这些触发，它将执行。所以它在 10。让我们看看这里会发生什么。它触发了我们的捕获所有，看到了吗？

所以它遍历并评估并说 x 是 25 吗，不，是 50 吗，是 75 吗，是 100 吗。Else 被触发。让我们把这个改为 75，看看会发生什么。你可以看到现在它只说 x 是 75。那么这里发生了什么呢？它说。评估这个，评估这个，评估这个，转为真。现在运行这段代码，我们完成了，所以它将跳出所有。非常简单，非常容易的逻辑。

它看起来比这堵巨大的文字墙好得多。非常容易理解。随着你深入编程，你会发现如果你不喜欢 L，还有另一种方法。还有一种方法，称为嵌套语句。这基本上是一个语句中的语句中的语句中的语句。

你可以一直继续下去。让我们去看看。所以我将说 x 等于，并且我们随便选一个数字 82。我们说它 X 大于 50。然后我们说超过 50。但把这个放在一些引号里。因为它大于 50，我们想继续。所以我想说 e x 实际上，大于 60。然后。

我们可以一次又一次使用相同的逻辑。这样就形成了一个非常重复的模式。例如。我可以这样说，我们只需抓住这个并继续。注意缩进是如何越来越大的。你必须这样做，否则。

Python 将其视为一个新语句。因此，例如，这里实际上会创建一个问题。它不会按照我们想要的方式执行。因此，我们需要缩进，缩进。这就是我喜欢 VS Code 的原因，它在缩进的位置放置这些行。现在你可以看到这是一个语句。这是一个语句。依此类推，它变得非常。

非常酷，非常迅速。现在，有时候粘贴会背叛你，你必须重新缩进。行会是你的指引，真的告诉你该去哪里。假设，如果超过90。我不想让这变得太荒谬。我们继续说，F。X大于或等于100。我们就到这里结束。Pri。

就说X代表某种进展吧。现在，一开始我们就遇到一些问题。我看到这个小波浪线，它表示意外的缩进。所以我们得把这个退回去，修正我们的缩进。哦，它不喜欢这个。所以我们可以抓住整个内容，然后把它放进来。应该修复了，看，成功了。保存并运行。哦。

我们又遇到了一个缩进错误。看看这里发生了什么。这是Python的一部分，会让你感到非常烦躁。如果你的缩进不正确，它会告诉你，并且你会收到缩进错误。现在我的所有缩进都正确，它应该按预期运行。那么你会使用哪个呢？好吧。

这取决于情况。所以，例如，在这个场景中，我们有所谓的“落空”，意味着x是82。所以它会判断为真，跳到下一个，真，再跳到下一个，真。然后再跳到下一个，真。接着突然故障。所以它在这里停止执行，尽管还有更多语句。而且你得面对这些可爱的缩进，爱它们或恨它们。

记住，缩进告诉Python你在编程逻辑中的位置。😊 所以有些人喜欢Liv，有些人喜欢落空，期待在其他人的源代码中看到这两者，选择适合你的解决方案。我的个人偏好是LF。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P12：12）Python流控制：While 循环 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好，我是Bryant，让我们继续我们的Python 3之旅。我们要讨论while循环。这是基本的流控制。它将证明一点：你的计算机非常愚蠢。没错，我说的就是这样。你的计算机真的很笨，我们将证明这一点。

所以循环就是简单地重复执行代码，直到你告诉它停止，因为计算机并没有足够聪明去知道何时退出。

让我们来看看。

好的，在继续之前我们先来一点理论，我们有程序的入口，我们将进入某种循环。我们就称之为这个循环。它会评估这个条件并运行某种类型的代码。现在不管它运行什么类型的代码都没关系。让我们把那个小家伙去掉。通常你所做的是某种递增的功能。例如，计数某些东西。

增加数字，查找套接字上的数据或类似的东西。所以它会说，好的，开始循环。所以我想在这里连接，来了。然后执行某些操作。如果你不退出这个循环，它就会真的回到这个循环里，你的程序最终看起来会像这样。我们称之为无限循环，你将进入程序，进入一个循环。

然后你就反复循环这个代码，直到你告诉它停止并执行其他操作。你可能在问自己，为什么你甚至需要一个循环。好吧，想一想。你进入你的程序。你进入你的循环。假设你想做某件事100次。你现在需要增加某种计数器。

一旦你达到了那个计数器，你就跳出这个循环并停止你的代码。有一些循环是故意设计为无限的。我的意思是它们看起来是这样的。程序开始，你进入你的循环。然后它就会永远循环。例如，当你进行图形用户界面编程时。

你有一个叫做用户界面循环或事件循环的东西。基本上程序将永远运行，等待用户点击鼠标或移动某些东西。这个循环就会永远发生，直到程序关闭。

好的，现在我们理解了循环是什么，让我们看看实际操作。所以我要说x等于0。我们将创建我们的while循环。这将看起来非常类似于if语句，因为它会像if语句一样评估。意味着这个循环将执行，只要我们即将给出的条件为真。

有人说教训的行为少于10。那么就做点什么。这将是一个关于计算机愚蠢的很好的例子。它们会按你告诉它们的方式去做。正如你所要求的那样。有一点额外的。你看到这个陈述有问题吗？但我们所说的是x是0，而x小于10。打印这个，但我们从不增加X。它始终是0。因此，这将始终为真。

它将永远运行。这就是我告诉你无限循环的地方。你看它总是说0。它将永远运行，控制台也疯狂了。有人来终止它。它将永远继续，直到我关闭程序或关闭计算机。因此，我们实际上需要增加X。一旦我们这样做，我们就增加了计数器。

最终x会变成10或更大，这样就会退出。1到10的循环现在按预期工作。因此，循环可以非常强大且易于使用，但你可以通过意外创建无限循环来搞砸你的应用程序。现在，如果你想知道，可以继续打印这个。我们要说的是，下一个完成了。

我们想知道这个循环何时完成执行，我们使用。你猜对了，缩进，这决定了我们的范围或代码块。因此，当这个条件为真时，执行这个范围或这个代码块。然后，当我们完成循环时，我们将跳回这里。

让我们看看实际效果，我要清除这个。果然，1到10，然后测试完成，因此它的工作方式正如你所想的那样。

让我们稍微绕一下，谈谈pass。你在Python中会看到这个，很多人并没有真正解释它。所以我们假设while。我们就用这个小模板。它将说。while表达式pass。但这是一个有效的Python表达式。比如说0，并且给它同样的逻辑。

注意这将如何运行。现在引擎盖下发生了什么，这仍然在运行。或者说它在运行吗？让我们来看看。我将关闭这个终端，以防万一。那么我们说测试2完成。因此x是0。当x小于时，注意我们从未像在这个例子中那样增加它，我们将通过。然后最终打印出测试2完成。注意它从这里说测试1完成。

但它永远不会达到测试2。那么在引擎盖下发生了什么，这个脚本仍在运行。它只是在这里做一个无限循环。因此，每当你在循环中看到pass时，要非常小心，因为你正在创建某种无限循环。Pass是Python中的一个特殊关键字，告诉Python。

不采取任何行动，继续正常做你该做的事。

因此，对于pass要非常小心。

我们刚刚讨论过pass，这在循环中非常危险。仅仅因为你可能会意外地无限循环。嗯，底层的情况并不简单，但我们会尽量简化。我们将讨论continue和break。因此，我们将说x等于0。让我们做一些非常糟糕的事情。

我们要说的是，当条件为真时，执行某些操作。如果你在关注这个，你就会知道“while”会以“if”语句的方式来评估这一点，并且它会判断这个条件是否为真。执行循环，并一直重复，直到这个条件不再为真。然而，我们使用了Python的true关键字，所以这将无限循环。

你会在代码中看到这一点，因为有时人们只是想循环，直到满足某个任意条件。这个条件可以是键盘输入，也可以是某个网络连接，或者其他任何东西。你会经常看到这个。因此，你需要知道何时跳出循环或如何处理特定条件。首先，我们来谈谈continue。我们将说x加上goess1。如果x小于5。

我们想要的就是跳过这一部分。我们其实不想做任何事情。因此我只是说x小于5，无论数字是多少。然后我们将继续。而continue所做的是返回到开头，继续你原本要做的事情。

然后我们将添加一些逻辑。如果x大于10，我们就会执行某个操作，打印出X。并且我们会在最后一行放一个打印语句。请注意，这与while在同一行。因此，直到循环完成之前，这个打印语句不会执行。我喜欢VS Code和大多数编辑器的一点是，你实际上可以折叠。

实际上看起来是这样的。一旦这个循环完成，它将打印“完成”。让我们清理一下，在这里看看实际效果。哦，你注意到吗？它工作得正如我们所预期的那样，因为计算机虽然很快，但非常愚蠢。那么这里发生了什么？它会说如果x小于5。

打印出来，然后返回到开头，因此我们仍然在一个连续的循环中。我们需要修复这个。

所以我们的编程逻辑基本上是，如果小于5，就返回到循环的开头，并继续增加计数器。如果大于5，就执行某个操作，但我们也希望在达到10时停止，所以我将说如果x等于10。打印。然后x等于。这样我们可以看到x实际上达到了那个值。

现在我们要使用 break。说点关于它的事。别担心，我们不会破坏任何东西。Break 就像想象中的野外循环，这个家伙。就像一个小监狱，我们要从监狱里逃出来，直接跳到下一行。所以它将在这里继续执行代码，然后运行这个语句。

继续看看这个实际效果。好的，确实，我们有。X 小于 5。我们有 1，2，3，4。然后做点什么，6，7，8，9，10。当我们达到 10 时，我们将退出，完成。这就是循环的简要说明。这段视频的主要要点是，循环非常，非常强大，但你需要有某种条件来进行评估。

否则你会创建一个无限循环。创建无限循环的简单方法就是简单地使用 pass，这样它会永远循环。你也可以说 while true，这也会创建一个无限循环。但你可以使用 continue 来继续在循环内的流程，或者使用 break 来打断这个流程，应用编程逻辑。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P13：13）Python流控制：For 循环 - ShowMeAI - BV1yg411c7Nw

欢迎大家回来，我是布莱恩。这段视频我们将讨论for循环和range函数。与之前视频中讨论的while循环相比，for循环有一个开始和一个结束，而range函数帮助我们创建这个开始和结束。

真的帮助我们避免了无限循环的麻烦。让我们深入研究，看看。

好的，第一件事，Spts，让我们先看看列表、元组和集合上的for循环。这是非常简单的。我将创建一个简单的列表。我们将说4 I in。注意我们在这里做的是什么。我们说4，然后创建一个变量。这个变量叫I。你可以把它命名为X、Z、zebra。

随便你想命名它。我将说4 I in。现在我们必须给它某种容器。我们说x。然后是冒号。这个读取起来就像while循环，但我们现在是在语句本身中创建变量。现在我们可以简单地说print。我们假设，ae。

我们将打印出I的值。继续，运行这个。你会看到1，2，3，4，然后它停止。我们不需要告诉它要中断、返回或执行其他任何操作。我们也不需要增加某种计数器。它是在底层根据你猜测的这个列表的长度自动完成的。所以它在处理这个可迭代的容器。

每一个现在都是一个独立的变量。我们将独立处理它。你可以非常快速地做到这一点，并且可以在不同类型的对象之间进行操作。例如，想想我可能多做了一个。我们将说列表、元组和集合。我们将说这是L。这是T。

这是X，所以我们有各种不同的东西。让我们实际来看。这其中有个小细节，你必须把它放在正确的风格括号里，这里是圆括号。而集合有点奇怪，像个波浪形。这样就好了。我们可以直接切换。我要用列表。效果如预期。让我们把这个切换到元组。

效果如预期。我知道你可能已经在翻白眼了。我们知道集合会正常工作，而它确实如此。一切都如宣传的那样工作。这使得遍历一个容器变得极其简单。

让我们看看关于字典的for循环。我们将以不同的方式对待这个。所以我要创建一个字典。我会说Dickt，让我们开始构建它。Brian。我会说我的年龄是46。说Tamy。别告诉她我把这放进视频里。她会非常生气。

但她48岁。然后Heather，我们就说Heather是28。Chris。我们就说Chris是30，如果我们真的想的话可以添加更多。所以我们有了这个漂亮的字典。赶紧打印出来，以便我们看看它是什么样子。它为我们创建了一个字典。现在，我们将与这个循环进行处理。

当我说循环时，有几种不同的方法可以做到这一点。第一种方法。我们要说4K。在X.dot E。这里要小心一点，如果你忘了。把它当作函数来调用。我们还没有真正覆盖函数。但相信我。如果你只是这样做，你会很痛苦。

而且让我们实际看看它失败，以证明它确实会失败。然后我们会说他。好吧。等于，然后我们稍后再填写这个。但让我们先看看这个东西失败。看，内置函数或方法对象是不可迭代的。这里发生了什么？这在简单英语中是什么意思，内置函数或方法。好吧。

我们还没有真正覆盖这些，但基本上这是我们可以调用的一段代码，要做到这一点。你需要这些括号。所以如果你忘记了这些，你会很痛苦。而且它说对象是不可迭代的。这是什么意思呢，嗯。它需要某种类型的容器，例如，列表、元组、集合或字典。

所以仅仅通过说，嘿，使用那些参数，它现在会返回某种可迭代的数据，我们可以遍历并使用。好的。让我们继续。我们要说x。我们想要获取那个特定的键。我假设你看过之前的视频，但以防你跳过了它们。

让我们稍微慢下来。首先，我们需要修复我们的小错误。所以这里发生了什么是我们在创建我们的字典，字典只是一个键值对。键值，键值，键值，你可以在这里看到字典创建的那些键值对。现在，我们要说对于我们字典的每个键。

它会返回某种列表，我们要说对于其中的每一个。获取这些值。我们说x。所以实际上我们在这里说的是，X是一个字典。K是键。所以我们说对于任何键，例如，如果是Tammy。它会说打印出Tammy，因为那是键，然后打印出。这里的实际值。

就是那样。所以每个键将与一个值相关联。我想强调的就是这个。也许我解释得不太好。所以键。然后你有你的键值，键值，键值。还有另一种方法。我想提到这个，简单是因为你会看到人们以两种方式做。

所以我们将说对于Kma B。这会让你大吃一惊。如果你来自另一种语言。我们将这里有两个不同的变量。键和值。我们想把它换成项，再次。我们在调用一个函数，所以如果忘记括号，就会出问题。

我们会有一个糟糕的时光。因为我们现在正在提取或解包这些。我们不需要再做这小部分。我们可以简单地用我们的变量替换掉它。那么项的作用是，它实际上提取每个键值对并返回它。所以现在它可以解包键和值。你有两个不同的变量。

在这里看到实际效果。让我们保存并运行。实际上，让我们。所有这些项。以免与键混淆。果然，项。并且它正确地解包了。布莱恩46，塔米48，希瑟28，克里斯30。那么哪种方式更好？这取决于你想做什么。就我个人而言，我倾向于这样做，这样我就不需要乱搞。

在这些小括号中记住每个作用。每种方式都完全可以。让我们谈谈范围，我们已经简单提到过，但现在真正看看范围。我们来快速回顾一下。我们说x等于，并且我们想要一个范围。5。如果我们打印出来，这里你会很快感到困惑。

所以让我们运行这个。我们的x就在这里，范围0到5。等，什么？

你觉得这会返回一个列表或类似的东西。实际上它会返回一个函数调用，所以范围是0到5。这0到5是什么？它从哪里来，我们说了5。好吧，我们将在下一个小节中看看。但只需理解我们真正的做法是说X实际上等于对那个函数的调用。

我们将在其他视频中深入讨论函数。这实际上是一个大主题。所以我们会将其拆分为多个视频，但只需理解这里发生了什么。你实际上并没有得到某种可迭代的容器可以遍历。但是我们现在可以这样做。或者我和X。

注意我没有这些括号。因为我们不是直接调用一个函数，而是调用一个变量。你试着这样做，会遇到非常糟糕的情况。只需理解这两者之间的区别。然后从这里开始，它变得非常简单。这就是我喜欢Python的原因。

一切都变得非常简单明了。我几乎都不好意思谈论它。因为对我来说，作为一个老程序员，这似乎只是常识。好了，range 从0到4。那么这里发生的事情是，它在说对于 I。因此我们正在创建一个变量 x，而这个变量实际上指向一个函数。

所以它正在进行这个函数调用并获取那个值，然后它遍历每一个项目。现在，如果最后那一点让你感到困惑，请系好安全带，范围这里可能会变得有点复杂。所以我们有一个开始，一个停止和一个步长。这实际上意味着什么，让我们来做这个。假设 x 等于 range。我暂时就先停在这里，以便我们可以阅读并了解发生了什么。

我们有一个停止点。所以这是默认设置。但调用这个的方式有很多种。你可以设置一个开始点，这意味着你将要开始的数字，还有一个停止点，意味着你将要停止的数字。还有一个步长，意味着在这两个数字之间你想跳过多少个数字。

让我们看看这个，看看它在内部到底是什么样的。所以假设我们想从5开始。当我们到达20时停止，并且我们想每次跳过三个数字。好吧，pop quiz。这个看起来会是什么样子？让我们打印出来。如果你认为它会显示 range 5，23。

你绝对是对的，因为现在开始理解这里的内容是，它指向的是一个函数，而不是某种值。但我们现在可以使用它，因为我们已经将其分配给一个名为 X 的变量。继续说4 I 在 X 中。记住，我们是在调用一个变量，而不是一个函数。继续打印。好吧，额外一轮。谁知道这会打印出什么，让我们看看。从5开始。

然后它会跳到8、11、14、17，并且在20处停止。注意它并没有输出20。如果我们设定为21。让我们看看会发生什么。现在，突然间，它包括了这个。所以这里的主要结论是，它不会包括那个停止点。它会在到达那里时停止。记住，在内部，这使用的是某种循环。它可能说的是我们之前见过的，比如这样一个 while。

然后在小于20的情况下。因此，当它达到20时，它将跳出那个循环并停止。一旦你理解了这个工作原理，生活就变得异常简单。像这样的事情在其他语言中可能需要一点数学。但是，Iython 和往常一样，让它变得简单易懂。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P14：14）构建简单的应用程序：油漆计算器 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好。我是布莱恩。我们将使用到目前为止学到的一切来创建一个简单的应用程序。如果你刚刚调入，有13个其他视频在这个播放列表中，你需要回去看看，如果你不懂Python。

但我们将制作一个油漆计算器。因此，我们将确定实际需要多少油漆来粉刷一个房间。当我们运行这个时，用户将看到类似这样的内容。油漆计算器：输入墙的尺寸，格式为宽度，逗号，高度（以英尺为单位），或按回车停止，例如12a 8。没有空格之类的。他们可以输入任意数量的墙，最后。

这将神奇地告诉他们需要多少罐或多少加仑的油漆。我们来看看。😊。

我们需要做的第一件事是设置一些变量。因此我们将创建一个名为“walls”的列表。这个列表将仅用于保存测量数据。我们要添加的第二件事是加仑。这将是每平方英尺所需的油漆加仑数。我不是专家。

但我确实出去查了一下谷歌。根据谷歌，1加仑油漆覆盖350平方英尺。我对此表示怀疑，因为每次我买油漆时，我从来没有买够，必须回到商店再买。也许这个应用程序会有所帮助。而且总数将是我们需要购买的油漆总加仑数。

我们稍后会用到这个。购买的小加仑。到目前为止，我们的应用程序完全没有功能。但这即将改变。我们将获取用户的输入，而我们还没有谈论过这一点。我们将创建一个无限循环。我们将说“while true”。你可能会想，哦，哇，哇，哇。

你正在制造一个无限循环。没错。我们将跳出这个。我将向你展示如何。所以我们将获取一个变量。我们将使用内置的输入函数。有不同的方法来做到这一点，但我们将使用输入。我将说“输入”。墙的尺寸。

然后我们要跳出这个，如果他们没有真正进入。任何数据，所以我必须说“Ly”。的“S”。零。那么如果你有点怀疑这一切是什么，我们想要的就是调用“break”。请回去看看我之前做的13个视频。所以让我们测试一下。我们要运行这个，结果显示“内墙尺寸”。

她知道我们的程序停止了并在等待我们。好吧，我就输入一些无效的数据。我必须说猫。然后它想要另一个。吃。还有另一个鱼。然后我就按回车。果然，它退出了。所以这是使用无限循环来收集用户输入并测试何时需要退出这个循环的正确方式。

现在我们可以获取用户输入，我们需要对其进行实际处理。在尝试处理之前，我们首先应该验证用户给我们的内容确实是我们所期望的。我们可能会遇到麻烦。记住，这一切都是从12a 8的例子开始的。好吧，我输入了catstocks鱼。

我不确定你怎么计算猫的平方英尺，但我相信这会很有趣，可能还需要去兽医那里。不过，无论如何。我们要说SQFT等于，我们要说S分割。因为S是我们从输入函数得到的变量。在这里，它将是一个字符串。

所以我们可以把它当作字符串来处理并说，a分割。我们想要再次以逗号进行分割。如果你对我在做什么一无所知，请观看之前的13个视频，不过。字符串有一个内置函数叫做split，它可以基于一个字符或字符序列返回多个值。所以我们的平方英尺将是从那个split函数返回的值。

所以我们要做的第一件事是确保里面确实有两个值。如果少于两个。好吧，我们要告诉用户发生了错误。Brench。我们继续说，格式无效。然后我们将退出这里。现在记住，break不在乎它在哪里，它将跳出这个循环。

让我们在这里测试一下。所以我们要运行这个，它会显示内壁尺寸。我会说，好的，2，ma 6，运行得很好。5 逗号 7。让我们输入一些无效的数据。哦，格式无效，它停止循环并退出程序。所以它实际上是在测试确保有两个项目是以逗号分隔的。

好吧，我们还没完成。现在我们获得了用户输入。需要转换它，因为记住我们在处理字符串，而我们想要处理数字。具体来说，我们想要将字符串转换为整数。这可能会导致麻烦。我们将演示这一点。所以我要说W等于。我们将调用n。

我们将做一些叫做类型转换的事情。我稍后会做一个完整的视频来讲这个。但是当我说类型转换时，想象一个拿着魔法棒的巫师，他将施展一个法术，把某物变成其他东西。所以我们在说我们想要施展一个整型的法术，将我们给的任何东西转换为整数。在这种情况下。

我们将获取平方英尺的第一个值。去抓这个。给它复制粘贴。嗯，复制粘贴有点多。然后。让我们获取另一个维度。现在我们有了平方英尺0和平方英尺1的宽度和高度。有趣的是，如果我们尝试这样做而它实际上不是一个数字，我们将会遇到麻烦。

它实际上会出错，我们的程序会停止并遭受可怕的失败。我会在另一个视频中讲解如何处理这些情况。这个程序的整个要点是用我们在13个视频中学到的知识来做一个程序。现在，我要说项目，我想要制作一个包含宽度和高度的列表。

我们将把它添加到我们的墙上。如果你在想我从哪里得到墙的，记住，它在我们变量的最上方，只是一个空列表。所以我们要说墙。让我们把这个项目添加进来。现在我们有一个列表，保存他们添加的每一面墙的尺寸。

让我们先打印出来验证一下，嘿，我们做了些什么。所以，添加。哦。😮。继续，保存并运行，来测试一下内墙的尺寸。好的，3乘6。这是一面很小的墙，它显示添加墙。好的，太好了。那么8乘8。我们继续说9乘12。现在，让我们测试一下这个转换，看看它是如何惨败的。

所以我要说两个猫。哦，还有有效的整数字面量，基数为10的猫。这看起来很丑，而且确实如此。这是一个值错误。我们将在未来的视频中讨论错误。我只是想让你明白，如果你遇到值错误，发生的事情是我们基本上在说我们无法将其转换为数字，或具体来说，转换为整型。记住，想象一个拿着魔法棒的巫师，我们施展的法术叫做整型，这将把我们施展的任何东西转换为整型。一旦我们到了这一步，剩下的就是计算数字并告诉他们需要多少油漆。

我喜欢告诉他们他们输入了什么。所以我们会说F。你输入了。这样，如果有任何差异，我可以说给我发个应用的截图，我可以说，哦，不。你搞错了，你在这里输入了错误的值。然后我们要说4 M。M将用于墙的测量。我们会说宽度将是M 0。记住。

它是一个基于0的索引。在我们的墙内，我们创建了另一个列表。所以我们获取这个宽度。我们可以说H。1。记住零基索引总是让新手困惑。现在我们要计算平方英尺。因此我要再创建一个变量叫S。我会说这就是宽度乘以高度。

现在我想得到某种值。所以我会说这是S或平方英尺。乘以。加仑。你可能在想加仑从哪里来的。记住，它就在我们创建的全局变量的最上面。我查过了。一加仑的油漆应该覆盖350平方英尺，所以。😊，这个值就是1除以350。

不知道这是否准确，我高度怀疑，尽管我确实信任谷歌。然后我们将抓取我们的其他全局变量总数。我想说加上B。因此我们只是增加它。你可能在想加上等于。我们在之前的视频中讲过。这基本上意味着我们说总数等于总数加上。

值，但是我们只是简化它。现在我们要向下移动并深入。我们要进行一些调整。所以我们在这个代码块中退出。然后我们回到主程序。我们要说王子。我们只是告诉他们你需要去买一些油漆。

这是你需要购买的油漆数量。你需要购买。让我们继续。如果我们只说总数。它会给我们一个疯狂的数字。所以我喜欢让它更美观。我会说四舍五入。我们将总数四舍五入到两位小数。冇嘅。

告诉他们你需要去买多少加仑的油漆，四舍五入到两位小数。让我们测试一下这个东西，看看它是否有效。所以我会说。12乘8。再做一个，15乘9。其实，让我们用8来做。如果天花板的高度不同，那就奇怪了。让我们继续说我们有一个8乘8的。

一个4乘8的房间，形状有点奇怪。然后我不想再输入了。所以我就直接按回车，你需要买。一加仑的油漆。基本上它会使用不到一加仑，我应该会有一些剩余。我不知道这有多准确。老实说，我有点在看我的小办公室。

我觉得做这个需要超过一加仑。因此，遇到疑问就怪谷歌。但是，这个视频的主要要点是。尽管我们才刚刚做了13个视频，我们实际上只是触及了Python所能做的表面。你可以编写一些相当有趣的编程逻辑。我们刚做了一个简单的应用程序。那就是油漆计算器，告诉我们需要购买多少油漆。

我们允许用户输入他们想要的任何数量的墙。我们正在验证用户输入。然后我们将该输入转换为正确的数据类型。接着我们计算他们需要多少，并将其返回给最终用户。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P15：15）Python函数介绍 - ShowMeAI - BV1yg411c7Nw

欢迎回来，大家好，我是布莱恩，我们将继续深入Python 3，介绍函数。那么，函数是什么呢？它是一个代码块，仅在被调用时运行，而我们之前写的所有代码都是在Python读取时立即运行的。

它会运行。这将改变这一点。我们将编写一些代码，并决定它何时运行。这是编程的另一个基本构建块，涉及许多理论和术语，因此我们会将其分成多个视频。不过，这个视频的一些关键要点是。

你可以将称为参数或实参的数据传入函数，你会听到这两个词是可互换使用的。这真的很困惑。因此，在下面，我写了一些注释，说明参数和实参之间的区别。函数参数是在函数定义中列出的名称，而实参是真实的值。这真的令人困惑。

为什么他们不直接称其为名称或值，而要称其为参数和实参呢？而且每个人，包括我自己，都会混淆这些。你会在一些视频中听到我称其为参数，而在其他视频中称其为实参。我也听过一些编程经验远超我的人也会把这两者混淆。

这确实有点令人困惑。另一个主要要点是，函数可以作为结果返回数据。返回实际上是一个关键字，我们将对此进行讲解。

暂时深入这一领域，到目前为止，我们处理过语句。我所说的语句是什么意思呢？到目前为止，我们做了类似这样的事情。有一个语句，一个语句，一个语句。Python从上到下读取。例如，我们想打印一些内容，也许在那个循环内做一个while循环。

我们可以像有一个if语句一样。它就像一本书一样从上到下阅读。但现在我们要做的是引入一个函数。这是一个独立的代码块，除非我们明确告诉Python去运行这段代码，否则它不会运行。在一个函数中，可以调用其他函数，依此类推。现在的最终结果是，我们可以从根本上。

决定我们的程序如何运行以及它的行为。我们可以使用这个进行一些相当复杂的编程逻辑。另一个关键要点是，我们正在引入范围的概念。到目前为止，我们所做的一切都在每个函数中的所谓全局范围内。每个代码块都有自己的范围，这是我们将在未来的视频中深入探讨的内容。

但请理解我们正在微妙地引入这一概念。

所以让我们测试一下，继续定义一个函数。我们将说 D EF，这是定义或定义的缩写。然后我们给它一个名称，接着就是那些小括号。如果我们忘记了它们，我们将会很糟糕。我们需要括号。在那里，我们可以定义任何参数。

我们将这个第一部分保持非常基础，并且不需要参数。但我们仍然需要在其中加上括号，然后是冒号。按下回车，注意大多数 IDE 会自动为你换行并自动缩进。然后我们可以填入我们的代码，这里几乎可以放入任何内容。

我只是放一个打印语句以便测试。我们只是说这是一个函数。现在我们可以根据需要使用这个东西。

好吧，这最后一个有点简单，让我们提高一下难度。因此我们将定义一个带参数的函数并返回一个值。在最后一个视频中，我们制作了一个油漆计算器，它根据平方英尺计算所需的油漆量。我们本可以很轻松地在其中使用函数，而大多数程序也会这样做。

所以我们将创建一个名为 S QFT 的函数，它是平方英尺的简写。括号，让我们定义一些参数，我要说的是，W 代表宽度，H 代表高度。现在我们可以在这里添加我们的编程逻辑，所以我们要返回的值将简单地是宽度乘以高度。

现在我们将使用 return 关键字来返回那个值。注意这两个都非常简单，但它们在根本上是非常不同的。第一个基本上没有参数并运行一些代码，一旦完成，它就直接跳回这里。而这个，我们必须给它两个参数，并且会有一些逻辑。

它将返回一个值。我们决定是否要实际使用返回的值，这并不是强制性的。如果我们想，可以忽略它。但这就是我所说的函数可以变得非常复杂，非常迅速。我们有两个非常小的函数，它们的作用截然不同。

让我们看看这实际上是如何工作的，我们将如何调用一个函数。我们所说的调用一个函数是什么意思，记住，这段代码不会执行，直到我们明确告诉 Python 运行它。让我们按原样运行我们的程序，看看会发生什么，绝对什么都不会发生。所以它所做的是从上到下读取。它在说定义 test，定义 S QFT。

它已经在内存中排队准备好了，但在我们告诉它之前，它不会实际使用它。所以让我们告诉它运行它。大多数编辑器足够聪明，会告诉你，嘿。这是一个实际的函数。在VS代码中，这个小块意味着它是一个函数。注意是一个块，因为它是一段代码。如果我只是点击确认或按回车或点击它。

它什么也不做。实际上它不会运行。我们必须添加这些括号。现在，突然间你会看到它显示“de test”，并且知道我们试图调用那个函数。我们继续运行，看看，这就是一个函数。所以Python是从上到下读取这个的。定义测试，定义SQFT，来到这里并说，哦，它想实际调用这个。

没有参数，所以我们不需要提供任何参数。你可能会想，这有什么大不了的，为什么我们还要玩函数，我是说。我们可以直接打印出来。好吧，让我们看看一个具体的情况。假设我们想多次调用那个函数，或者说4次在范围内。

我们将说范围为四，因此我们想多次调用它。现在我们可以这样写。但有时，我们可以这样做。你会看到有人这样做。然而，这不是最佳方式。如果你的老板过来，告诉你，我希望你这样做20000次。哦，你会有一个非常大的文件来调用它。

这是一种更简单的方法。你会说4次在范围内，然后你会调用它。所以我们现在所做的是创建一个循环，并有一个下限和一个上限。它将调用它。所以我们没有创建一个无限循环，它会调用我们的函数。让我们看看这个在实践中是如何运作的。它就在那里。所以这就是函数的力量。

你可以定义一段代码，然后决定何时以及如何运行。现在，按照这些视频的典型方式，我确实喜欢提高难度。所以我们将调用一个带参数的函数。这就是我说的，它会迅速变得复杂。记住我们的小伙伴。

SQFT函数，我们定义的，实际上我们还没有真正使用过。现在我们说x等于SQFT。现在我们有了一些参数，它足够聪明，知道这是一个p。所以我们现在必须给它一些信息，假设12乘以8。这里的额外问题。这些数字是参数还是参数。好吧，它们是参数。

所以上面的这些是参数，它们在函数定义中。我们输入的值是参数。你会遇到人们会争论这个，因为大家容易搞混。好的，让我们继续打印出平方英尺。所以平方英尺是96。现在你看到它有多强大。

你可以定义某种逻辑，然后在需要时按需调用它，并从中获取值并相应地使用它。快速回顾一下我们在这个视频中讨论的内容，函数是很神奇的。它们也非常复杂。代码是从上到下读取的，你必须使用DEF或def关键字来定义一个函数。函数可以有零个或多个参数，这些参数必须被传入参数值。

Python 3全系列基础教程，全程代码演示&讲解！10小时视频42节，保证你能掌握Python！快来一起跟着视频敲代码~＜快速入门系列＞ - P16：16）函数与作用域 - ShowMeAI - BV1yg411c7Nw

大家好，我是布莱恩，让我们继续探索 Python 3 的函数与作用域。这是一段理论密集的视频，但我们会尽量简单明了。我们正在讨论词法作用域，有时也称为静态作用域，这是一种许多编程语言使用的约定。

这设定了变量的作用域或功能范围，使其仅在定义它的代码块内部调用。然而，作用域可以嵌套在彼此内部。因此，你可能会有一个盒子再加一个盒子再加一个盒子，这就是我们在讨论的内容，这也是为什么如果你不专心，这真的会让你感到困惑。

所以让我们深入探讨一下。

现在我们来看看词法作用域，我将这里放一个正方形。我要把它做得大一些，并且给它上个颜色。假设这个颜色是某种绿色，实际上颜色并不重要。这就是一段代码块。实际上，你一直在使用这个。

这被称为全局作用域。到目前为止，我们做的所有事情都在一个叫做全局作用域的巨大范围内。它还有其他名称，但这基本上就是我们在讨论的内容。现在，我们实际上可以再做一个。😊，让我们把这个移到最前面，并将其设为不同的颜色，比如蓝色。这是一个不同的作用域，可以把它想象成一个函数。

它不一定是一个函数。它也可以是一个任意语句或条件语句之类的东西。那么我们要表达的是，你有这个大范围的全局作用域，但随后你有这些子作用域。为了让事情稍微复杂一点，假设我们在全局作用域内有这个作用域，我们称之为一个函数。

例如，我们将继续创建另一个。这次我们给它一个不同的颜色。这就是我们要讨论的内容。所以你可以在一个作用域内再嵌套一个作用域。

就像一个盒子、一个盒子再加一个盒子，这样就变得非常非常混乱。现在，这里有一个框。让我们把所有的东西都移到这里，让它更容易理解。你有全局作用域，有函数作用域，还有另外一个像语句的东西在这里。

你可以在全局范围内定义一些东西，并在这里一直使用它，甚至在这个语句中使用。然而，你不能反过来，你不能在语句中定义某个东西，然后在全局范围内向上使用它。这就是为什么它会变得非常非常混乱，我认为图形化地表示这可能是定义它的更好方法之一。

只需理解，你可以有一个作用域，其中包含另一个作用域，还有另一个作用域。你可以定义某个东西，并随着细化，可以使用你定义的东西。然而，你不能在非常细化的级别定义某个东西并在更高的层次使用它。所有关于作用域的讨论确实令人困惑，所以让我们深入了解，首先讨论全局作用域。

这可能是最简单理解的概念，因为我们整个时间都在使用它。没错。如果我说名字，然后填上你的名字。我们现在在全局作用域中创建了一个变量，这意味着这个应用中的任何东西现在都可以使用它。

这非常酷，也非常简单。

让我们演示这个全局作用域。函数可以访问全局作用域。所以让我们定义一个函数。我们把它叫做 test1，名字很描述性，我知道。我们将使用这个在全局作用域中创建的变量，并在这个函数中使用。记住这个函数有自己的作用域，我们现在正在定义它。说 print。为了测试这一点。

让我们调用这个函数。我的名字是，然后用全局作用域中的名字。这样非常方便。然而，我们在这个视频中要展示的是，这种便利带来了复杂性，肯定会遇到一些问题。

让我们反向思考一下，展示一些可能遇到的问题。例如，全局作用域无法访问函数作用域，这看起来很荒谬。我们在全局作用域中定义了函数，应该能够访问它，但并不是这样的。我们说 x 等于 10。接下来，我们定义一个函数。

我们把这个叫做 test2，名字非常具有描述性。我们将说 x 等于 50。现在，你可能会想，等等，这有两个 x。它们是同一个 x，但实际上并不是。我们来看看这里。我们将说哦，函数。不，不行。现在我们只打印出 x 的值。继续往下看看。

让我们调用这个函数，这样它会打印出来。然后我们将说，全局作用域。好吧，那么，U quiz。x 等于 10，x 等于 50，这将打印什么？它会说函数作用域 x，全局作用域 x。让我们看看。如果你认为这两个都是 50，那你错了，这里发生了什么。

我们在全局作用域中有 x，现在我们在函数作用域中创建一个新变量并将其赋值为 50。这是两个不同的变量，所以它们会被不同对待，即使它们的名字相同。这很令人困惑，但这是有原因的。这被称为名字冲突。如果你有一个同名变量，你不想覆盖它。

假设这是某个神奇的数字，比如密码之类的。然后我们在某个函数里搞砸了它。我们不想破坏应用程序的功能。😊。所以这实际上是为了保护我们自己。

好的，让我们更深入地探讨，所以我们将讨论全局作用域、函数作用域和语句作用域，所有这些都会真正考验你的大脑。所以我们要创建一个全局变量。我们说x等于15。现在我们就来添加一个打印语句，打印全局的X。

为了让我们看看这里发生了什么。是的，15。现在我们要定义一个函数。我们说de。名称非常描述性，我知道。我要让x等于0。我们在这里做了什么？我们创建了两个不同的变量。我们在这里讨论过这一点，我们说这个变量是15，而这个变量是0。

所以我通过神奇的复制粘贴，我有一些笔记在屏幕外，以节省一点时间。我们要打印这些出来。让我们先这样做。这样我们就能看到发生了什么。果然，Globals 15，函数为0，一切正常，即使这有点令人困惑。这是为了防止我们自己出错，因为你有一个叫做名称冲突的概念。

这就是一个密码或类似的疯狂东西。我们不想覆盖它，然后在代码的其他地方搞砸。好的。现在让我们进一步，我们要说的是对于I in range。我们要让一些人非常生气，因为我们要做一些我们真的不该做的事情。

我们要说x加1。现在我们要说y等于x。到目前为止，一切都很好。但是现在这个x，你注意到它有三层深，这个x究竟是哪个？好吧，这是令人困惑的部分。所以这个x实际上是借用我们定义的内容，它向上延伸了一些。因此，当你看到def关键字时，请想象一下。

我们实际上是在这里放置某种墙或保护罩。让我们画一条线。就像是在设置一个边界，表示如果我已经命名过，你将无法通过。现在，让我们去做一些我们可能不该做的事情。我们有语句X，语句Y。这完全没问题。让我们运行这个，看看效果如何。

果然，它按预期工作。我们可以看到语句Y实际上是在乘法。一切都很好。现在，让我们做一些非常、非常可怕的事情。我们将抓取这些。然后我们将通过作用域向后走。VS代码添加了这些漂亮的小线条，告诉我们我们在什么作用域中。你可以看到，就像一个气泡一样。我们在全局，我们在函数内。

我们现在在语句中，正在回到函数作用域。让我们运行这个，看看会发生什么，你会注意到它确实有效，因为我们在这个小边界内，系统认为这是一个安全的小游乐场。然而，你绝对可以破坏一些东西，造成一些问题，我强烈。强烈建议避免这样做。未来的 Python 版本甚至当前的 Python 版本。

你可能会遇到一些问题，一些名称冲突，可能会破坏你的代码。现在，让我们继续使用这个概念。并尝试仍然向后追溯。让我们回到全局作用域。所以我们想查看 x 和 y。我们在这里定义了 y，并且能够回到函数作用域。

让我们看看是否可以回到全局作用域。果然，我们无法命名错误 Y 未定义，为什么会出现这个，发生了什么？

这个定义是一段代码，它是其自己的独立小作用域。这里有这些箭头，全球指向函数，函数指向语句。你不应该向后追溯。然而，我们看到你可以违反这个原则并向后追溯。尽管我们实际上不应该这样做。或者我应该说你不想这样做，因为你可能会引发问题。

因为如果你采用那个逻辑并试图向后追溯到全局，你将会得到一个名称错误，为什么在全局命名空间中根本不存在。你在处理作用域时需要稍微小心，并真正理解这一点。这将一次又一次地导致问题。我看到人们不断这样做。

我定义了 y，为什么我不能使用它，然后你必须向他们解释作用域。再次运行一遍，一切运作得很好，因为我们注释掉了这段代码。

现在，关于作用域和函数的这些讨论可能有点混淆。所以你需要真正理解的一件事是，函数之间不共享作用域。让我们测试一下这个。我要说的是怀疑猫。更好的名称。我喜欢猫。所以我要创建一个变量 Z。现在。

你需要理解的，是这仅在这个函数中存在。让我们实际提取这个函数，创建另一个，称之为狗。现在， Z 是 3。我们在这里做了什么，你看到两个不同的函数和两个不同的 Z。这些是独立的。它们不是同一个变量，不能互相通信。所以例如。

如果我这样做，会发生什么？嗯，我们将会调用猫。我们会调用狗，然后我们将会得到某种未定义错误，而 Vi Studio 代码已经足够智能，知道它未定义，因为这些变量只存在于这里。

现在为了强调这一点。让我们抓住这个。让我们去掉这些。现在我们已经将其注释掉了，让我们保存它。如果我们现在调用狗，会发生什么？让我们继续说。注意，它已经在运行，哦哦。你将遇到一个未定义的变量，让我们测试一下，果然如此。

打印 Z 名称未定义。记住，当你看到未定义时，它意味着它根本不存在。即使我们调用猫。看，하나。不存在。因此它们彼此不共享范围。如果你对此感到困惑，只需折叠代码，如果你的 IDE 允许的话。这就是我们所说的。这些是独立的岛屿，它们根本不交流。

现在为了总结，你可能会问，如果函数不共享范围，如何在函数之间共享信息？好吧，函数可以返回值。我们在这里讨论过这一点。让我们生成一些幸运数字。我将定义一个名为数字的函数。我们实际上想要一个步长参数。

继续，我们将说 L 等于范围。然后我们想从 1 到 20。使用步长。好了。继续打印这些。我们将说对于 I 在 L 中。我们将继续打印 I，这样我们可以在屏幕上看到发生了什么。现在我们将返回，并且我们将说返回。

我们想返回从这个范围中得到的小列表。那么在幕后发生了什么？我们在说定义这个函数，它有一个步长参数。我们将说 L 是从 1 到 20 的范围，使用步长。I 在 L 中。我们只是将其打印出来，然后我们将实际返回我们生成的所有这些信息。

现在，一个真正的程序会有更复杂的逻辑。但现在我们将使用这个函数并获取其中的信息。所以我们将创建乐透函数。每个人都想赢得乐透。我知道我想。我们将说 z 等于，我们将以三为步长调用数字函数。

你可能在想，等一下。数字并不存在，我们无法使用它。如果你感到困惑，而你的 IDE 允许，可以折叠代码。你可以看到数字存在于全局范围内。因此，我们可以调用它，我们是向下走，而不是向上走。好的，既然我们有了这个。我们可以说或 x 在 z 中。

现在让我们继续打印出我们的幸运数字。我们只是要把它打印出来。现在，让我们调用我们的乐透函数。注意，我们并没有直接调用数字，我们是调用乐透，而乐透将调用数字，运行代码并返回值。获取返回值，然后使用它。看，这就是我们的幸运数字。这是一个重要的收获。

我们讨论了作用域，并且深入探讨了它。作用域可能有点 confusing，但请记住，它会从全局到函数再到语句。你不应该逆向操作。如果你这样做，你可能会遇到某种问题，尽管你会看到人们在 Python 中总是这样做，这让我感到困扰。

因为如果他们还没有遇到问题，他们最终会碰到问题。一个函数可以调用另一个函数，你可以从这些函数中获取值并在本地使用它。