ShowMeAI-人工智能工具笔记-十四-

ShowMeAI 人工智能工具笔记（十四）

用 Pandas 进行数据处理与分析！真实数据&实时讲解，学完就能上手做数据分析了！＜实战教程系列＞ - P3：3）索引 - 如何设置、重置和使用索引 - ShowMeAI - BV1M64y187bz

大家好，最近怎么样？在这个视频中，我们将深入学习索引。我们在之前的视频中见过基本的默认索引，但在这个视频中，我们将学习如何设置自定义索引及其好处。现在，我还想提到我们有这个系列视频的赞助商。

而且这是 brilliant.org。因此，我真的想感谢 brilliant 赞助这个系列，如果你们能通过下面描述部分的链接查看他们并支持赞助商，那就太好了。我稍后会更多地谈谈他们的服务。所以话虽如此。

让我们开始吧。好的，我在这里打开了我的代码片段文件，以便我们可以使用一个简单的数据框查看索引，然后我们将看到如何将这些与我们在系列中使用的大型调查数据集结合使用。

在这些代码片段中，我们有在上一个视频中看到的同一个小数据框，我们只有三个人的名字、姓氏和电子邮件地址。这个数据框显示在右下角。😊正如我在之前的视频中所说，我们的数据框左边有一个没有名称的列，这就是索引。所以由于我们到目前为止看到的都是默认索引，这目前只是一个数字范围，基本上是行的整数标识符。

所以这是 a0，a1 和 a2。有时为每一行设置不同的标识符可能更有意义，这将基本上是该行的标签。所以通常是唯一的。现在 pandas 实际上并不强制索引必须是唯一的，有时它们不会，但大多数情况下这些将是唯一值。那么我们这里的示例数据可能更好的索引是什么呢？

嗯，电子邮件地址可能是这个数据的一个好索引，因为这通常是大多数人的唯一值。所以现在，如果我想查看所有的电子邮件地址，我们可以说 Df 并访问电子邮件。我们在上一个视频中见过这一点，但我们可以看到它显示了所有这些电子邮件地址。现在。

如果我们想将这些电子邮件地址设置为这个数据框的索引，那该怎么办呢？要做到这一点，我们可以说 D set underscore index，然后我们只需传入我们想要作为索引的列名。如果我现在运行这个，我们可以看到电子邮件在最左侧，并且它是粗体的，实际上看起来像一个正常的列，因为这个索引有名称，它与我们设置时的列名相同。所以我想在这里展示给你们看，我们可以在这个单元中设置这个索引，但如果我再次查看我的数据框。

所以下面如果我说Df打印出这个数据框，那么我们可以看到我们的数据框实际上没有变化，左边仍然有默认索引，这是因为pandas不会做很多这些更改，除非我们特别告诉它这样做。这实际上很好，因为它允许我们实验而不必担心以意想不到的方式修改我们的数据框。

假设我们实际上想把索引设置为电子邮件列，并让这些更改延续到未来的单元格。为了做到这一点，我们可以在上面提到的set index的地方再加一个参数，说in place等于true。现在如果我运行这个。

然后再次运行数据框，现在我们可以看到，它实际上设置了那个索引并修改了数据框，我们可以通过说Df index来具体查看那个索引，如果我运行它，那么我们可以看到这里有一个索引，它的值是所有索引值的列表，并且它还告诉我们，名称等于email，好的。

这真的有用吗？嗯，正如我之前所说，电子邮件地址作为索引为我们的行提供了一个不错且独特的标识符。并且请记住，在之前的视频中，我们使用了do lo通过标签搜索数据框。好吧，这些索引就是这些行的标签。因此，在之前我们只是使用默认的范围索引。

但现在我们可以通过传入那个标签来找到特定的行。所以如果我说Df do lo，实际上看一个例子会更简单，如果我说Df do lo，之前我们是传入a0作为标签，但现在我可以说，好吧，我想查看Corium Schefffer在Gmail.com的信息，然后它会返回说，好吧，那个人的名字是Cory，姓是Schchaefffer，等等。

所以现在我们得到了那个特定电子邮件索引的行。正如我们在上一个视频中看到的，我们仍然可以传入特定列的值。所以如果我们想要姓，那么我可以把它作为第二个值传入。所以我只需说我想要姓，我们可以看到那里得到了saferffer。

现在，我们实际上不再使用那些默认的整数作为我们的索引，因为现在它使用的是电子邮件。所以如果我尝试使用之前用过的整数，那么如果我说我想要第0行使用Lo，那么我们将会得到一个类型错误。我收到一个错误，因为它不再有那个标签的索引。

如果你想使用整数位置而不是标签，那么你仍然可以使用ilo索引器。我们在上一个视频中也看到了这一点。所以如果我把这个改成i Lo而不是Lo，那么它仍然会给我们第一行。所以这仍然有效。现在，如果你意外地设置了索引并想要重置它。

然后我们可以使用重置索引方法来做到这一点。所以在这里我将说Df do reset underscore index。我会将in place设置为true，以便这些更改能够生效。然后我会打印出该数据框。所以如果我运行这个，我们可以看到现在我们又回到了将电子邮件作为一列和默认范围索引。

现在，如果在创建数据框时你实际上知道索引应该是什么，那么你可以直接在那里设置，而不是稍后使用设置索引方法来设置。我们也可以在从Cv或其他来源加载数据时这样做。那么让我切换到我们在整个系列中使用的堆栈溢出数据的另一个笔记本，我们将看看使用索引的实际案例。

对于那些到目前为止一直在关注系列的人，这应该看起来很熟悉，但如果你还没有关注，这是你观看的第一部视频，下面是一个简要概述我们正在做什么：我们在这里加载pandas，我们也在这里加载一些cv文件，我在下面的描述部分中有一个链接，指向我们用于这些CSv文件的数据，然后我们还在pandas中设置一些选项，以便显示最大列数，使我们能够查看所有列，以及最大行数，以便我们能够查看这些行中的很多，然后这就是我们的数据框的样子。

这些只是来自堆栈溢出的调查结果。因此到目前为止，如果我们查看在系列中的数据框，我们一直在使用这个默认索引，我们可以在这里看到它只是012和3的范围。现在如果我们查看调查响应数据，它看起来实际上有。

数据本身每行的唯一值。所以如果我们看一下这个回应者列，这个回应者列实际上是一个唯一的ID。所以它是respondent1、respondent2、respondent3，依此类推。因此，我们可能应该稍微整理一下，只用这个回应者ID作为我们的数据框索引。现在我们可以像之前看到的那样，通过在这里说Df do set index来做到这一点，或者我们可以在实际读取数据时，通过向read CSv方法传递一个额外的参数来做到这一点。所以在这里加载数据的地方，我们就添加另一个参数。

我们将这个参数称为index underscore call等于我们想要作为索引的列的名称，在这种情况下，我希望它是这个回应者唯一ID。因此，我将说我们的index call等于respondent。我将重新运行该单元格。

现在我将回到这里并重新运行我们的数据框头。现在我们可以看到这稍微清理了一下，因为现在我们将这个回应者作为我们的实际索引。所以现在这些是标签。如果你想要第一个回应者，那么我们可以直接说Df dot Lo，那就是1。所以这是第一个回应者。好的。

让我删除那个单元格。好的，现在让我给你展示一个我会使用这个的真实案例。如果你记得系列早些时候，我们有我们的调查数据，可以在这里看到。但我们还有另一个数据框，告诉我们这些列在调查数据中实际是什么意思。让我快速展示那个数据框。例如。

如果我想知道“爱好者”是什么意思，那么我们可以查看我们的模式数据框，我们可以看到他们在调查中回答的问题是“你把编程当作爱好吗”。所以当我们看到“爱好者”上面的“是”和“否”问题时，他们是在回答“你把编程当作爱好吗”。那么，有一个问题。如果我想定位某一特定列的含义，而不需要手动搜索整个数据框该怎么办。

好吧，在这种情况下，我们可以简单地将列名设置为索引，并使用dot Lo索引器。因此我会在这里设置索引，正是在我们加载模式数据框的地方。让我回到这里的顶部。我们希望这一列作为索引，因为这些都是唯一的值。

所以我将获取这一列的名称，恰好就是“列”。然后在这里，我会说我想要索引。等一下，让我把它放在字符串里面。好的，索引调用等于列。运行它。现在让我们重新运行我们的模式数据框。现在我们可以看到该列是粗体的。

所以这就是我们的索引。现在我们可以直接使用dot Lo来搜索这些列。如果我想查看爱好者列的信息，我可以说，让我向下滚动。我可以说模式数据框dot Lo。然后我们可以传入我们想要的索引标签。

所以如果我想看看“爱好者”是什么。那么我们可以看到，哦，好吧。“爱好者”的问题文本是“你把编程当作爱好吗”。那么让我们回到我们的调查数据，看看我们能否找到一个对我们没有太多意义的列。如果我在这里滚动一下，好吧，比如，这个“M G R”是什么意思。😊，笨蛋，好的。

N GR 笨蛋。所以让我向下滚动。现在我会将其粘贴到模式Df dot Lo并重新运行。现在我们可以看到该列的信息。实际上，文本在Jupiter笔记本中默认被截断，但如果我们希望查看整个问题文本，我们可以更改该设置。

不过我想保留，因为我们有这么多数据要显示。但是相反，如果你想查看那个问题的完整文本，那么你可以直接通过传入列名到dot Lo中，访问该行和列中的数据。

就像我们之前看到的，当我们使用dot Lo时，这是我们想要的行。那么我们想要哪个列呢？我们想要读取问题文本。所以我将其粘贴进来。现在如果我再运行一次，我们可以看到完整的问题文本为：M GR idiot的意思是你对你的经理是否知道自己在做什么的信心有多大。

这是一个很好的例子，说明设置这些索引是多么有用，因为它让我们能够非常轻松地按标签搜索这些行，就像我们在这里使用模式一样。现在，让我在结束之前再给你展示一件事情。我们可以看到，我们成功地设置了索引，这一切看起来都很好。

但如果索引按字母顺序排序，可能会使读取模式数据框变得稍微容易一点。因此，做到这一点的方法就是简单地说schema Df dot sort。underscore index。让我们运行一下。让我往下滚动一点。我们可以看到这些索引现在按字母顺序排序了。

所以如果我们知道想要获得就业或其他信息，这将会更容易找到你要寻找的内容。如果你想将其按降序排序，那么我们可以简单地将ascending设置为false。

现在我们可以看到，这里呈现的是反向顺序。因此，根据你的数据，这可能会让阅读变得更容易。我们将在未来的视频中深入讨论更高级的排序，但这些只是关于如何将索引整理好的一些基础知识。现在，像往常一样，我们来看我们的数据框。

如果你希望排序是永久性的，并且能够影响未来的单元格，那么你应该将in place设置为true。我们在整个系列中会看到很多这种用法，因为这样做可以让我们看到数据框的样子，而不会实际影响数据框本身。所以在这里，数据框仍然是未排序的，但如果我在这里说sort index in place等于true。

重新运行它，然后再重新运行我们的模式数据框，现在我们的模式数据框是永久排序的。因此，根据你的数据，学习这些索引将非常有用，特别是在使用dot Lo时，因为它允许你通过标签进行搜索，这在你搜索的数据类型上是极其有用的。好的，在我们结束之前。

我想提到这个视频的赞助商，那就是Brilliant组织。

在这个系列中，我们一直在学习关于pandas以及如何在Python中分析数据的内容。Brilliant将是一个极好的补充，帮助你通过他们的动手课程来巩固在这里学到的知识。他们有一些优秀的课程和课程内容，可以深入探讨如何正确思考和分析数据，尤其是数据分析基础。我非常推荐查看他们的统计课程。

该视频展示了如何分析图表并确定数据的重要性。我还推荐他们的机器学习课程，它将数据分析提升到一个新水平，你将学习到机器在考虑过多变量时如何做出决策的技术。因此，支持我的频道并了解更多关于 brilliant 的信息。

你可以访问 brilliant.org/Cs 注册免费账户。前 200 位访问该链接的人将获得年度高级订阅 20% 的折扣。你可以在下面的描述部分找到该链接。再次强调，这个链接是 brilliant.org/Cs。😊

好的，我想这就是这段关于 pandas 视频的内容了。希望你能对如何使用索引以及它们为何有用有一个清晰的了解。正如我所说，你不必使用索引，但根据数据的不同，有时使用索引会更有意义。例如，在这个视频中，设置模式数据框索引让我们更容易查找列名。

在下一个视频中，我们将开始学习如何过滤数据框，并抓取符合特定标准的数据。也许我们只想查看薪资高于某个数额的数据，或者我们只想查看在这次调查中表示使用 Python 的人的数据。在下一个视频中，我们将看看如何根据这种类型的标准过滤数据框。

如果有人对这里涵盖的内容有任何问题，请随时在下面的评论区提问，我会尽力回答。如果你喜欢这些教程并希望支持它们，有几种方式可以做到。最简单的方式就是给视频点赞并点击赞👍。

另外，这是一个😊，请分享这些视频给你认为会觉得有用的人。如果你有能力，可以支持我的 Patreon。该页面的链接在下面的描述部分。请务必订阅以获取未来的视频。感谢大家的观看。

用 Pandas 进行数据处理与分析！真实数据&实时讲解，学完就能上手做数据分析了！＜实战教程系列＞ - P4：4）过滤 - 使用条件过滤行和列 - ShowMeAI - BV1M64y187bz

大家好，你们过得怎么样？在这个视频中，我们将介绍如何从数据框和系列对象中过滤数据的基础知识。所以，例如，如果我们想查看我们的调查数据并只查看会使用Python的人。我们可以过滤出那些数据。或者也许我们只想查看来自特定国家的结果，或者是拥有特定薪资范围的人。

类似这样的事情。我们可以通过过滤我们的系列和数据框对象中的数据来做到这一切。我们将在这个视频中学习如何做到这一点，所以过滤是学习pandas的主要内容之一，因为这基本上是我们通过过滤我们想要的数据与不想要的数据来开始每个项目的方式。

现在，我还想提到我们有一个赞助商为这个视频提供支持。那就是brilliant org。所以我真的很想感谢brilliant赞助这个系列。如果你们能通过下面描述部分的链接去查看他们并支持赞助商，那就太好了。我稍后会多谈谈他们的服务。所以话说回来。

让我们开始吧。好的，首先让我给你们展示一些将成为我们过滤基础的内容。如果我们进行基本的比较，使用我们的数据框。那么我们将得到一些有趣的结果。让我们看看这个是什么样的。所以现在，我打开了我们在系列中看到过几次的代码片段笔记本。

在这里底部，我要进行一个基本的比较，看看结果是什么样的。所以假设我想要数据框中姓氏为“do”的每个人。应该有两个，因为我们在数据框中有一个Jane do和一个John Do。所以在我们底部的单元格中，我将放入一个比较，表示Df。

然后我们想要访问那个姓氏列。现在我们可以简单地说，如果那个姓氏等于“do”。所以如果我运行这个，那么我们得到的将是一个系列对象。这可能不是你所期望的。所以也许你认为我们会得到一个包含所有满足我们条件的值的数据框。但我们得到的是一个带有一堆真值和假值的系列。😊 现在。

这些真值和假值实际上对应于我们的原始数据框，真值是满足我们的过滤条件的行，而假值是未满足过滤条件的行。所以你可以基本上把这个想象成一个掩码。因此我们可以在这里看到，在我们的简单数据框中，姓氏为shaffer的值是假的。

这两个姓氏中的“do”是真的。所以这是一个过滤掩码，当你将它应用于数据框时，它会给你所有满足该过滤条件的行。那么现在我们来将这个过滤器应用于我们的数据框。首先，我要将这个返回的序列赋值给一个变量。

我就把这个变量叫做过滤器。所以我会说Fil等于，然后这个比较。现在filter是Python内置的关键字。所以请确保使用其他名称。每次我分配这两个变量时，我通常只使用这个fil关键字。我们不是关键字，而是变量名。现在。

我通常也喜欢将整个过滤器用括号括起来，因为我觉得这样更容易阅读。所以这不会改变任何事情，但我只是把整个内容放在括号里，这样我就可以看到这个赋值和这个等号是分开的。

好的，所以现在我们有这个过滤器。记住，这个过滤器变量等于这系列的真和假值。现在让我们将这个过滤器应用于我们的数据框。我们可以通过几种方式做到这一点。所以你可能会看到一些人这样做。我们可以直接传入，就像我们在搜索一个列一样。我们可以在这里传入一个过滤器。如果我运行这个，哦，不。

我在这里遇到了一个错误，因为我没有运行这个单元来设置那个变量。所以我会重新运行它。现在如果我运行这个，然后我们可以看到返回了一个数据框，其中包含所有有姓氏“Do”的行。😊现在，我们只是在不同的行上分配过滤器，因为我觉得那样更容易阅读。但你可能会看到一些人将这些比较直接放在数据框的括号中。

所以你可能会看到像这样的情况。我现在就把它注释掉，抓取这个整个过滤器。你可能会看到一些人这样做，直接粘贴或放进去，我们也可以看到那样也有效。现在我觉得这比仅仅将其分配给变量更难以阅读。所以我会将其用作变量，但你应该知道这是一种可能性，因为你会看到一些人直接将过滤器放进去。

好的，这是一种缩小这些行的方法。现在你可以做的另一种方法，我更喜欢的方式是使用我们已经看到几次的点lo索引器。我稍后会讲讲我为什么更喜欢这个。但如果我们将布尔值传入点lo，那么它应该给我们与当前相同的结果。

所以如果我说Df点lo并传入相同的过滤器，我们可以看到得到完全相同的结果。这给我们带来了与我们下面的点lo相同的结果。这是pandas让人感到困惑的一个原因，因为你可以将多个东西传入这些不同的括号以获得不同的结果。正如我之前所说，do lo用于按标签查找行和列。

但是如果你传入一系列布尔值，就像我们这里做的那样，你也可以过滤数据。现在，我喜欢使用dot Lo的原因是因为我们仍然可以抓取我们想要的特定列。例如，如果我想要电子邮件列，我可以简单地在dot Lo中传入第二个值，并说我们想要那个电子邮件列。如果我运行这个。

然后我们可以看到匹配那些姓氏的电子邮件。所以记住，dot Lo的第一个值是我们想要的行，第二个值是我们想要的列。由于我想要电子邮件列，它给我返回了一个那些姓氏等于Do的电子邮件系列。所以让我们快速看看其他一些过滤数据的方法。

首先，让我们看看与和或操作符。现在，我们不能使用Python内置的and和or关键字作为我们的过滤器，所以我们将使用其他符号，我们将在这里使用的符号是&作为与，让我把这些写下来。

与的符号是&，或的符号是竖线。这些符号沿用了其他编程约定，所以你可能以前见过它们。例如，假设我们想要过滤所有姓氏为Do且名字为John的行，这应该只返回这个结果。为此，我们可以回到我们的过滤器，并且我会去掉这个单元格，因为接下来我只会使用dot Lo。

现在，使用我们的过滤器，假设我们想要姓氏等于dough，我们将使用&，并且我们想要名字等于John。所以我会把这个放进去。我还会把它们分开。我喜欢把每一个都用括号括起来。我认为这样阅读起来更容易。所以如果我重新运行那个过滤器，然后重新运行我们的dot Lo。

然后我们可以看到现在只得到了那个单一的电子邮件地址。这个电子邮件地址是所有姓氏等于Doe且名字等于John的结果。所以在这种情况下，只有一个结果。那么现在我们来看一个使用或操作符的例子。为此，我们可以使用竖线字符。

假设我想要一个过滤器，其中姓氏等于shaeffer或名字等于John。好吧，如果我想让姓氏等于chaeffer，或名字等于John，我们在这里使用一个竖线字符。因此，如果我重新运行这个，就可以看到我们得到了所有的行或所有的电子邮件地址。

😊，最后一个名字等于沙弗，或者第一个名字等于约翰。所以在这种情况下，这正是这两行。现在我们也可以得到一个过滤器的相反结果。假设我想获得这个过滤器的完全相反结果，即我们希望所有最后一个名字不是沙弗，且第一个名字不是约翰的行。现在我可以在这里调整一下我当前的查询，尝试把一切弄对。

或者我可以简单地在这个过滤器的开头添加一个波浪号，它会给我所有不匹配该过滤器的结果。所以如果我在这里输入一个波浪号，那么它将否定那个过滤器，并给我相反的结果。所以我们可以看到这里得到了简·多，因为所有结果中最后一个名字不是沙弗，或者第一个名字不是约翰。

这回到了我们可能在学校学习过的真值表。如果有人对真值表不熟悉，请告诉我，也许我可以在未来的视频中讨论这个主题，但这更多是数学相关的，而不是编程相关，尽管这两者确实经常重叠。好的，这基本上涵盖了对小数据框进行过滤的基础知识。

但现在让我们回到更大的调查数据集，看看一些我们可能想要查看的过滤器的现实例子。我将打开我的另一个笔记本，这里是我们在整个系列中使用的Stack Overflow调查数据。

再次提醒，如果你想跟着做，你可以在下面的描述部分找到这段代码和数据的链接。好的，现在我们了解了一些基本的过滤方法。让我们看看能否对我们的调查数据运行一些过滤器。例如，假设我们想查看那些薪水超过某一金额的人的数据。

也许我们想看看哪些语言的薪水更高，或者其他类似的事情。因此，为了做到这一点，我将首先创建一个过滤器。如果你不知道数据框中的哪一列给出了薪水，那么你总是可以通过我们在整个系列中看到的模式数据框找到，它告诉我们这些列的含义。

但是为了节省时间，我只告诉你这个关于薪水的列在这里。如果我在这里找，我想我可以很快找到它，它就是这个转换后的薪资。所以如果我们滚动查看这些调查结果，我们可以看到这个人说他们的收入大约是9000，另一个人赚61000，这些都是转换为美元的。让我刷新一下这个页面，以确保我运行了所有这些单元，并且这些变量都已初始化。

好的，如果我们想要获取所有高薪的过滤器，那么让我过来这里，再次复制这个列名。现在让我们创建一个过滤器，我称之为高薪，并将其设置为条件，其中我们说我们想要数据框中这个转换薪资列的Df，希望它超过7000。

你知道这有点主观，但我们将把它作为过滤器。现在让我们将该过滤器应用到我们的数据框中。就像之前看到的那样。我可以说Df do Lo，然后将高薪过滤器传入。现在我们可以看到一些结果，但这并不是我们所有的受访者。

现在我们可以看到受访者6、9和13。如果我滚动到我们的转换薪资，那么这些薪水都应该超过70000，看起来确实如此。现在，为了稍微缩小这些列，让我们只抓取一定数量的列。所以我将抓取国家。

编程语言和薪水。因此，为了做到这一点，请记住。我们可以将这些传入dot Lo。在这里，我们正在进行dot Lo。我在这里放一个逗号。现在我将列出我们想要的列。假设我们想获取国家，我们还想获取这些人所使用的编程语言。

这里，正如我所说，你可以在架构中查找所有这些。但这是在“使用的语言”下。我们可以看到这个人会Java、R、SQL等等。因此我将其粘贴为我们想要的列之一。我还会获取转换薪资，所以我也将其粘贴。现在让我们运行这个。

现在我们可以看到我们不仅得到了符合这个高薪标准的人员过滤器，而且我们只获得国家、他们知道的语言和他们的薪水。所以我们的过滤器似乎确实被正确应用，这样运行得很好。现在我看到这些国家，这让我想起我们可能想用多个值进行一些过滤。

例如，我的YouTube观众主要来自美国、印度、英国、德国和加拿大。好吧，这就是观看视频的观众中最大比例的来源。所以假设我想过滤出这里的调查结果，只查看这五个国家的结果，现在我可以在这里创建一个超级长的过滤器，我说。如果国家等于美国，或者如果国家等于印度，或者如果国家等于英国。

这会占用很多空间。因此，让我们创建一个国家的列表。然后我将向你展示一个我们可以用来过滤这些的好技巧。那么现在，在这里，而不是使用这个高薪过滤器，我将创建一个国家的列表。我会把这个等于……我打字有点慢，所以让我快速打出来。

好的，现在如果我们想要所有这些调查结果，其中受访者表示他们来自这五个国家之一，那么我可以简单地说，我将在这里设置一个新的过滤器。实际上，让我在这里做这个。我会设置一个新的过滤器，并将其等于 DF 的国家。所以国家在……我们想要国家在这个国家列表中。所以我要运行这个单元格，现在。

让我们将这个过滤器应用到我们的数据框中。因此，如果我运行这个，并且只是为了缩小这些结果，以确保我们能立刻看到国家。我将只抓取国家。所以如果我运行这个，我们可以看到好的，我们得到了英国、美国、加拿大和印度。

看起来这也应用得很正确。现在，让我给你展示一个你可能会经常使用的常见过滤操作。因此，我们实际上也可以在 pandas 中使用字符串方法来对数据框进行一些修改，或者在这种情况下帮助处理条件。让我告诉你我想表达的意思。

假设我们只想查看那些回答自己知道 Python 作为编程语言的人。那么我们看看该怎么做。首先，列出每个人说他们知道的编程语言的是“所用语言”列。让我们看看这看起来如何。这里，我只是抓取“所用语言”。

所用语言列，哎，我把“语言”拼错了。所以是“所用语言”。我没说错吧？好的，我们可以看到这里有一些编程语言，每种语言之间用分号分隔。因此，我们不能仅仅查询“所用语言”是否等于 Python，因为该列的实际值将是调查中列出的任何语言组合。因此，我们可以采用的方法是使用字符串方法，看看 Python 是否在他们知道的这些语言字符串中。

为了做到这一点，我将重新编写我的过滤器。我只是想说我的过滤器将等于，并且我们要抓取每个人的“所用语言”，然后我们将使用一些字符串方法。所以我将说 dot STR dot contained。

然后我将传入 Python。现在我们还可以看到这里有一些 inN 值，但不是数字。现在我们还需要为那些设置一个填充值，否则我们可能会得到一个错误，所以这是 contains 方法的一部分。我可以说 in 等于 false，我们不会对那些做任何操作。所以让我再解释一次。我们这里放置的这个过滤器。

它说，好的，对于这一列，这里的语言是处理过的。这些结果都是在这里。我们在说这一列中的字符串是否包含 Python。所以这就是我的过滤器。我将运行那个单元，现在让我们通过调用 dot Lo 并传入这个过滤器来应用到我们的数据框中，现在让我们还抓取一下处理过的语言列，以确保这一点。正常工作。因此，如果我运行它，那么所有这些结果或者说这些行都应该在它们的已知语言中包含 Python。

所以我们可以看到那里有 Python。所以是的，似乎在所有这些结果中都有。现在这个编号 8 的地方我们实际上看不到，但这里有省略号，所以可能只是被截断了。在我上一段视频中，我一直在说这些是被连接的。我是指被截断。一些人指出了这一点。所以是的。

这里被截断了，所以我们无法看到 Python 的值，但它们确实存在。我可能会在将来做一个关于字符串方法的完整视频，因为我们可以用这些方法做很多其他事情，比如替换文本、拆分值等各种不同的操作。

所以这些字符串方法在 pandas 中非常有用。这是对我们数据框进行一些过滤的基本概述。再次强调，关键点是我们可以在这里进行这些条件筛选，并将它们作为过滤器，另外让我仅仅打印出这个过滤器，而不应用到数据框上。

我们可以看到过滤器返回了一系列的真和假的值，当我们将其应用到数据框时。这些真假的值基本上对我们的数据框应用了一个掩码，我们得到所有的真值，而不是假的值。所以如果我看这里，我们有响应者 12、4 和 5 是真的，而 3 是假的。所以如果我查看我的数据框，我们可以看到我们得到了 1、2、4 和 5，而 3 不在那，因为那个值是假的。

这就是过滤器的工作原理。再一次，这是 pandas 的一个重要部分，因为这是我们在加载数据到 pandas 中时首先要做的事情之一。好的，在我们结束之前，我想提一下，我们为这个视频找到了一个赞助商，那就是 brilliant.org。

Brilliant是一个解决问题的网站，通过积极参与指导课程帮助您理解基本概念，Brilliant将是补充您在这里学习的知识的绝佳方式，他们提供动手课程。他们有一些关于数据科学的优秀课程和课程，深入探讨如何正确思考和分析数据。

因此，如果您正在观看我的熊猫系列，因为您正在进入数据科学领域，那么我强烈建议您也查看一下Brilliant，了解您可以学习哪些其他数据科学技能。他们甚至在统计课程中使用Python，并会对您如何正确分析语言中的数据进行测验。他们的指导课程会挑战您，但如果您需要，您也可以获得提示甚至解决方案。

它真正侧重于理解材料。因此，为了支持我的频道并了解更多关于Brilliant的信息，您可以访问brilliant org，免费注册。此外，前200位访问该链接的人将获得年度高级订阅的20%折扣。

您可以在下面的描述部分找到该链接。再次说明，这是brilliant org forge。😊。

好的，所以我想这就是本期熊猫视频的内容。希望您能清楚地了解如何在数据框中过滤数据，以找到您所寻找的信息。正如我所说，这是熊猫中的一项基本技能，通常是我们处理数据时首先要做的事情。在下一个视频中，我们将学习如何更改数据框中的数据并进行修改。我们将学习如何更改特定值。

以及如何在整个数据框中一次性进行多项更改。例如，您可能希望将所有电子邮件地址转换为小写，以便更容易搜索。或者您可能想删除列名中的空格，并用下划线替换它们。这些内容将在下一个视频中介绍，请务必关注。

但如果有人对本视频中涉及的内容有任何疑问，请随时在下面的评论区提问，我会尽力回答。如果您喜欢这些教程并想支持它们，那么您可以通过几种方式做到这一点。最简单的方法是😊，给视频点赞并点个赞。还有。

与您认为会觉得这些视频有用的任何人分享这些视频是非常有帮助的。如果您有能力，您可以通过Patreon支持我。该页面的链接在下面的描述部分。请确保订阅以获取未来的视频。感谢大家的观看。😊。

用 Pandas 进行数据处理与分析！真实数据&实时讲解，学完就能上手做数据分析了！＜实战教程系列＞ - P6：6）增删 - 从Dataframe中添加与删除行和列 - ShowMeAI - BV1M64y187bz

大家好。你们过得怎么样？在这个视频中，我们将学习如何从数据框中添加和删除列。我们还会看看如何将多个列的信息合并为一个。现在，在我之前的视频中关于更新行和列的内容，那个视频比较长。

但这个应该短很多。现在，我想提一下，我们这系列视频有赞助商，那就是 Brilliant。因此，我真的想感谢 Brilliant 赞助这个系列，如果你们都能通过下面描述部分的链接查看他们并支持赞助商，那就太好了。我稍后会多谈谈他们的服务。所以说到这里。

让我们开始吧。正如我所说，在上一个视频中，我们看到了如何更新行和列中的信息。现在我们将看到如何添加和删除行和列。首先，让我们看看添加列。添加列对我们来说会很简单，因为这基本上与我们更新值时所做的相同。

我们可以简单地创建一个列，并传入我们希望该列具有的一系列值。因此我现在在这里打开的代码片段文件是我们之前视频中见过的。😊。我们可以在较小的数据上查看这是什么样子，像往常一样，如果你想一起操作，我会在下面的描述部分提供代码、笔记本和我在本系列中使用的数据的链接。

假设我们想把名字列和姓氏列合并成一个单独的列，并称之为名字。那么首先，为了获取合并后的名字和姓氏的序列，我们可以简单地说，当我来到这里的底部时，我们可以抓取第一列，然后将这些列相加，并在中间加上空格。

然后我将添加姓氏，如果我运行这个，哎呀，我漏掉了第二个加号，现在如果我运行这个，我们可以看到我们得到了名字和一个空格，这就是这一部分在做的事情，然后是姓氏。所以现在我们有了一系列的值。

我们可以看到我们有三个值。为了将这些值添加到新列中，我们可以简单地说 Df，然后是我们想要的新列的名称。我将把这个叫做全名，然后我只需复制之前给我们这个序列的内容，并将这个全名列分配给那个返回的序列。所以如果我运行它，然后查看我们的数据框，那么现在我们可以看到我们的数据框这里有了这个新列，它是名字和姓氏的组合，再次。

我在这里使用字符串，但你也可以使用我们在上一个视频中看到的 apply 方法创建一个新列，以便为数据框中的另一列进行某种数学分析。现在，我想指出的是，当像这样分配一列时，不能使用点符号，我们必须使用括号，如我们在这里所做的，以便进行这些分配，因为如果你使用点符号，Python 会认为你试图将一个属性分配到数据框上。

并不是一列。那么，我们就来看一下如何向数据框添加一列。现在我们来看一下如何删除列。既然我们有了全名列，我们可以说我们不再需要或想要我们的名字和姓氏列，所以要删除这些。我可以在我们的数据框上使用 drop 方法。所以这就像说 Df do drop 一样简单。

现在我们想删除什么呢？我们想删除列，而这些列将等于。我将传入一个列表，因为我们想删除多个列。所以我想删除第一列和最后一列。如果我运行这个，我们可以看到它返回一个没有这些列的数据框。就像我们之前看到的。

这只是给我们一个视图，显示我们的数据框看起来会是什么样子，但如果我们对这些更改满意，它并不会实际应用这些更改。那么我们可以将 in place 参数设置为 true，以便它在原地更改我们的数据框。所以我可以在这里说 in place 等于 true，在我们的 drop 方法内。如果我运行这个。

然后我们查看我们的数据框，现在我们可以看到我们的数据框不再有名字和姓氏列。如果我们想反转这个过程，将全名列分割成两列，那就稍微复杂一些，但仍然相对简单。

在这个系列中，我们已经看过几次字符串分割方法。现在我们来对全名列运行一下，看看我们得到什么。我将说 Df，并访问那个全名列。现在我将对我们的系列使用字符串类，然后我们将进行分割。

我们将根据空格进行分割。现在分割默认是基于空格的，但我想在这里明确一下。所以如果我们运行这个，那么分割方法的结果是我们得到名字和姓氏的列表。因此，名字是第一个值，姓氏是第二个值。现在，如果我们想将这两个分配到不同的列中。

然后我们需要扩展这个列表，使它们实际上分布在两列中。要在 pandas 中做到这一点，我们可以使用 expand 参数，让我们看看这是什么样子。所以这是在分割方法内，我们可以传入另一个参数，并说 expand 等于 true。

如果我运行这个，那么我们可以看到结果非常相似。但现在我们列表中的所有内容都被分割成了列。因此我们在这里有两个分割结果的列。现在我们需要做的是将数据框中的两列设置为刚刚返回的这两列。所以我们可以说，如果我们记得在系列早期的内容，如果我们想访问多列，那么在括号内我们可以传入一个列表，因此我们将有两个括号，内层括号是我们的列表。

关于列。我想添加第一列和最后一列，我们将把其设置为我们在这里使用split方法所做的那样。如果我运行这个，那么我们的第一列和最后一列应该已被分配到这些列中。让我们看看我们的数据框，看看这是否有效。我们可以看到现在我们添加了第一列和最后一列，并且它们的值是我们在这里返回的。

好的，这就是我们如何添加和删除列的方式。现在让我们看一下添加和删除数据行的方法。有几种不同的方法可以将行添加到我们的数据框中。首先，我们可能只是想将一行新数据添加到我们的数据框中。其次。

也许我们想将两个数据框合并成一个，通过将一行附加到另一行。所以首先，让我们看一下添加一行数据。我们可以使用附加方法来做到这一点。如果我想添加一行数据，我可以直接说Df do append。现在我们可以在这里传入我们的值。我将传入一个字典，并传入一个名字为Tony。

如果我运行这个，我们可以看到我们得到一个错误。现在，这是因为目前没有索引。有时很难读取这些pandas错误并弄清楚问题所在。但在这种情况下，它确切地告诉我们该怎么做。它在底部说只能在ignore index等于true或系列有名称的情况下附加一个系列。

所以我们就忽略索引，我们现有的数据框将自动为这一新行分配一个索引。在顶部，我们可以简单地传入一个参数ignore underscore index，并将其设置为true。现在如果我运行这个，就能看到它成功了。我们不再收到错误，并且在底部也没有问题。

我们可以看到这个新名称是附加的。现在我们只为这一行分配一个名字值。因此我们可以看到这里将其分配为Tony，其他所有列的值都设置为一个表示缺失值的非数字值。所以你可以传入一个完整的系列或信息列表，以便添加你想要的任何信息的单行数据。

现在如果我们有一个想要附加到现有数据框的数据框，我们也可以做到这一点。所以让我从顶部的现有值创建一个新的数据框。我将向上滚动，抓取我们最初创建数据框时的第一个字典，并稍微修改一下。所以我只会保留这两个名字。

取出这些第三个值，然后我们将继续更新这些。所以更新这些。对于第一个名字，我将用托尼和史蒂夫，对于姓氏，我将用斯塔克和罗杰斯，对于电子邮件地址，让我们看看，我将用Ironman@Avenge.do.co，对于第二个，我将用cap@Avenge.do.co。现在我将根据这个新字典创建一个新的数据框。

现在我要调用这个Df2。所以现在我可以说PD.t数据框，并传入那个people字典。现在我们应该有第二个数据框。好的。那么现在假设我们想将这个添加到现有数据框中。我们可以简单地将一个数据框附加到另一个数据框。

现在这些有冲突的索引，并且它们的列顺序也不同。因此，我们再次希望在附加时忽略索引，以便正确分配索引。所以我将说Df.append，并传入Df2，以便将其附加到我们的原始数据框中。然后我将说ignore_index等于true。

如果我在这里运行，那么我们可以在底部看到它添加了这些新行。现在，如果你收到警告，那么原因是因为在附加时我们没有以相同的顺序传入所有列。这给我们带来了一个警告，说明有不同的方法可以对列进行排序。所以不必太担心，但在未来的pandas版本中。

它将默认将排序设置为false，实际上，pandas版本1在我录制这个系列时刚刚发布，所以这可能已经完成，但我们暂时可以忽略它。如果我们想的话，可以传入sort等于false的值，以消除这个警告。所以如果我回到这里，传入sort等于false，并且当我运行时，它将不再对这些列进行排序。

然后我们可以看到不再出现那个警告，现在它也不再对列进行排序了。与drop方法不同的是，如果我们想让这些更改永久生效，那么我们就没有一个就地方法可以使用，而是必须通过复制这个返回的数据框来设置数据框，然后我们可以说Df等于。

然后将返回的数据框传入。所以如果我运行这个。然后我们看看我们的原始数据框，我们可以看到那些行被添加上去了。老实说，有些人可能想在下面的评论区问为什么有些有inplace参数而有些没有，但说实话，我也不太确定，我相信是有原因的，但我还需要再深入探究一下，确切地找出原因，但这个append方法没有像drop方法那样有inplace参数，所以我们必须这样做。

最后，让我们看看删除行。假设你是一个钢铁侠的粉丝，你想从数据框中删除史蒂夫·罗杰斯。现在我们几乎可以以与删除列相同的方式做到这一点，但不是指定我们想删除的列，而是简单地传入我们想删除的索引。因此我可以在这里说Df do drop，我们可以在最左边看到，如果你看过我关于索引的视频，这个索引是四，所以让我们。

假设我们想删除索引为四的行。所以如果我运行这个。我们可以看到我们仍然有钢铁侠和托尼·斯塔克，但不再有史蒂夫·罗杰斯。因此第四个索引被删除了。而且，如果你想实际将其应用于数据框，那么你需要将inplace参数设置为true。

现在你可能想做一些更复杂的事情，并使用条件删除行。现在我可能会像在之前的视频中那样使用Lo，我们学习了如何从数据框中过滤数据。所以我们也可以使用drop。因此如果我想删除所有姓氏等于do的行。我们这里有两个这样的值。然后我可以传入那个过滤器的索引。

让我来展示一下这是什么意思，没那么复杂。所以我可以说Df do drop。现在我要说index等于。接下来我将放入我的条件。所以如果你还记得。从过滤视频中，我们实际上可以在括号内传入条件。因此，现在我可以说，好吧，我想要一个条件，其中该列的姓氏等于do。

现在，唯一的区别在于。我们这里有一个条件。因此我们想要索引，因为我们说index等于。所以就在这里最后。我将使用这个方法，直接说.dot index。所以如果我运行这个。我们可以看到它移除了姓氏为do的那些值。现在。

正如我在那个过滤视频中所说，我不太喜欢将所有内容挤在一起，因为我觉得这样很难阅读，你总是希望你的代码对其他开发者来说容易阅读。因此，我会将条件提取到自己的变量中，而不是。

我会这样说。我会说filteril的过滤条件等于。然后我会抓取我们的条件。😊，把它剪切出来并粘贴到这里。现在我们可以说我们想要将我们的过滤应用到那个数据框上，然后抓取它的索引。所以如果我运行这个，我们可以看到这给我们带来了完全相同的结果。

但那样更容易阅读，所以这就是关于从数据框中添加和删除行和列的概述。在结束之前，我想提一下本视频的赞助商，赞助商是brilliant。因此，在这个系列中，我们一直在学习pandas以及如何在Python中分析数据，而brilliant将是补充你在这里所学内容的绝佳方式，提供他们的实践课程。

他们有一些出色的课程和教学，深入讲解如何正确思考和分析数据，以掌握数据分析的基础。我真的推荐查看他们的统计课程，它教你如何分析图表并确定数据的显著性。

我还会推荐他们的机器学习课程，它将数据分析提升到一个新水平，在那里你将学习被用来让机器进行学习的技术。😊。

决策中变量太多，无法让人类考虑。因此，为了支持我的频道并了解更多关于brilliant的信息，你可以去brilliant org forgelash cms注册，免费注册。此外，前200个访问该链接的人将获得年付高级订阅的20%折扣。

你可以在下面的描述部分找到那个链接。再次提醒，那个是brilliant org forge。好吧，我想这就是本期pandas视频的内容。我希望你能对如何添加和删除数据框中的列和行有一个好的理解，并且能自信地做到这一点。在下一个视频中，我们将学习不同的排序数据的方法。

如果任何人对我们在这个视频中讨论的内容有任何问题，请随时在下面的评论区提问，我会尽力回答这些问题。如果你喜欢这些教程并希望支持它们，有几种方式可以做到这一点，最简单的方法就是给视频点赞并给予好评。

同时，将这些视频分享给任何你认为会觉得有用的人也是一个很大的帮助。如果你有条件，可以通过Patreon进行支持。这个页面的链接在下面的描述部分。😊。

确保订阅以获取未来的视频，感谢大家观看。

用 Pandas 进行数据处理与分析！真实数据&实时讲解，学完就能上手做数据分析了！＜实战教程系列＞ - P7：7）排序 - 数据排序 - ShowMeAI - BV1M64y187bz

大家好，最近怎么样？在这个视频中，我们将学习如何在 Pandas 中对数据进行排序。所以我们将看看如何对列进行排序，如何对多个列进行排序，以及从不同的行中提取最大和最小值。和往常一样，我们将首先看看如何在小数据集上做到这一点。

然后我们将看到这如何应用于更大的数据集，比如我们在整个系列中使用的堆栈溢出调查数据。现在，我一直在阅读你们对这个系列的评论和建议，并努力将这些建议纳入其中。很多人表示希望视频更短。

所以我会尽力制作更短的视频，同时不牺牲我认为重要的细节。现在，我还想提到我们有一个赞助商为这个视频系列提供赞助，那就是 Brilliant。因此，我真的想感谢 Brilliant 赞助这个系列。如果大家能够通过下面描述部分的链接去了解一下并支持赞助商，那就太好了。

然后我会稍后详细介绍他们的服务。所以话不多说，我们就开始吧。好的，我现在打开的是我们在整个系列中看到的代码片段笔记本。再次提醒，如果有人想要跟着做，我提供了链接。😊这个代码和下面描述部分的数据。

假设我们想对这里的小数据框进行排序。首先，让我们决定一下想如何排序。现在，一个合理的方法是按姓氏排序。因此，为了做到这一点，我们可以使用这些排序值的方法。为了按姓氏排序，我只需说 df.sort_values。

然后我们将按姓氏排序，并将 by 参数设置为列名，这里是 last。所以如果我运行这个，就可以看到返回的数据框中姓氏按字母顺序排序。如果这些是数字，那么它们将从小到大排序，我们在查看堆栈溢出数据时会看到这一点。

现在，如果我们想按降序排序，我们可以传入一个参数，只需说我们希望 ascending 设置为 false。所以如果我运行这个，现在我们可以看到这些数据是按降序排序的。现在，有时你的排序可能会有点复杂。也许你想按多个列排序。

当你排序的第一个值具有相同的值时，你会这样做，然后你想按第二个值进行排序。为了做到这一点，我们可以传入一个我们想排序的列名列表。假设我们希望按姓氏的升序进行排序。

如果有重复的姓氏，我们想在此之后按名字排序。为了做到这一点，我们只需传入一个需要排序的列的列表。所以我实际上要在这里换一行。现在不只是按姓氏排序。我可以在这里传入一个列表。假设我们想先按姓氏排序。

然后我们想要按名字排序。如果我运行这个，我们可以看到这是按姓氏的升序排序的，正如我们之前看到的那样。但如果有相同的姓氏，名字也会按降序排序。所以我们可以看到简在这里是第一个。

现在是约翰，因为这是按降序排列的。有时你可能会遇到需要按多个列排序的情况。所以你可能想要一个降序，另一个升序。让我再往数据框中添加一个名字，以便在我这样做时更加清晰。

所以我会在字典顶部再添加一个名字。就叫这个亚当，并保持重复的姓氏是杜。然后我将传入一个电子邮件，比如email@do.com。现在让我继续重新运行所有这些单元。

所以我就说运行所有单元。现在在底部，我们可以看到我们的姓氏，所有这些都是降序的。但是假设我们想要像这里那样按姓氏降序排序的数据框。那么我们希望名字按升序排列。为了做到这一点。

我们可以简单地向升序参数传入一个布尔值列表。所以让我复制一下我们这里的内容，展示一下这看起来有什么不同。所以我们不只说升序等于假，而是传入一个列表，这些将对应我们的列。如果我说我想要姓氏按降序排列。

那么我们可以将其保持为假。但是如果我想让名字按升序排列，我可以为第二个值传入一个真。所以现在如果我运行这个，我们可以看到我们的姓氏仍然是按降序排列的，但我们的名字现在是按升序排列，亚当在这两个名字之前。

正如我们在系列中多次看到的，如果我们想保存这个数据框并使这个排序永久生效，那么我们可以将inplace值设为真。所以如果我这样做，我只是会在末尾加一个inplace等于真。如果我运行这个。

现在我查看我们的数据框，发现我们的数据框已被修改为一种可以看到这些值按我们指定的方式排序的顺序。现在，如果你想把它恢复到之前的样子，并让那些索引被排序，那么我们可以通过排序索引来做到这一点，所以这次我们不使用排序值的方法。

我们将使用 sort index 方法，因此我可以说 Df.do sort _index，然后运行它。现在我们可以看到，索引在最左侧按我们添加的顺序排序。现在我还想指出，如果你只想对单列进行排序，我们也可以很容易地对那个单一系列进行排序。

series 对象也有 sort value 方法。因此，如果我们只想查看已排序的姓氏，而不是整个数据框，那么我可以简单地访问那一列。在括号中传入姓氏列，然后我可以说 sort，_values。我将所有参数保留为默认值并运行它。现在我们可以看到这些是按升序排序的。好的，这只是一个简要概述。

现在我们来看看我们的调查数据，看看在更大的数据集上这是什么样子。我们还将看到一些简单的方法来查看我们数据中最大的和最小的结果。好的，我这里打开了我们的 Stack Overflow 开发者调查，这是我们整个系列中看到的内容。如果你想下载这些数据以便跟随。

然后我在下面的描述部分中有链接。好的，有一种方法可以对调查结果进行排序，就是按国家名称。我们可以看到这里有一个国家列，受访者回答了他们来自哪个国家。因此，也许你正在对来自不同国家的信息进行一些分析。

看到它们排序后会更容易一些。例如，我们想看看国家和薪资。因此，要按国家对这些调查结果进行排序，我们可以简单地到下面说 Df.dot.sort，_values。然后我想按国家进行排序并将其设置为国家。

现在我还将对此进行原地修改，以便它更改我们的数据框。所以现在我们来看看这个数据框前 50 个结果左右的国家列。我将访问那个国家列的前 50 个，并使用 head 方法来获取它们。如果我运行这个。

然后我们可以看到这些是按字母顺序排列的。因此，我们有来自阿富汗的开发者的结果，而在底部，结果显示阿尔巴尼亚。现在我们这里只有前 50 个结果，但如果我们查看所有这些，我们会看到所有这些国家都是按字母顺序排列的。

好的，现在我们来看一下这些国家报告的薪资。因此让我把它添加到我们的输出中。我会通过访问 converted comp 列来实现，所以这是 converted comp。现在，请记住，这里有一个错误，一些人在访问多个列时，必须将其放在方括号内的列表中。

我们这里将有两组括号。好吧，现在让我们运行这个。每个受访者的薪资将列在右侧，我们可以看到这里有很多非数字对象，这只是意味着他们跳过了这个问题。

但是如果我们想要一个关于更高薪资的一般概念，那么我们可以按降序排列这些薪资。所以就像我们在之前的例子中看到的，如果我们想要将国家按升序排列，而薪资按降序排列，那么我们可以通过在这里传入多个要排序的列来实现。因此，我们希望按国家排序，并且还希望按这个转换的薪资列排序。

我将在这里传入一个升序参数，并将其设置为一个列表。这将对应我们的列名，看看我们是否希望这些以升序排列。对于国家，我将传入true，因为我们确实希望按升序排列。但我想先看到最高的薪资，这意味着我们希望将其设置为false，以便薪资按降序排列。

如果我运行这个排序，然后我们再看看这个头部。那么我们可以看到现在这里有阿富汗，所有最高薪资都列在了顶部，显示人们所说的收入。如果我们向下滚动，可以看到低薪资为零和非数字的情况，然后一旦我们到达阿尔巴尼亚，就会重新开始该国的高薪资。

现在，我们可以看到这里有一些大的异常值。这比其他人所说的收入要高得多。现在，有一些技术可以用来处理异常数据。我们将在下一个视频中专注于此，讨论数据聚合和分组。

在结束之前，我还想看看一些其他有用的方法，以查看最大和最小值。所以也许你只是为了从特定的数据框中抓取最大或最小值而对结果进行排序。如果你这样做，那么实际上有一个更简单的方法。所以也许我们想要查看调查中10个最高的薪资。为了做到这一点。

我们可以简单地使用nlargest方法。所以首先，我将对此进行处理。假设我想获取那个转换的薪资列，也就是薪资。我将获取nlargest，并希望获取10个最大薪资。如果我运行这个，那么我们可以看到报告的10个最大薪资。

所有这些薪资都是200万。所以我假设这个调查将他们的薪资上限设置为200万。我觉得这相当高，所以我很好奇这些人是怎样的开发者，他们是否在管理职位上。再一次，我们将在下一个视频中看到如何进一步分析这些结果。

但你知道，如果你们中有人作为开发者年收入200万美元并正在招聘，请告诉我，因为你知道我目前不在找额外的工作，但我确实认为在年薪200万美元的情况下，我会破例。现在你可以看到，当我们从这一列中提取出10个最大值时，它只给我们那一列的10个最大值，但如果我们想查看这些行的其他调查结果呢？那么，为此我们可以简单地在整个数据框上运行这个方法。

并传入我们想要获取最大结果的列。因此，我可以说df.nlargest，然后我想从converted comp列中获取10个最大值。如果我运行这个，那么这些将给我相同的行，但现在我们有他们所有的调查结果，而不仅仅是工资。所以如果我在他们的索引上查看，这里是25983，那么我们可以看到第一个是25983。

所以如果我在converted comp上向右滚动，我们可以看到这些都是200万美元。如果我们想查看最小值而不是最大值，那么可以简单地使用nlargest替换为nsmallest。所以如果我查看这里的最小工资，这将给我们调查中的最小工资值。现在我假设这可能只是对那些人来说是零。

当前没有工作，没错，这里是零。好的。那么，这就是如何对我们的数据进行排序以及如何在多个列上排序并获取最大和最小值的简要概述。现在，在结束之前，我想提到一下本视频的赞助商，那就是Brilliant。Brilliant是一个问题解决网站，帮助你通过积极参与指导课程来理解基本概念。

而Brilliant将是补充你在这里学习内容的绝佳方式，他们提供实操课程。他们在数据科学方面有一些优秀的课程和教程，深入探讨如何正确思考和分析数据。因此，如果你因为进入数据科学领域而观看我的熊猫系列，我强烈推荐你也去看看Brilliant，了解你还能学习哪些其他的数据科学技能。

他们甚至在统计课程中使用Python，并会考你如何在该语言中正确分析数据。他们的指导课程将对你提出挑战，但如果需要，你也可以获得提示甚至解决方案。这真的很适合理解材料。因此，为了支持我的频道并了解更多关于Brilliant的信息，你可以访问brilliant.org/Forge。😊

注册是免费的，前200个访问该链接的人将享受年度高级订阅20%的折扣，你可以在下面的描述部分找到该链接，这真是太棒了。orgm。好的，我想这就是本期pandas视频的内容了。

我希望你能对如何整理我们的数据框有一个良好的概述。在下一个视频中，我们将学习聚合和分组数据。现在，这将是很多人期待的视频，因为这正是大多数人想到数据分析时的想法。例如。

我们将看看如何按国家对我们的调查数据进行分组，然后获得每个国家的中位数薪资，以及其他类似的内容。这也将处理之前解决的一些异常数据。掌握这个技能在pandas中绝对是一个好技能，并将为进一步探索你的数据打开许多可能性。

但是如果有人对本视频中将要涵盖的内容有任何疑问，请随时在下面的评论区提问，我会尽力回答。如果你喜欢这些教程并想支持它们，有几种方法可以做到。最简单的方法就是点赞并给视频一个好评。

而且，把这些视频分享给你认为会觉得有用的任何人也是一个巨大的帮助。如果你有条件，可以通过Patreon进行支持。相关链接在描述部分。😊。请确保订阅以获取未来的视频，谢谢大家的观看。

用 Pandas 进行数据处理与分析！真实数据&实时讲解，学完就能上手做数据分析了！＜实战教程系列＞ - P8：8）分组和聚合 - 数据的分析和探索 - ShowMeAI - BV1M64y187bz

大家好，最近怎么样？在这个视频中，我们将学习如何对数据进行分组和聚合。如果你不知道分组和聚合到底是什么，建议你继续观看这个视频，因为基本上。

这是大多数人想到有意义地分析数据时的想法。因此，这将是我们第一次从数据集获取一些统计数据，而不仅仅是以不同的方式修改数据框。

例如，也许你想知道开发者的平均薪资是多少。或者你想知道每个国家有多少人会Python或其他编程语言。我们将在这里学习的内容将帮助我们回答这些类型的问题。现在，我想提到我们这一系列视频有一个赞助商，那就是Brilliant。

我真的想感谢Brilliant赞助这一系列。如果大家能通过下面描述部分的链接查看他们并支持赞助商，那将非常棒。我稍后会更多地谈谈他们的服务。那么，既然这样，我们就开始吧。在开始进行一些更高级的数据分析之前。😊

我们将慢慢开始，然后逐步进入更高级的内容，以确保这一切都是有意义的。我这里打开了我们在整个系列中使用的开发者调查数据。如往常一样，如果你想跟着做，我在下面的描述部分中提供了代码和数据的链接。让我们看看一些基本的聚合。如果你不知道聚合的意思，基本上。

这意味着我们将把多个数据片段合并为一个结果。例如，如果你曾经在数学中使用过平均数、中位数或众数，这些都是聚合函数，因为它们取多个值并给出这些结果的平均数、中位数或众数。因此，如果我们想对这次开发者调查进行一些分析，我们可能会问的问题是。

好吧，回答这个调查的开发者的典型薪资是多少？如果你正在找工作并想了解目前的薪资情况，这可能是一些很好的信息。因此，为此，我们可以获取数据框中的平均薪资。首先，让我们看看这些薪资。在这个数据框中的薪资列叫做转换薪资。

这转换为美元。实际上在调查中还有进一步的信息。就在这里。所以我会复制它。首先，让我们看看这一列。正如我们之前看到的，我们可以像访问字典的键一样访问这一列。我将抓取前15个薪资。

所以我将查看结果的前几行。这些是开发人员在这次调查中填写的工资，而这些N N值在这个上下文中意味着非数字，表示他们在调查中跳过了那个问题。好的，所以我们可以看到这次调查的中位数工资。

只需在这个序列上运行中位数方法。因此，接下来我将复制我在这里的内容。现在，不再查看头部，我可以直接在那个序列上运行中位数。所以如果我运行这个，我们可以看到这次调查的中位数工资大约为57000。

所以这取自我们调查中这个序列的所有工资响应。它给我们提供了所有这些的中位数值，并忽略了N N值。因此，这可能没有提供我们真正想要的信息。例如，不同国家的薪资不同，因为生活成本和其他因素各不相同。

因此，如果我们能查看按国家划分的中位数工资就好了。当我们学习分组数据时，我们将稍后查看这一点。所以首先，我想在继续分组之前再讲几个基本概念。我想查看的是对整个数据框运行这些聚合函数。

😊，让我们看看如果对整个数据框运行我们刚才运行的中位数函数会得到什么。所以这里我只是说Df do median。我们不再仅仅访问单一列。如果我运行这个，可能需要一点时间来加载。当我这样做时，它会查找我们的数据框，并找到包含数值的列，以便可以获取中位数值，其中一些可能不适合用中位数，但其他的可能对我们很有用。

例如，我们可以看到这次调查的中位数年龄在底部为29岁，而每周的中位工作小时数为40小时，这很标准。所以这很合理。现在，如果你想对你的数据进行广泛的统计概述，我们可以使用describe方法，而不是对我们的数据框运行。于是，我如果改为运行describe。

而不是中位数。我运行这个，这将为我们提供一些不同统计数据的概述。所以如果我们查看这里转换的补偿列，我们可以看到一些关于这一列的不同统计数据。它给我们提供了计数、均值、标准差、最小值，以及25%、50%和75%分位数。

现在，这个50%的标记只是中位数值。就像我们之前看到的，当我们具体查找这个中位数值时，大约是57000。这里是科学记数法，所以看起来有点不同。基本上，这意味着我们只需从小数点向右移动4个位置。所以1、2、3、4。

所以这里会是57000。因此，这个描述方法会在一个地方给我们提供一堆聚合数据。如果我们只想快速浏览我们的数据。现在，如果你在想，为什么我想查看薪资的中位数而不是平均数，其实是因为平均数会受到异常值的影响太大。

这并不是一个好的指标，因为少数异常值可以极大地影响平均数。我们可以看到上面的平均薪资，如果我强调这一点。如果我们要计算这个，那么实际上大约是127000的平均值，但这给我们一个不切实际的期望，关于典型开发者的薪资，因为数据集中的最高薪资将平均值拉得太高。

所以在这种情况下，你肯定想使用中位数，我认为那是更好的表示，抱歉，你会想使用中位数，因为那是更好的表示。现在，如果我们只想获得单列的概述，我们也可以在单列上运行这个描述方法，并得到相应的结果。

现在，你可能在想，这些描述结果顶部列出的计数值是什么。计数值是非缺失行的数量，这基本上意味着它计算了非缺失行。因此，在这次调查的上下文中，缺失行仅意味着受访者没有回答特定问题。

如果我查看转换的comp列的计数。我将会上去抓取这个。而不是抓取中位数，我只是要抓取计数。我们可以看到，只有大约55000到65000人回答了这个问题。现在，我想这个数据大约有89000行，这意味着大约有30000人没有回答这次调查的薪资问题。

现在，我有时会看到一些人犯错，他们认为计数函数会计算特定行中的个别值，并报告这些值在列中有多少个。但是如果这就是你想做的，那么我们应该使用值计数函数。

现在，如果这听起来有点不太明白。我们来看一个例子，看看这是什么样子的。例如，我们在调查中有一个问题，问每个人是否在空闲时间把编码当作爱好。为了查看这个问题的所有回答，我们可以查看爱好者列。所以我会访问这个爱好者列并运行它。

我们可以看到这里返回了一系列数据。这些只是一些是或否的问题。每个人都回答了一个是或否的问题。因此，当你可能收到调查结果时，你可能会想，好吧，我可以在调查中看到响应，但我只想知道有多少人回答了是，有多少人回答了不。那么我们该如何做到呢？我们可以通过值计数函数获得这些信息。所以如果我只看值计数，那就是value underscore counts。如果我们对那个系列运行这个方法，那么这将给我们一个回答人数的细分。

是的，还有多少人回答了不，是否将编码作为一种爱好。因此，我在探索数据时总是使用值计数。通过对一些不同的字段使用这个，我们可以从我们的调查中发现一些有趣的事情。例如，这个调查中有一个问题。😊。

询问每个人最常使用哪个社交媒体平台。因此，如果你在构建一个应用程序或网站并想跟踪最受欢迎的社交媒体网站，那么你可能会对这个问题的最受欢迎答案感兴趣。为了查看这些结果，我们可以访问调查的社交媒体列。所以让我这样做。在我对这个运行值计数之前。

让我给你展示一下这个列是什么样的。因此，这一列叫做社交媒体，所以我将运行这个。我们可以看到，受访者编号一说他们使用Twitter比其他任何社交媒体更多，这个人还使用了Instagram、Reddit、Facebook、YouTube等等。到目前为止，我在之前的视频中提到过这一点。

但如果你忘了，或者这是你第一次观看这个系列的视频，那么在我的笔记本顶部，我也在这里加载了一个模式数据框。这个数据框告诉我们每个列名在调查中提出的确切问题。例如，如果我们想看到这个社交媒体列所提问的确切问题。

然后我可以直接访问那个模式数据框并进行点选择，因为索引将是列名。然后我们可以搜索社交媒体，如果我运行这个，我们可以看到调查中他们具体问的问题是你最常使用哪个社交媒体网站，因此我们可以看到这里有几个不同的回答，但这些中哪个是最受欢迎的呢？所以要找出这个。

让我们看看这个系列的值计数，以了解这些开发者的总体最受欢迎社交媒体网站是什么。因此，我将运行这个，然后在这里运行值计数函数。现在我们可以看到，Reddit在顶部是最受欢迎的，大约有14000人，然后我们有。

YouTube、Whatsapp、Facebook、Twitter、Instagram，我不使用社交媒体是其中一个答案。我们还有一些外国社交网络在这里。我从未听说过这些，但我相信这些是中文字符。所以这可能是一个中国社交媒体网站。我对俄文不太了解，但我猜这可能是俄文。

这可能是一个俄罗斯社交媒体网站。看到来自世界各地的这些不同答案真有趣。还有一个小提示，如果我们想看到按百分比划分的结果，而不是原始数字，我们可以将归一化参数传递给值计数函数，并将其设置为true。让我给你展示这是什么样子。所以我可以说normalizedize等于true。

现在我们将按百分比进行划分。所以17%的人说他们使用Reddit，16%说YouTube，约16%说Whatsapp，等等。好的，所以我们可以看到这里有一些来自其他国家的社交媒体网站。这显然可能是地区性的问题。我猜社交媒体平台的受欢迎程度。

这因国家而异。那么我们如何拆分这些结果，以便看到每个国家最受欢迎的社交媒体网站呢？为此，我们需要学习如何对数据进行分组。所以这又是一个初看可能会让人困惑的话题。让我慢慢开始，以便我们确切了解这里发生了什么。首先。

如果我们想看到基于国家或其他某一列的特定结果，那么我们需要在那个特定列上进行分组。我们有用于此的group by函数。那么，使用group by函数实际上意味着什么呢？在pandas文档中，它说分组操作涉及某种组合。

拆分对象、应用函数和组合结果。所以我将尝试逐一讲解每个过程，以便我们确切了解这是如何工作的。所以在pandas文档中，它说分组操作涉及某种组合，拆分对象、应用函数，然后组合这些结果。让我们逐一进行。首先，作为参考。

让我们显示每个国家的值计数，以便看到在这次特定调查中结果最多的国家。为此，我们只需访问国家列。如果我运行这个，我们可以看到每个受访者所说的国家。

如果我们查看这个的值计数，这将汇总所有独特的响应，因此我们可以看到大多数调查是由美国的开发人员回答的。其次是印度，然后是德国、英国、加拿大等。好的。

现在让我们看看如何在我们的国家列上使用分组函数。所以首先，我们将拆分对象，然后应用一个函数。然后它将组合这些结果。所以首先，让我们看看拆分对象。在这种情况下，我们想按国家分组所有结果。所以为此。

我们可以简单地说DF.group_by。然后我们将传入。这将是我们想要分组的列的列表。我将只传入一个列，这里是国家。如果我运行这个，那么我们返回的是这个数据框的分组对象。

那么这个对象是什么，我们到底可以对其做什么？所以首先，让我们稍微解释一下这是什么。这个对象包含一堆组。为了更好地理解这是什么，让我们看一下这个数据框的一个单独组。在我们这样做之前，我将把它设置为一个变量，以便我们可以重用它，而不必反复输入代码，同时它也更容易阅读。

我将这个称为国家组，我将其设置为这个DF.do_group_by，现在不必每次都输入这个，我们可以只引用这个国家组变量。那么现在让我们看看这些组中的一个。由于我们按国家分组了我们的行，所以我们可以通过国家名称抓取特定组。

所以我会获取美国的组。为此，我们可以说国家组做git_group，然后传入组的名称，在这种情况下，我想获取美国的组。如果我运行这个单元，哎，这告诉我国家组没有定义。

这是因为我在设置变量后没有重新运行上面的这个单元。所以如果我运行这个并获取美国的组，然后我们可以看到这里返回了一个包含一些调查结果的数据框。所以这看起来似乎没什么特别的。但是如果我查看每个调查结果的国家名称。

国家就在这里列出。那么我们可以看到所有这些回应都是来自声称他们来自美国的人。如果我查看印度的组。如果我把美国换成印度并获取那个组。

如果我们查看这里的国家，那么这些都是声称他们来自印度的人的调查结果。所以这就是我们之前看到的数据框分组对象的组成。它已将所有不同的回应按国家名称分成了组。因此这类似于在我们的原始数据框上运行过滤器。

所以我应该能够获得这些相同的结果，对于单个国家，只需按照我们在之前视频中看到的做并创建一个过滤器。所以我可以说，好的。我想抓取。我希望我们的过滤器等于国家等于美国时。然后我可以通过说，好的，将其应用于我们的数据框。

数据框调用Lo并给我所有符合该过滤器的结果。如果我运行这个单元，那么我们可以在国家列中看到所有这些结果都是来自美国的响应者。所以如果我们只是想获取单个国家的信息，那么这与我们在这里创建一个过滤器非常相似。

但不是仅仅获取一个国家的结果。按组分组会将所有这些响应按国家名称拆分。所以现在我们已经将所有这些按国家名称拆分和分组。现在我们可以应用一个函数，并将这些结果合并在一起。

那么我们想应用什么样的函数呢？正如我之前提到的，也许我们想看看按国家划分的最受欢迎的社交媒体网站。现在，如果你只是想获取美国或印度最受欢迎的社交媒体网站，那么我们已经看到过如何做到这一点。所以在这里我有一些过滤后的结果，涉及到美国的响应。

因此我们可以做我们之前做的事情，即在社交媒体列上运行值计数方法。所以我可以在这里说，在最后。我可以访问那个过滤后的数据框的社交媒体列。然后我可以运行值计数。在这里。所以如果我运行这个，那么我们可以看到对于美国，Reddit、Twitter、Facebook和YouTube是四大社交媒体网站。

如果我们想具体查看印度的情况，那么我可以将过滤器更改为印度，然后运行这个，我们可以看到Whatsapp排在第一，接着是YouTube，LinkedIn和Facebook。所以这是针对一个特定国家的结果。

但是如果我们在数据框上按对象进行分组，那么它会给我们所有这些国家组的结果。所以如果这有助于你理解，可以想象这类似于运行一个过滤器，然后应用一个函数，就像我们在这里对一个国家所做的那样。

但是当我们使用分组功能将这些数据分组，然后应用一个函数时，它会将这些组合并，以便给我们所有独特国家的结果。所以我认为一旦我们在这里看到这一点就会明白。所以记得我在这里调用了我们的组。

国家组，所以如果我们到这里底部，我们可以说，好吧，对于国家组。现在我想查看社交媒体列，并获取该列在整个国家组的值计数。所以如果我运行这个，那么返回的是一个系列，按国家划分的最受欢迎社交媒体网站。

现在，这实际上在这里提前截断了一点。所以让我获取这个系列更大的一部分，以便更好地了解它的样子。所以在这里的结尾，我就说.dothead，看看前50个结果左右。所以如果我们运行这个，那么我们可以看到，第一个国家是阿富汗。我们可以查看那里的最受欢迎社交媒体，然后继续往下列表，阿尔巴尼亚。

阿尔及利亚、阿根廷等等。现在这实际上是返回一个系列，而这个系列有多个索引。它有国家索引和社交媒体索引。现在我们还没有讨论这个系列中的多个索引。但是如果有人对这如何运作感到好奇，或许可以在下面的描述部分留言。

也许我们可以在未来的视频中讨论这个话题。但国家是第一个索引。我们可以像处理任何其他系列一样获取这些数据。所以，如果我想获取印度最受欢迎的社交媒体网站，那么我可以直接来到这里，使用那个返回的系列。

让我们再看一下。这是这里的索引。我可以通过说点点Lo来获取这个系列，然后查找印度。我们可以看到这些结果和之前得到的是一样的。现在，你可能会想，嗯，如果这些结果和我之前得到的是一样的，那这还有什么用呢。

这很有用，因为现在我们可以查看任何国家的结果，而不需要对世界上每个国家单独运行过滤器。所以，例如，如果我想查看美国最受欢迎的社交媒体网站，那么现在，除了不断更改过滤器，我可以直接查看这个返回系列的美国索引。

现在我们可以看到这些结果。所以我觉得能够像这样玩弄数据并进行探索真的很有趣。我非常喜欢看到不同国家的不同结果，而这些网站中有很多我从未听说过。所以例如，如果我们查看中国或俄罗斯最受欢迎的社交媒体网站。

那让我在这里看看中国。我们可以看到，这确实看起来像是一个中国社交媒体网站，可能是微信，然后我猜这个发音是微博，但我觉得这非常有趣。如果我们想看看俄罗斯，那么在这个调查中我们不能仅仅说俄罗斯，俄罗斯被称为俄罗斯联邦。我之前犯过这样的错误，只输入俄罗斯，它会告诉你找不到这个名称的索引，所以实际上是俄罗斯联邦。如果我们搜索这个，那么我们可以看到我不知道该怎么发音，但我之前认为是俄文的那个，确实看起来是俄文。请记住，如果你觉得查看百分比比单纯的原始数字更有意义，你总是可以将normalizedize设置为true，这样它会给你百分比结果，而不是原始数字。

我们可以看到这个俄罗斯社交媒体网站有30%的人表示这是他们最受欢迎的社交网络。如果我们回到中国，我们可以看到顶部的这个，有67%的开发者表示这是他们使用最多的社交媒体网站。所以我觉得能玩弄这些数字，看到不同国家的不同结果真的很有趣。

一旦掌握了这些技能，我们就可以做这样的事情。在很多时候，能够以这种方式探索数据本身就是一种乐趣，并发现数据中可能未曾预料到的东西。现在回到视频开始时讨论的内容，我们也可以用它来运行更传统的汇总函数，如均值、中位数等。

所以前面我们查看了整个调查的中位数工资。但现在让我们将其拆分。😊因此，就像我们查看社交媒体列的值计数一样，我们可以查看工资列的中位数，该工资列标记为转换的补偿。

所以要做到这一点，我可以直接抓取我们国家组的数据。我们想查看这个转换的补偿列，现在我们需要告诉它我们想看到什么汇总函数。我想查看所有国家的中位数工资。如果我运行这个，我们可以看到结果显示正常。

这是阿富汗的中位数工资，这是阿尔巴尼亚的，依此类推。所以如果你想看到像德国这样的地方的中位数工资，我们可以简单地查看这里。这就是我们得到的结果，这些是我们的索引。索引是国家名称。如果我想获取特定国家的数据，我可以使用点符号，输入国家名称。

如果我运行这个，我们可以看到德国的中位数工资大约为63000。现在，或许你正在进行一些分析，想要对数据进行分组，同时想在你的组上运行多个汇总函数。假设我们不仅想看到中位数，还想看到均值。

所以要做到这一点，我们可以使用 ag 方法 A G G，并传入我们想要使用的所有汇总函数。为了做到这一点，我可以说，让我抓取我们运行中位数的地方。我们将使用这个 ag 方法，而不是仅仅运行中位数汇总函数。现在我们将传入一个汇总函数的列表。

假设我想先获取中位数，然后我也想能够看到平均数。如果我们运行这个。然后我们可以看到得到一个包含每个国家的平均和中位数工资的数据框。再次，如我们之前所做的那样。如果我想按特定国家缩小范围，那么我们只需通过国家名称获取这些索引之一即可。

如果我们想查看加拿大的平均和中位数工资。那么我可以直接在这里输入dot Lo，然后传入加拿大。让我拼写正确。现在我们可以看到加拿大的中位数工资和平均工资。根据你的需求，你可能会遇到一些意想不到的问题。

举个例子，假设你想知道每个国家有多少人会使用Python。在我们对组进行此操作之前，先看看我们如何使用之前使用的过滤方法来处理一个国家。

我要滚动到我们有那个过滤器的地方。然后我将复制并粘贴到这里。然后我将删除这个值计数部分。因此，目前我们这里的过滤器是我们将国家过滤到自称来自印度的人。

现在，为了弄清楚在这项调查中有多少人表示知道Python。我们将使用之前视频中见过的字符串方法。如果你不记得这些是什么样的。那么我们可以这样做。通过做这样的事情，我们可以说，好吧，我想要所有表示来自印度的人的回应。

现在，当我得到这个结果时，请记住，这个结果只是我们数据框的一个过滤版本。我们的原始数据框，现在我们可以说，好吧，我还想要。使用的语言是他们实际使用的不同语言。因此，如果我们查看这个语言工作列。

然后我们可以看到他们列出所有自称会的语言，以检查Python是否在这一列中，然后我可以说dot STR并在返回的系列上使用字符串类，表示。好吧，我们想要STR.dot包含Python的地方。因此，这将为包含Python的行返回true，而对不包含的回应返回false。所以如果我运行这个。

然后，这将返回一系列真假值，告诉我们每个受访者在语言工作列中是否包含那串Python字符串。现在，如果我们想实际计算知道Python的人数。那么我们可以使用sum函数将这些值相加。通常，你会认为sum只适用于数值数据，但它也适用于布尔值。

它将把所有的真值计为 1，把所有的假值计为 0。所以要找出多少人知道 Python，我只需在最后做一个 dot sum。如果我运行这个，那么我们可以看到大约 3100 名来自印度的调查者表示，他们知道 Python 是他们使用的语言之一。现在，在我们想要对数据框组对象运行类似的聚合函数之前。

我们对组对象采取了相同的方法。所以例如，你可能会认为我们可以这样做，看看有多少人来自每个国家知道 Python。你可能会认为我们可以说，好吧，我应该能做到这一点。我可以说，对于这个国家组。

我想查看这个语言工作的列，然后查看包含 Python 的字符串并将其相加。但是如果我在这里运行这个，我们可以看到出现了一个错误。正如我在之前的视频中所说，有时阅读这些 Pandas 错误并理解我们做错了什么可能很困难。但在这种情况下，它实际上给了我们一个相当不错的线索，说明我们做错了什么。

它告诉我们，无法访问系列组对象的字符串属性。然后它说，尝试使用 apply 方法。因此，我们在这里得到这个错误的原因是，因为这不再只是一个系列，而是一个系列组对象。它告诉我们改用 apply 方法。所以当我们对像这样的组对象运行 apply 方法时。

我们将指定一个函数，在这个组中的每个系列上运行。我知道这可能听起来有点困惑，所以让我们看看这是什么样子。希望这能稍微清晰一些。所以，不是直接访问这里的字符串类，而是使用 apply 方法。对于任何跟随的或将要下载这个的人。

我将继续保留这个单元格中的错误，以便你可以运行它并重现该错误。然后我将在这个单元格中做正确的方式。所以再次强调，不是直接在这个系列组对象上使用字符串类，而是使用 apply 方法。所以让我把它剪切掉，然后我会说点 apply。

现在我们可以应用一个我们想在这个组中的每个系列上运行的函数。如果你看过之前的视频，你会知道如果我们只想要一个简单快捷的函数，我们可以使用 lambda 函数。如果你愿意，可以写另一个单独的函数。但在这里我将使用 lambda。所以这里的 lambda 是。😊，一个系列。所以现在我们可以说。

好吧，我们想要返回什么？好的，我想返回 X，然后。由于这是一个系列，我们可以说 x.dot.string.dot.contains Python.dot.sum。所以再次强调，就再来一次，我们正在对这个系列组运行 apply 方法，然后传递一个将在这些系列上运行的函数。

我们想要的函数或返回的内容是该系列中包含字符串Python的值的总和，这将在我们使用这个国家分组时为每个国家执行此操作。所以如果我运行这个。

那么我们可以看到，在阿富汗，8名受访者表示他们会使用Python，阿尔巴尼亚则有23名，等等。现在，仅仅看到这些数字并没有太大的帮助，因为我们想了解每个国家声称会使用Python的人的百分比，单靠这些结果，我们只能看到一个数字，我们需要来回比较。

每个国家的调查有多少人回答，以及其中有多少人会使用Python。然后我们可以从那里计算出这个国家中会使用Python的人的百分比。但我们不想手动计算，这样太繁琐了。所以我们想找到一种方法，让Python和pandas为我们完成这个计算。

现在，很多人都让我整理一些编程问题，以便练习我们在这些视频中学到的内容。所以你可以把这个当作练习。所以我将在这里进行尝试。那么，你们中有没有人想过一个方法，我们可以算出每个国家中会使用Python的人所占的百分比？如果你认为你能找出这个问题，可以在这里暂停视频，自己试着解决。

而且这将结合我们在这一系列课程中讨论的一些主题来完成这个任务。话虽如此，我将继续我的解决方案。所以如果你想自己试着找出这个问题，可以暂停视频，试着自己解决。如果你这样做了。

然后我希望你能够在这里找到一些解决方案。但如果没有，那也没关系，让我们继续来看看我的解决方案，这样你可以用它作为练习，提升自己在pandas方面的技能，以便将来能够进行这种类型的分析。

正如我所说，为了计算每个国家会使用Python的开发者百分比，我们将结合我们在这一系列课程中学到的一些不同的知识。现在，回答这个问题可能有几种不同的方法。如果你有不同的解答方法，欢迎分享。

如果你找到了方法，请在下面的描述区留言，让大家可以看到不同的方法。你知道，绝对有可能有比我接下来要做的更有效的方式。如果有的话，我会强调一下，这样其他人也能看到最佳方法。但是我打算这样做。首先，我将获取每个国家的总受访者人数。

这样我们就知道每个国家回应这项调查的人数总和。所以我将称之为国家回应者，并将其设置为。我们想要获取这里国家的值计数。所以。如果我打印出我们得到的结果。我们之前见过这个。哎呀，我在这里出错了，因为我写成了县。

我把它改回国家。所以如果我看看这个。那么这些是说他们来自每个国家的总回应者人数。我们在视频中也看到过这个。所以现在我将获取每个国家知道 Python 的总人数。

我们刚才就在这里做过这个。但我会继续这样做，并将其设置为变量，以便我们记录所有这些步骤。所以我将抓取。我们刚刚计算出的所有内容。现在我将把这个设置为一个变量。我将称之为，你知道的。国家使用 Python。然后我将把它设为等于这个。现在。

让我们也打印出那个变量。所以让我在下一行进行，这让我电脑。有点让我烦恼。好的，这些是来自每个国家的所有人，他们说他们知道如何使用 Python。所以现在我们有一个变量是一个系列，包含来自每个国家的总人数，称为国家回应者。然后我们还有另一个变量是一个系列。

这是来自每个国家的知道 Python 的总人数。所以现在我们需要将这两个结合起来。现在，我实际上将使用一个在这个系列中还未讨论过的方法。所以如果你在这里卡住了，那是完全可以理解的。我可能应该在我们将行附加到数据框的那段视频中提到这个。

但是我们可以使用 pandas 的 concat 函数将多个系列组合在一起。所以让我们看看这会是什么样子。我可以说，我就叫这个数据框 Python Df。现在我要创建一个数据框，我们可以将这两个系列连接在一起。所以我可以说 P D.dot concat。现在我要传入一个我们想要拼接的系列列表。

所以我希望这些是我们国家的回应者。而且我还想。加入这个国家使用 Python 的系列，现在。我们还想将轴设置为列，因为默认情况下。它会尝试在行上进行拼接，但我们希望将索引匹配，这样才能以那种方式进行拼接。所以我们想说轴等于列，然后最后。

我还将设置 sort 等于 false。现在，如果你观看了之前的视频。这不是绝对必要的，但如果你在没有设置 sort 等于 false 的情况下运行它。它会给你一个警告，告诉你在未来版本的 pandas 中。它会默认排序或默认不排序。

所以最好直接指定你是否希望结果数据框排序。现在让我们看看这个连接的数据框。好的，现在我们有一个数据框，其中这两个系列已被连接，并在相同的索引上匹配。这更有用，因为现在我们可以看到，大约有20000或21000。

1000名声称来自美国的人和大约10000名声称知道Python的人，所以这肯定是更好和更有用的信息。现在关于这个新数据框的一件事是，有些列与我们正在讨论的内容并没有真正的关系。我们可以看到这个叫做国家，而这个叫做使用的语言，所以让我们重命名这些，使它们在我们实际尝试做的上下文中更有意义，我们也看到如何在之前的视频中重命名列。

但是如果你忘记了，那么你可以通过抓取我们的数据框来做到这一点，我会说Python Df，也就是我们的数据框.dot rename，现在我们想要重命名什么呢？我们想要重命名列，我将传入一个字典。

关键在于之前的值，而这个值将是更新后的值。所以我将其称为回应者数量。然后我还想更改这个“使用的语言”列。我想把它改成，我们称之为知道Python的人数。如果我运行这个，我们可以看到这看起来不错。我们有来自美国的回应者数量和知道Python的数量。

所以这看起来不错。由于它看起来不错，我将说in place等于true，这样它实际会修改我们的数据框。如果我运行这个，然后再查看我们的数据框，那么😊，我们可以看到它已用这些新列更新。现在我们有来自每个国家的回应者总数，以及每个国家知道Python的人数，所有这些都在一个数据框中。

所以我们有计算百分比所需的所有信息。现在我们所需的就是创建一个新列并进行计算。所以如果你还记得，为了创建一个新列，我们可以简单地赋值。所以我将这个列称为PCt，用于表示知道Python的百分比。

现在我们想要这个等于什么呢？好吧，如果你不知道如何用数学计算百分比，基本上你需要先取出部分，然后用它除以整体，再乘以100。所以这里的部分是知道Python的人数。

所以我会抓取这个，叫做on underscore DF，并访问那个系列，访问那个列。然后我想用这个部分除以整体，而整体是来自那个国家的总人数，也就是回应者数量。现在，如果我们想要这个是一个整数百分比，那么我们可以乘以100。好的，如果我做了所有这些正确的话。

而且很有可能我犯了一个错误。但如果我正确地完成了所有这些，那么我们应该在这里有一个数据框，显示每个国家知道 Python 的人所占的百分比。现在我们可以像处理任何其他数据框一样处理这个数据框。所以假设我们想要对这些结果进行排序。

现在我们在之前的视频中学习了如何对系列中的值进行排序。所以假设我们想按照知道 Python 的受访者所占的最大百分比来排序各个国家。为此，我可以简单地说 Python D F.t sort.Underscore values。如果你忘记了如何做这些事情，那么你可以随时回到我们的 pandas 视频，那里我们学习了排序。

所以为了按照知道 Python 的人或其百分比进行排序，我们可以说，好吧，按什么排序。我在这里称之为“知道 Python 的百分比”。然后我实际上希望这以升序排列。Order 等于 false，因为我希望知道 Python 的人所占的最大百分比排在最上面。然后我本来打算先将 in place 设置为 true。但让我们看看这是什么样子。好的。

所以看起来那个排序有效，并且效果不错。所以现在我会说 in place 等于 true，这样它就会修改我们的数据框。现在我们可以在这里查看我们的结果。因此我们可以看到这里的一些数据有点误导，因为你知道。来自圣多美和普林西比的 100% 的人不懂 Python。

但我们只有一个来自这个国家的人回答了调查。而他恰好知道 Python，或者她。因此这是 100%。所以相反，让我们看看头部，并抓取。看看我们能否找到一个受访者数量更多的国家。所以，好吧。我们有 72 名来自乌干达的人，其中 47 名知道 Python。所以这是 65%。这相当不错。

我们有哦，好的，这是美国，情况也不错。这里大约有 21000 人，大约有 10000 新的 Python 使用者。所以这是 48%。所以这在较高的范围内，这很好。所以，是的。我认为这是练习使用 pandas 的好方法。而且，能够以这种方式探索你的信息也很有趣。

现在我们有一个包含所有这些信息的数据框。然后我们还可以检查特定国家，以查看来自特定国家的开发者中知道 Python 的百分比。所以，举个例子，我想查看日本，而不是逐一查看所有这些。我可以简单地说，好吧，Python.😊，D F dot Lo。

由于我们的国家名称是这里的索引，所以我们可以简单地对日本使用 dot Lo，然后我们可以看到我们得到了该特定国家的统计数据。好的。所以我知道这可能有很多内容需要消化，并且我们在这个视频中覆盖了很多内容。我们确实涵盖了一些比之前视频更高级的主题。

不过，我希望这能让你对使用pandas所能做的事情感到兴奋，以及我们可以解决的问题类型。你知道，当你像这样探索数据时，你可能会在过程中犯很多错误。

我在使用pandas时仍然会犯错误，甚至在这些视频中，我也犯了一些错误。而且这些都是我事先准备好的。所以这确实会发生。但是你知道，每一个我们解决的问题类似于这个，都让后续处理其他问题变得越来越容易。

所以如果你需要回去重看这些步骤，以便自己解决这些问题，那是完全正常的。😊，不要觉得如果这似乎很困难，那就是你有什么问题。

这类信息确实很多，理解起来很正常。而且，正如我之前所说，如果你有其他解决我们在这里回答的问题的方法，那么请在下面的描述部分留言分享你的解决方案，我会看一下这些方案，如果它们比我在这里的做法更好，我会特别提及。

好的，在我们结束之前，我想提一下本视频的赞助商。那就是Brilliant。在这个系列中，我们学习了关于pandas以及如何使用Python分析数据，Brilliant将是一个很好的补充，提供动手实践的课程，他们有一些优秀的课程和课程内容，深入探讨如何正确思考和分析数据。

对于数据分析基础，我强烈推荐查看他们的统计课程，它教你如何分析图表并确定数据的显著性。我还推荐他们的机器学习课程，它涉及数据分析。

提升到一个新层次，你将学习到如何让机器在变量过多的情况下做出决策的技术。为了支持我的频道并了解更多关于Brilliant的信息，你可以去brilliantg cs注册免费账户，前200位访问该链接的人将获得年度高级订阅20%的折扣。你可以在下面的描述部分找到这个链接。

所以我认为这就是我们本次关于pandas视频的全部内容，希望你对如何使用这些聚合函数以及如何对数据进行分组以探索数据有了良好的理解。我真的鼓励你在观看完这个视频后花点时间玩玩数据，看看能否回答某些人可能对这些数据提出的问题。

例如，对于回答这项调查的人，最常见的教育水平是什么，这绝对是我们可以通过这里学到的知识来回答的问题。😊 我希望你感觉自己对回答这类问题有了很好的介绍。

在下一个视频中，我们将学习如何处理缺失数据以及如何清理数据。数据中缺失值是非常常见的，因此了解如何清理和整理我们的数据绝对很重要。如果有人对我们在这个视频中讨论的内容有任何问题，请随时在下面的评论区提问，我会尽力回答。

如果你喜欢这些教程并想支持它们，有几种方法可以做到。最简单的方法就是点赞视频并给予好评。此外，与任何你认为会觉得有用的人分享这些视频也是一个很大的帮助。如果你有能力的话，可以通过Patreon进行支持。

下面的描述部分有一个链接指向该页面。请确保订阅你未来的视频，感谢大家的观看。😊！

用 Pandas 进行数据处理与分析！真实数据&实时讲解，学完就能上手做数据分析了！＜实战教程系列＞ - P9：9）数据清洗 - 转换数据类型和处理缺失值 - ShowMeAI - BV1M64y187bz

大家好，你们过得怎么样？在这个视频中，我们将学习如何处理缺失值，以及如何稍微清理一下我们的数据。几乎每一个你要处理的数据集都有可能包含一些缺失数据，或者是我们希望清理或转换为不同数据类型的数据。因此，我们将在这里学习如何做到这一切。现在，视频接近尾声时。

我们将结合在这里学到的内容，能够查看我们的 Stack Overflow 调查数据，并计算回答调查的开发者的平均工作年限。所以一定要保持关注，这将是对我们在这里所学内容的极佳实践。现在，我想提到的是，我们确实有这系列视频的赞助商。

这真是太棒了。因此，我非常感谢 Brilliant 赞助了这个系列。如果你们能通过下面描述部分的链接去了解他们，那将是极好的，并支持我们的赞助商。我会在稍后详细谈谈他们的服务。那么，就让我们开始吧。好的，首先，让我们谈谈如何删除缺失值。

我这里打开了我的代码片段文件，我们在之前的视频中看到过这个。如果有人想跟着一起做。😊，我会在下面的描述部分提供所有这些笔记本和数据的链接。正如我们在之前的视频中看到的，我们将首先在较小的代码片段数据框中学习如何做其中的一些操作，然后再看看如何在更大的 Stack Overflow 数据集上做一些有趣的事情，以便在一些真实世界的数据上进行工作。

在这个视频中，我在我们的代码片段数据框中添加了一些之前没有的空值。我添加了一些额外的名字，我们可以看到我这里只有一个是 nu do N，也就是不是数字的值。我在顶部也导入了 nu，这里只是一个 nu 值。我还添加了一些自定义缺失值。

这个只是一个 NA 字符串，而这个只是一个缺失的字符串。因此，我在数据中随意放了一些 N、一些 nuns 等等，以便我们有一些缺失值。所以你会看到，当我们使用 pandas 时，这种情况会经常出现。😊我们会有一些缺失数据，具体取决于你想做什么。

你可能想用不同的方法处理缺失数据。所以，你可能想做的一件事就是简单地删除它。对于我们这里的小数据框来说，假设我们要对数据框中的这些人进行一些分析，但如果他们没有名字、姓氏和电子邮件地址，那么我们就无法进行所需的操作。因此，我们将删除那些缺少这些值的行。为了做到这一点，我们可以使用drop方法。

所以让我们这样做，然后我会解释结果并讨论这些。因此，我在这里对我的数据框所做的只是说Df drop in a，我们现在将不带任何参数运行它。因此，当我们运行时，我们可以看到现在我们只得到四行数据，而在上面我们有45行。

所以我们得到了这四行，因为它们没有缺失值。现在我们底部的这一行仍然存在，这里有一些自定义缺失值。但我们将看看如何处理这些。不过现在，让我们讨论一下drop in a实际上在这里做了什么。

这里的背景是drop in a正在使用一些默认参数。所以我将手动填写这些默认参数。这样可能会更清楚我们为什么得到这个具体的结果。因此默认情况下，我将留那个参数在这里。现在我再次填写drop in a。

但我将放入它已经拥有的默认参数。这个在后台的默认参数是它将轴设置为索引，并将how变量设置为任何。所以由于这正是该方法默认使用的，我们应该得到相同的结果，我们可以看到确实如此。

我们得到的结果与我们在上面运行时是一样的。但现在让我解释一下这些参数。首先，我们有轴参数。这个可以设置为索引或列。这将告诉pandas我们希望在行缺失值时丢弃值，当这里设置为索引时。

如果我们将此设置为列，那么如果列中有缺失值，它将会丢弃列。我们马上会讨论这个。现在，第二个参数是我们想如何丢弃这些。或者我想说一个更好的方式是，这是它用来丢弃行或列的标准。因此默认情况下，这被设置为任何。所以我们在查看行，因为这被设置为索引。

这里也被设置为任何。因此它将丢弃任何有缺失值的行。但这可能不是你想要的。也许在我们进行的这种分析中，有缺失的电子邮件或姓氏是可以的。但必须有某些内容。不能整行都是缺失值。

所以如果是这样的话，我们可以将这个how参数改为All。这样只有当该行中的所有值都缺失时，才会丢弃行。因此现在如果我运行这个，我们可以看到我们得到了比之前更多的行，因为它保留了那些有一些缺失值，但不是全部缺失值的行。

所以我们可以看到这里缺失了电子邮件，但还有其他一些列是填好的。我们可以看到这里所有内容都缺失，但他们有电子邮件。因此，所有的值必须缺失，才能真正丢弃它们。因此看起来我们缺失索引4。如果我回到我的原始数据框这里。

我们可以看到索引中有所有缺失值。好的。如果我将这个轴改为列而不是索引，那么它将删除所有缺失值的列。我们没有任何列是完全缺失值的。因此，它应该只返回我们的原始数据框。如果我在这里说列并运行这个。那么我们可以看到。这就是我们得到的，因为这些列没有完全缺失值。现在。如果我将其设置回默认值并删除任何缺失值的列。那么我们实际上会得到一个空的数据框，因为我们有一行是完全空的，这个索引为四。因此对于那一行，每一列至少会有一个缺失值。如果我们将此设置为任何，则任何具有单个缺失值的列都会被删除，而在这种情况下所有列都是这样的。如果我将此改为任何，那么由于其中一行的所有值都是缺失的，这将给我们一个空的数据框。此时你可能会想，好的，我的数据比这复杂一些，我正在进行一些分析，我想删除一些缺失值，但我只想删除在特定列中缺失值的行，所以例如。

假设我们正在对数据进行一些分析，如果他们没有名字或姓氏也没关系，但我们确实需要电子邮件地址。如果他们没有电子邮件地址，那么我们需要删除这些行。为了做到这一点，我们可以传入一个子集参数。所以首先我将我们的访问设置回索引，以便删除行，现在我们想传入一个子集参数，这个子集将是我们检查缺失值的列名。

在这种情况下，它只会是一个单列。因此，我将说子集等于，我仍然会传入一个列表，即使这只是单个列，我会说电子邮件。所以如果我运行这个，我们可以看到返回的数据框充满了至少填入电子邮件地址的行。而且再次提到下面这个带有这些空值的行是我们自定义的缺失值，我会告诉你如何处理这些。

缺失值稍后再讨论。现在，在这种情况下，由于我们只传入一个单列作为我们的子集，我们的如何参数并没有真正发挥作用，因为它只会查看电子邮件地址的缺失值。因此，如果电子邮件地址没有填写，则在此处传入任何或所有参数都会触发该行被移除。所以即使我将其设置为所有，它也应该给我们相同的结果，因为我们只在检查一个值。

但我们也可以将多个列传入我们的子集。那么如果我们说，好吧，为了使我的数据有用，我需要他们的姓氏或电子邮件地址，但不需要两个都提供。那么为了做到这一点，我们可以说，他们需要姓氏和电子邮件的所有值。抱歉，我把这个说反了。

他们不需要姓氏和电子邮件。只是不能所有这些值都缺失。所以只要姓氏或电子邮件存在，就不应该删除那些行。如果我运行这个，那么我们可以看到一些没有电子邮件的值，但它们有姓氏。我们还会得到一些没有姓氏的值。

但确实有一个电子邮件，就像这里的一个非内联元素，它有一个电子邮件。但它没有姓氏。而且，再次说明，这是因为我们在所有参数中传入了how。这意味着要删除一行，两个子集列都需要缺失。现在，正如我们在之前的视频中看到的，这并没有永久改变我们的数据框值。

如果我们想永久改变我们的数据框，那么我们必须添加inplace参数并在这个方法中将其设置为true。但在这一系列中我们已经看过很多次。我觉得在这里不需要再重复。好的，现在让我们来看看这些自定义缺失值。我们可以看到这里有一行包含一些自定义的缺失值。

例如，可能获取我们数据的人不知道如何处理缺失值。所以，他们只是传入了一个字符串“N”或者传入了一个像我们这里的“缺失”字符串。那么我们该如何处理这些呢？这取决于我们如何加载数据。在这种情况下，我们是通过创建一个字典并在这里创建数据框来从头开始创建我们的数据框。

因此，我们可以在这里简单地将这些值替换为NaN值。现在，如果我们从一个CSV文件加载数据，那么我们可以做不同的事情。但首先，我将展示这个，然后在我查看Stack Overflow数据时再看看CSV文件。所以在我们创建数据框的顶部，我将替换这些值。

使用合适的NaN值。因此，为了做到这一点，我将往下走几行，我们在之前的视频中看到过这个，但我们可以在这里使用replace，我将替换整个数据框中的所有值。所以每当我们看到一个“NA”字符串时，我将其替换为NaN，而且我在这里导入了numpy，所以我能够使用numpy，然后我想说inplace等于true，因为我们实际上想要修改那个数据框，所以如果我运行它，那么这将替换那些值，但我还将把这个缺失字符串也替换为NaN值，我也想这样做。

所以我们继续执行这个操作，这应该替换那些值。现在如果我查看我们的数据框，可以看到我们不再有那串缺失或 N 的值。这些现在都是 N N 值。如果我们回过头来，运行删除 N 值的操作。

那么这些自定义值应该被替换，并且它应该将这些视为缺失值。所以在这里，我们可以看到之前的结果，其中自定义值的索引为 6，如果我现在重新运行，我们可以看到它消失了，同样在这里如果我重新运行，那么它也消失了。现在，如果你不想做任何更改，只想查看某些值是否会被视为 NA 值。

然后我们可以运行 NA or is in a 方法，得到一个值的掩码，以判断这些值是否被分类为 NA。让我向你展示我在这里的意思。我可以说 Df dot is NA，这将给我们一个值的掩码，表示它们是否被分类为 N 值。

我们可以看到，row4 这里全是 NA 值，row6 也是如此，我们还可以看到其他一些缺失值。现在，有时特别是处理数值数据时，我们可能想用特定值填充 NA 值。现在我正在处理字符串数据，但有时用特定值填充 NA 值也是有意义的。

例如，假设我们在为作业计算分数，或者类似的事情，而你有一些作业的值为 NA，因为学生从未提交作业。那么在那时你可以决定是否将所有缺失的作业记为零，以便你可以计算总分。因此，要做到这一点，我们可以使用 fill NA 方法，例如我可以这样说，如果我做 Df do fill NA，然后传入一个值。

为了确切展示这在做什么，我将用这个大写的缺失字符串填充我们所有的缺失值。如果我运行这个，那么我们可以看到所有缺失的值，或所有的 N 值都被填充为这个大写的缺失字符串。

如我之前所说，我并不常用某些字符串。我发现这对于数值数据最有用，具体取决于你如何进行计算。但是你可能想给 NA 值一个值，例如 0 或 -1 等。如果这与数据相符，并且你有数值数据，可以用 0 替换缺失值。

然后你可以运行 Df fill in0。如果我继续运行这个，我们可以看到这在我们的数据框中也有效。同样，就像我们之前的方法一样，如果你希望对数据框的更改是永久的，并且能在其他单元格中保留，只需添加 inplace 参数并将其设置为 true，使更改永久化。好的。

现在让我们看看我们可能需要处理的另一件常见事情。那就是转换数据类型。因此我在这里有另一列，这是我在之前视频中没有提到的。如果我们查看，这就是这个年龄列。所以假设我们想要获取这个样本数据框中所有人的平均年龄。

好的，现在这些在我们的数据框中打印出来时可能看起来像数字。实际上它们是字符串。我们可以通过查看数据框的数据类型来验证这一点。要做到这一点，我们可以说 Df 的数据类型（D types）。这不是一个方法，而只是一个属性。所以如果我在这里运行它，我们可以看到所有这些列都是对象。

当它说这是一个对象时，可能意味着它是字符串或不同事物的混合。所以在 Python 或 pandas 的最新版本中，抱歉，它们实际上进行了更新，现在有一个字符串数据类型。但我会在这一系列的最后做一个关于 pandas 版本更新的视频，因为在我编写这门课程时它们实际上发布了那个更新版本。但不用担心，这里学到的内容不会过时，基本上还是大同小异，但我们可以看到我们的年龄列是字符串，因为它是这个对象数据类型。

所以如果我们想要平均年龄，现在这样做是行不通的。那么让我们看看这个错误是什么样子的。我将获取那个年龄列的平均值，如果我运行这个，那么我们可以看到现在我们得到一个错误，如果我向下滚动看看这个错误是什么。

它显示“只能将 STR 连接到字符串，而不是 int”。这可能不是最容易理解的错误，但基本上它告诉我们，因为那一列是字符串而不是整数，所以我们需要将该列转换为数字，而不是字符串。

现在在做这件事时有一个注意事项，这可能会让一些人困惑。所以当我们在尝试将列中的 NAN 值转换为数字时，你需要使用浮点数据类型。这是因为 NAN 值实际上是一个浮点数。让我继续演示一下，以便让你看看这是什么样子的。

我将查找 N dot NA 的类型。我们可以看到这是一个浮点数。如果我们尝试将这一列转换为整数，当遇到 NAN 值时就会抛出错误，因为它无法进行转换。因此，如果我说 Df 的年龄（Of age）等于，然后我们尝试将这些转换为整数。这里转换数据类型的方式是，我们可以简单地说，我想将年龄列的类型设置为。

现在我们想传入我们想要的类型。如果我尝试将这些转换为整数，那么这会给我们一个错误，因为我们有一些naN值。所以我们可以看到，int参数必须是字符串，而不是none类型。因此，当你试图将这些数字转换时，如果有naN值，你基本上有两个选择。如果你的列没有任何缺失值。

这样就可以正常工作。我们甚至不会遇到这个错误。但如果确实有缺失值，你可以将那些缺失值转换为其他值，比如用我们之前看到的feel N方法将其转换为0，或者你也可以直接将该列转换为浮点数。现在，我认为将那些缺失值转换为0或其他数字是个坏主意。

因为我们试图计算这个案例中的平均值。但根据你的数据，这可能正是你想要做的。不过我会继续将这些转换为浮点数。所以那些naN值保持为缺失值。因此，在这里我不再使用nt，而是将其转换为浮点数。如果我运行这个，那么看起来是有效的。

现在我们可以再次查看数据类型。我可以说Df，哎呀，对不起，我在那个单元格里打错了。我可以说Df的dtypes。如果我们查看这个，我们可以看到现在我们的年龄是一个浮点对象。那么让我们看看当我们尝试计算该列的平均值时会发生什么。

所以我会说Df的mean。如果我运行这个，那么我们可以看到我们得到了这些年龄的平均值。现在，如果你有一个包含数字的整个数据框或者类似的东西，想要一次性转换，那么数据框对象也有一个as type方法。所以你可以直接说Df的as type。

然后传入你想要转换为的任何数据类型，并一次性转换数据框中的所有内容。但这里有一些混合列，所以我们不想这么做。好的，我们现在一直在查看我们的小数据集以测试这些内容。但现在让我们把在这里学到的知识应用到现实世界数据上，并对我们的Stack Overflow调查数据进行一些分析，所以首先。

我之前提到过，如果我们有自定义的缺失数据值，那么在加载cv时处理这些会简单一些。我所说的在这里是我们在顶部替换这些自定义缺失值。让我给你展示如何在加载cv时做同样的事情。所以我将切换到我的Stack Overflow调查数据。

让我重新运行这一切，以确保所有这些内容都在正常运行，所以这个笔记本仍在运行，这很好，而且这仍然是我们在整个系列中使用的 Stack Overflow 数据。如果你想跟着操作，我在下面的描述部分有一个下载链接。好的，如果我想在加载 CSV 时忽略这些自定义值。

然后我们可以简单地传入一个我们希望视为缺失的值列表作为参数。那么我们可以这样做。如果在这个 CSV 文件中有一些自定义缺失值，我可以简单地创建一个缺失值的列表，并称之为“缺失值”。然后我将传入这个列表。假设我们有一些值是字符串“Na”和一个表示缺失的字符串。

所以现在我们可以在这里添加一个参数，并说 Na 值等于我们刚刚创建的那个列表。如果我们运行这个，就不应该出现任何错误。当它读取这个 CSV 时，它会将那个值列表视为缺失值，并给出 NaN 结果。现在，在这个调查中。

他们做得很好，没有出现任何奇怪的情况。因此，这实际上不应该改变任何内容。好吧，现在让我们看看一个有趣的问题，即如何转换一些值。假设对于回答了这项调查的开发者，我们想计算他们的平均编程经验年数。

现在了解这一点可能对比较你的经验与平均水平是有帮助的。但让我们看看为什么使用这个数据集来计算可能会比较困难。我们计算这个解决方案实际上会应用到我们在这一系列中学到的几个概念。所以在调查中查看这个问题答案的列称为“编程年限”。

那么让我们看看这些答案。我将查看“编程年限”的前 10 个答案。所以我会使用 .head()，让我们看一下前 10 个结果。如果我运行这个，乍一看，这似乎并不会成为问题。我们只有一堆整数，表示不同受访者编程的年数。所以你可能会认为我们可以简单地通过说“好吧”来获取这一列的均值。

如果我们这里只有一堆整数和一些 NaN 值，那也没问题。让我们直接计算这一列的均值。但如果我运行这个，就会出现错误。如果我向下滚动，这里显示只能将字符串与字符串连接。我们在较小的数据集中也看到了同样的错误，那时列实际上被加载为字符串而不是数值数据。

我们应该知道如何处理这个问题，因为我们在小数据集中已经处理过了。让我们尝试一下。让我们尝试将其转换为浮点数，然后取平均值。所以让我回到顶部。😊而不是在这里运行 mean。我将说，好吧，让我们将其转换为浮点数，以便可以获取平均值。

所以我会说作为类型。我们想将其转换为浮点数，因为有 N N 值。所以如果我运行这个，我们仍然会得到一个错误。所以在我们的小数据集中没有出现错误。如果我向下滚动，它说无法将字符串转换为浮点数。无法转换的字符串是小于一年。

这可能是我们没有预料到的事情。显然，这一列不仅仅有数字和 N N 值。实际上，有一个字符串值，受访者可以选择，该值等于小于一年编程经验的字符串。所以让我们查看该列的所有唯一值，以便看到其中到底有什么，以防有更多类似的字符串。

我不相信我们在序列中实际上见过这个。也许我们见过。我记不太清楚。但如果我们想查看序列的唯一值，那么我们可以简单使用 unique 方法。所以我们也可以使用我们之前见过的 value counts 方法。如果我们想计算所有唯一值，但我们其实并不想统计它们。

我们只想查看该列中的所有唯一值。为此，我将说。DF 然后访问该 years code 列的 unique。那是一个方法。所以如果我运行这个。哎呀，我拼写错了。抱歉，今天打字有点困难。好的，如果我运行这个。那么这将给我们该列的所有唯一值。正如我们所期待的。

这里有很多数字。但我们看到这些数字中也混杂了一些字符串。现在我们在这里也有 N A N 值，但我们不需要担心这些。我们只想忽略 N A N 值，因为这只是没有回答问题的人。但我们可以看到这里的字符串都是小于一年。

超过 50 年的编程经验。好的，这就是我们唯一的字符串值。所以我将用数字替换这些，以便我们能够了解人们编程的平均年限。所以我们继续将小于一年替换为 a0，因为这基本上是同样的意思。如果某人编程少于一年，那他们实际上编程的年限就是零年。

所以要做到这一点。我可以说 D F 点 years code 并访问该列。然后我们可以直接替换。将小于一年的值替换为 a0。我们还希望这些值的 in place 等于 true，因为我们实际上想修改这个数据框。所以如果我运行这个，应该能进行替换。

现在我还要替换这里超过50年的值。这将稍微影响我们的结果，具体取决于我们想怎么做。我只是简单地用51的值来替换它。可能有些人比51年有更多的编码经验。

但我无法想象会有那么多人，您知道。编码超过50年的。所以我只会用51来填充这个。但正如我所说，具体取决于我们在这里选择的内容，它可能会稍微影响我们的结果。但在这种情况下不会影响很多。所以我只是会抓取这个相同的替换值。然后。

我想替换超过50年的数据。我将用51的值来替换它。那么现在。让我继续运行这个。如果我们想再次查看这些唯一值。然后我们可以查看这些。现在看起来这里没有任何字符串。但我们可以看到，这仍然是一个D类型的对象。

这意味着实际上并没有将其作为浮点数读取。所以如果我们向上滚动一下。哦，实际上，我想我。覆盖了那一行。是的，我确实这样做了。那我们再试一次，所以。我要做的是将其转换为浮点数。这就是之前给我们带来错误的原因，因为我们这里有这些字符串。

它不知道如何将这些转换为浮点数。但现在我们应该只需要说，好吧。我想将其转换。将类型设置为浮点数。那么让我们运行一下。我们这次没有得到错误。这很好。现在我们应该能够查看填写了此调查的开发者的编码经验年数的平均值。

所以为了做到这一点。我将说，好吧，D F数据框。访问该列并获取该列的均值。所以如果我运行这个。然后我们可以看到现在我们得到了那个平均值。所以我们得到的平均值大约是11年半的编码经验。

作为回答此调查的开发者的平均年数。现在你也可以对此进行其他分析。所以，例如，如果我们想查看中位数。那么我可以运行这个。中位数返回为9年的编码经验。所以希望这个现实世界的例子有助于解释为什么了解如何转换这些值以及理解其中发生的事情是重要的。

总会有一些数据是杂乱的或不是我们想要的格式。所以知道如何处理这些缺失值并将这些值转换为不同的数据类型在使用pandas时真的很重要。好的，所以在结束之前，我想感谢本视频的赞助商，并提到我为什么非常喜欢他们的教程。那就是brilliant。在这一系列中，我们一直在学习关于pandas的内容以及如何。😊。

在 Python 中分析数据，brilliant 将是补充你在这里所学内容的绝佳方式，他们提供了一些优秀的动手课程。这里有一些出色的课程和教程，深入讲解如何正确思考和分析数据。对于数据分析基础，我真的推荐你查看他们的统计课程，它展示了如何分析图表并确定数据的显著性。

我还建议他们的机器学习课程，该课程将数据分析提升到一个新水平，讲述了允许机器在变量过多时做出决策的技术。为了支持我的频道并了解更多关于 brilliant 的信息。

你可以访问 brilliant.org 免费注册。而且前 200 位访问该链接的人可以享受年度高级订阅的 20% 折扣。你可以在下面的描述部分找到该链接。再说一次，访问 brilliant.org。我想这就是这段 pandas 视频的内容了，希望你对如何处理这些缺失值和将数据转换有了一个良好的理解。😊。

数据类型以便我们能够精确地分析我们的数据。现在，在下一个视频中，我们将学习如何处理日期和时间序列数据。此系列的整个过程我一直在使用 Stack Overflow 调查数据，因为我喜欢向大家展示这些概念如何在现实世界中应用。但我们的 Stack Overflow 调查数据没有任何我们可以实际处理的时间序列数据。

所以我将在下一个视频中使用一个不同的数据集。我还没有确定具体使用什么，但我会确保它能让我们对一些现实世界的数据进行分析，就像我们一直在做的那样。也许我们会使用时间序列数据来分析加密货币的汇率变化，或者其他类似的内容。

但是如果任何人对本视频中的内容有疑问，请随时在下面的评论部分提问，我会尽力回答。如果你喜欢这些教程并希望支持它们，还有其他方式可以做到。最简单的方法就是点赞并给视频一个好评。此外，分享这些视频给任何你认为会觉得有用的人也非常重要。😊。

如果你有能力，可以通过 Patreon 进行支持。链接在下面的描述部分。请务必订阅以获取未来的视频。感谢大家的观看。😊。

用 Python 和 Numpy 实现最热门的 12 个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P14：L14- AdaBoost - ShowMeAI - BV1wS4y1f7z1

嘿，大家好，欢迎来到另一个机器学习的 Sc 教程。今天，我们将仅使用 Numpy 和内置的 Python 模块实现 AdaBoost 算法。😊 AdaBoost 使用提升方法，这个简单的想法是将多个弱分类器组合成一个强分类器。这个方法在实践中效果非常好。所以在我们跳到代码之前，让我们先从理论开始。

让我们看看这个二维示例，以理解这个概念。这里我们的样本只有两个不同的特征，分别在 X 轴和 Y 轴上。现在，第一个分类器根据 Y 轴进行划分。在这个例子中，它在某个阈值处绘制了一条水平决策线。我们在这里看到的虚线就是。😊

我们可以看到一些预测是正确的，但也有误分类。现在，利用这些误分类，我们可以计算性能指标。也就是这个分类器的准确度。通过这个指标，我们计算并更新所有训练样本的权重。然后第二个分类器就会出现。

它利用这些权重，寻找一个不同的、可能更好的决策边界。在这个示例中，第二个分类器选择了 X 轴上的一个特征并绘制了一条垂直线。然后再次计算性能并更新权重。接着我们重复这个步骤，直到达到我们想要的分类器数量。😊 然后在最后。

我们有所有不同的决策线，以及所有不同的分类器性能。然后我们将所有分类器结合起来，可以用计算得出的性能进行加权求和。这使我们能够绘制出我们在这里看到的完美决策线，这可能比简单的线性决策线更复杂。😊

这里的想法是，分类器越好，对最终结果的影响就越大。这基本上就是这个概念。现在让我们详细看看所有不同的步骤以及背后的数学。

所以我们需要的第一件事是一个弱分类器，这也被称为弱学习器。弱学习器总是一个非常简单的分类器。在 AdaBoost 的情况下，我们使用一个所谓的决策树桩。决策树桩基本上是一个只有一个划分的决策树。所以我们在这里看到的内容是，我们只关注样本的一个特征和一个阈值。

然后根据我们的特征值是否大于或小于阈值，我们可以说它是类别 -1 或类别 +1。😊 所以这就是决策树桩。然后我们需要计算误差的公式。所以第一次，在我们迭代的第一次，误差是通过误分类的数量除以样本总数来计算的。

这是处理误差的自然方法。如果我们再次查看我们的例子，我们可以看到在这种情况下我们有10个样本。在第一个分类器中，我们有三次误分类。这意味着我们的误差率是0.3或30%。这是第一次。但下次我们也想考虑权重。

如果一个样本被误分类，我们将在下一次迭代中给予它更高的权重。这意味着我们的公式将计算为所有误分类权重的总和。如果我们的误差大于0.5，我们就简单地翻转误差。我们翻转所有决策，也翻转我们的误差。

所以这就是1减去误差。这就是误差。现在我们需要权重。每个样本的权重最初设置为1/n。这也与第一步的误差计算相匹配。如果我们说计算误差为所有误分类权重的总和。

我们还说每个权重一开始是1/n。因此它等于误分类数量除以样本数量。是的，这就是为什么初始权重是每个样本1/n。然后我们还需要这里定义的更新规则。

我们有旧权重乘以负阿尔法乘以实际y乘以h(x)，其中h(x)是我们的预测。阿尔法是分类器的准确性。如果这是-1，我们有一个误分类。如果这是+1，那么我们有一个正确分类。这个公式确保了被误分类的样本对下一个分类器有更大的影响。

是的，这就是你应该记住的权重。现在是性能。因此，我们需要为每个分类器计算性能或阿尔法，我们可以做到这一点。这是最终预测所需的，性能的公式计算如下。所以是0.5乘以1减去误差的对数除以误差。

所以让我把这个放大一点。这就是性能。我们的误差始终在0和1之间。所以我在这个范围内绘制了不同误差下的阿尔法。我们可以看到它在一个正值和一个负值之间均匀分布。误差低时，我们有一个高的正值，而当误差接近1时，情况则相反。

我们有一个很高的负值。因此，由于我们正在翻转决策，这将再次产生对负面贡献较高的正确分类。所以这里的类别是-1。这就是阿尔法的概念。现在我们需要预测。如果我们理解了这一切，那么最终的预测就很容易理解。我们只需选择这里的符号。

所有预测总和的符号，我们用分类器的性能来加权每个预测。因此，这里是alpha乘以预测。我们的分类器越好，对最终预测的影响就越大。分类器越好，它的指向就越倾向于负侧或正侧。

然后我们将更好的侧作为我们类别的预测。因此，是的。这就是预测的概念。对于不同的公式和侧翻可能会有点困惑，但基本概念并不难。现在让我们总结一下在代码中必须执行的不同训练步骤。因此，首先，我们初始化每个样本的权重，并将值设置为1/N。

然后我们选择想要的弱学习者数量。接着我们进行迭代。然后我们训练每个决策树桩。因此，我们进行贪婪搜索，以找到最佳的分裂特征和最佳的分裂阈值。然后我们计算这个决策树桩的错误。因此，这是用公式表示的，错误是分类错误权重的总和。然后如果错误大于0.5，我们还要翻转错误和决策。

然后我们用公式计算alpha。接着我们需要预测。然后利用预测和alpha，我们可以计算。我们可以更新权重。因此，这就是我们现在必须在代码中做的事情。是的。我向你保证，从现在开始我们有了所有的公式和所有的训练步骤。

实现是相当直接的，应该不难。所以让我们跳到代码。

所以我们做的第一件事是导入Ny。所以导入Ny S和P。这是我们将需要的唯一模块。然后我们为决策树桩创建一个类。所以class decision stampump。然后进行初始化。所以定义一个初始化，这里只需要self。

在这里，我们想要存储几个东西。首先，我们要存储所谓的极性。所以self.dot polarity等于1。这告诉我们样本应该被分类为-1还是+1，取决于给定的阈值。所以如果我们想查看左侧或右侧。这是必要的，因为如果我们想翻转错误，那么我们也必须翻转极性。

这会在一秒钟内变得更清晰。现在我们要在这里存储的第二件事是特征索引。所以self.dot feature index在开始时等于None。我们还想存储阈值。因此，分裂阈值self.dot threshold在开始时等于None。我们还想存储性能变量。所以alpha。

所以我们说self.dot alpha等于none。这是我们想要存储的内容。然后我们还定义一个预测方法用于决策树桩。所以我们说定义预测，它接受self和x。所以它应该预测的样本。现在我们想在这里做的事情是，只查看这个样本的一个特征，然后将其与阈值进行比较，看看如果它小于阈值，则为-1，否则为+1。

所以这就是决策树桩的整个概念。所以让我们这样做。我们可以说样本的数量等于X的形状0。然后我们只获取这个特征。所以我们可以说x column等于x。

然后我们可以使用冒号。所以我们仍然希望所有的样本，但只有这个特征索引，我们稍后在训练期间计算。所以self.dot feature index。现在我们做出预测。所以我们说predictions等于。默认情况下，我们说这是1。所以我们可以说nuy ones的大小等于样本数量。然后我们必须检查极性。

所以我们说如果self.dot polarity等于1。这是默认情况。那么我们说所有预测中，特征向量小于阈值的就是-1。所以，我们可以说，预测。在这些索引处，x column小于self.dot threshold。那么这些预测就是-1。

在另一种情况下，else。所以如果我们的极性是-1。那么我们想要完全反过来做。所以让我复制这个。但我们想说如果x值大于我们的阈值。那么这些就是-1的预测。所以，是的，这就是我们的决策树桩所做的所有事情。

然后我们可以返回预测结果。所以这是决策树桩的类。现在我们需要一个实际的加法增强算法的类。我们可以说class add boost。我们把这个名字的小写处理。现在我们需要一个初始化函数。所以定义一个初始化函数。它接受self，而唯一的参数是我们想要的分类器数量。

所以我们可以说N C，L F默认为5。然后在初始化时，我们存储这个数字。所以我们说self.dot N C，L F等于分类器的数量。然后像往常一样，我们想要实现fit和predict方法。我们先从fit方法开始。我们可以说定义fit，它接受self、X和y。所以训练样本和标签。

现在，我们首先要做的是获取这个向量的形状。所以样本的数量以及特征的数量。特征等于x的形状。然后我们要初始化我们的权重。因此，初始化权重。正如我所说，每个样本的权重在开始时都设置为1/n。所以我们可以说w等于nuy。

然后我们可以使用一个来自numpy的方法，叫做full。所以numpy full。它获取样本的大小数字。然后它获取一个初始值。在这里我们说是1。除以样本数。这将每个值设置为这个计算值。然后，这是我们的初始化。现在让我们遍历所有分类器并进行训练。

首先，我们创建一个列表来存储所有分类器。假设self.dot.C.LF's。😊，这是一个空列表。一开始。现在让我们进行迭代。假设4_在范围内。在这里我们有指定的分类器数量。所以self.dot.N.C.L.F。现在我们想要做的是贪婪搜索。

我们想遍历所有特征和所有阈值。这与我在另一个教程中实现的决策树类似。我建议你也查看一下。所以我们想在这里做类似的事情。首先，我们创建我们的分类器。假设C.LF等于decision stump。

现在让我们一开始定义一个最小误差。我们想找到最佳特征值、分割特征和分割阈值，使得这个误差最小。所以一开始，我们只是说这是float。在这里，这是一个非常高的数字。现在让我们遍历所有特征。假设对于特征。对于特征。

我在范围内。在这里我们有一开始获取的特征数量。然后我们只想获取这个特征。假设X列。这与我们在这里所做的相似。所以我们可以做同样的事情，设定x列等于这个。所以所有样本，但仅仅是这个特征索引。在这种情况下我称之为特征i。

然后我们获取唯一值。它们就是我们的阈值。假设阈值等于Nai.dot.unique。在这里，我们的列的唯一值。所以x列。现在我们遍历所有阈值。假设对于阈值在阈值中。现在我们想做的是先用极性1进行预测，然后用我在开始时展示的公式计算误差。

假设我们的极性等于1。然后让我们进行预测。所以预测等于。这与我们在这里所做的相似。所以一开始，它只是1。然后我们使用这个公式。因此，由于我们的极性是1，我们必须通过比较它是否小于阈值来进行比较。

所以预测结果是我们的列值，我们的特征值小于阈值时，预测结果为-1。现在我们预测了所有样本，接下来我们想计算误差，正如我所说，误差是错误分类样本权重的总和。让我们获取错误分类的权重。假设错误分类等于W，且w是我们的y，训练标签不等于我们刚才的预测。

这些是被错误分类的权重。现在我们想要简单地计算这些权重的总和。所以 arrow.Eror 等于这些被错误分类权重的总和。这是误差。现在如果误差大于 0.5，我们也要翻转我们的误差。所以我们说如果误差大于 0.5，我们简单地说我们的新误差等于 1 减去误差，然后我们也翻转极性。

所以我们说 P 等于 -1。现在我们有了误差，接下来检查我们的误差是否小于最小误差。如果误差小于最小误差，那么这是我们的新最小误差。所以我们说最小误差等于误差。这是我们当前的最佳拟合。因此，我们要保存这个结果。我们说 CF.dot.polarity 等于 P，对不起，只有 P。

我们还想保存阈值和特征。因此，CF.dot.threshold 等于当前阈值，CF.dot.feature index 等于特征 I。是的，这就是分类器的整个训练循环。当我们完成后四个循环时，我们要检查我是否在正确的缩进上。

现在我们需要计算性能。计算 alpha。因此我们说 CF.dot.alpha 等于。然后我们需要这个公式。

所以 0.5 乘以 1 减去误差，再除以误差。

我们还使用一个小的 epsilon，以避免除以 0。所以我们假设 Es 等于这个小值。嗯。这是我们的 epsilon。现在让我们使用这个公式。所以 0.5 乘以 nuy.dot.log。这里有 1 减去误差。然后在这里除以，假设误差加上我们的 epsilon。并将其包裹在另一个括号中。所以这个。

让我检查一下这是否正确。因此让我们在这个周围再做一个检查。这应该没问题。所以这是我们的 alpha。现在我们想更新权重。为此，我们还需要预测值。因此让我们再次检查公式。所以这是旧权重乘以刚刚计算的 alpha 的指数函数，乘以实际预测值或实际标签乘以预测值。

然后我们进行归一化。这是我们需要的公式。让我们在这里写下这个公式。首先获取预测值。所以我们可以说 predictions 等于。我们已经实现了这一点，所以我们可以简单地说 CF.dot.prediction。

X。X，没错。所以我们在这里获取列。因此我们可以把整个 x 放在这里。现在我们有了预测，现在我们可以使用它们并更新权重。因此我们说我们的权重乘以等于。然后我们说 nuy X。即指数函数。然后减去 CF.dot.alpha。乘以，和这里的实际标签。再乘以预测值。

次数，预测。所以，我们想要进行归一化。我们将其除以这个权重的总和。所以我们说w除以等于。然后这里我们说nuy的sum W。现在我们完成了。我们更新了权重，然后我们想要存储这个分类器。我们想要保存它。所以我们说self的C，L。

F点追加当前分类器。所以我们追加C，L F。现在我们完成了fit方法。这是我们add boost分类器的整个训练过程。现在，我们当然也需要predict方法。让我们在这里实现它。假设定义predict，这里得到self，也得到X。这是我之前给你展示的公式。

我们查看总和的s。在这里我们将每个alpha与预测相乘。是的。那么我们来做这个。

假设C，L F的Prats等于。在这里我们使用列表推导式。然后我们对每个分类器进行此操作。我们说C，L F的alpha乘以。在这里我们使用预测C，L F的predict。我们想要对X进行预测。我们要对每个初始分类器这样做。所以我们说对于C，L F在self的C，L Fs中。

这些都是预测的总和。现在我们需要计算总和。我们说y pre等于nuy的sum。这里我们说C，L F pres，并沿着axis 0。现在我们得到了总和。最后我们需要查看s。所以我们说y pret等于nuy的sign of this，Y pret。这是我们的最终预测。

然后我们可以返回这个。我们说返回y pret。现在我们应该完成了。现在我们有了fit方法和predict方法。这里我已经写了一个小的测试脚本。所以我从addda boost中导入我们刚刚创建的类。

然后我这里还有一个准确率测量。在这个例子中，我们从SQ learnide assets加载乳腺癌数据集。重要的是我们必须将目前所有标签为0的设置为-1，因为add boost需要标签为-1和+1。然后我们像往常一样进行训练测试分割，然后在这里创建一个add boost分类器。

在这种情况下，我放入了五个分类器。然后我们调用fit方法。接着我们调用predict方法，然后计算准确率。所以这是测试脚本。让我们运行这个，希望一切正常。假设我们用Python来进行boost测试，调用它并按下回车，它正在运行，并在计算。我希望它能正常工作。

现在我们完成了。所以，是的，这里我们有一个准确率，而且在这个例子中表现相当不错。所以我们有094。我们看到它在工作。希望你喜欢这个教程，下次见，拜！

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P1：L1- 介绍 - ShowMeAI - BV1wS4y1f7z1

欢迎大家观看这部从零开始的机器学习综合视频。这个视频将我从零开始的机器学习系列的所有15个部分合并成一个视频。在这个系列中，我们将仅使用纯 Python 和 Numpy 实现最流行的机器学习算法。这非常完美，如果你是初学者或中级水平，想要更深入地了解这些算法的工作原理。

所有视频在开始代码之前也包含一些理论部分。我会为每个部分留下时间标记，当然，所有代码都可以在 Github 上找到。我还创建了一个免费的 Numpy 手册，涵盖了你必须了解的所有基本函数，并包含所有部分的有用代码示例。

所以你可以在我的网站上免费下载这本电子书。我会在描述中留下链接。现在让我们开始吧。如果你喜欢这个内容，请一定给我点赞，并考虑订阅频道。😊

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P10：L10- 决策树第 2 部分 - ShowMeAI - BV1wS4y1f7z1

嗨，大家好。欢迎来到决策树教程的第二部分。如果你还没有观看第一部分，请务必观看，因为在那里我会解释理论。所以在这里我们继续实现，我们可以立即开始。所以我们说导入numpy S和P。然后，在实现决策树类之前，我们首先。

创建我们的熵方法来计算熵。我们将其实现为全局函数。所以我们说定义熵。它将获取一个包含所有类别标签的向量y。

让我们看看这个公式。所以我们必须计算出现次数，我们可以。

用一个函数来完成这项工作。我们称之为hist或直方图。我们可以使用nuy bin count。对y进行计数。所以这将计算所有类别标签的出现次数。然后我们将它们除以总样本数。所以我们说P等于hist除以y的长度。

然后我们应用实际的公式。所以我们说减去p的x乘以log的p的x的总和。所以我们可以在一行中完成这个并说返回减去nu pi的总和。在这里我们使用列表推导。所以我们可以说P乘以nupy log2的P，适用于P中的所有P，并且我们还必须使用一个条件，如果P大于0，因为对负数不定义对数。

所以这是熵。现在我们还实现一个辅助类，称之为note。在这里我们将存储我们的note的信息。所以这将获取一个初始化。它将获取自我。然后我们来看看这个，。

如果我们处于中间状态，那么我们想存储最佳分裂特征和最佳分裂阈值。我们还想存储左右子树，因为我们稍后需要它们。如果我们现在处于叶节点，我们还想在这里存储实际值。所以最常见的类别标签。

所以，我们说特征等于无。阈值等于无，左等于无，右等于无。然后我们用一个小技巧。所以我们使用一个星号和一个逗号。然后我们说值等于无。所以现在如果我们想使用这个值参数，我们必须将其作为关键字参数使用。所以稍后当我们创建叶节点时。

这只获取值，然后我们还需要写值等于某个东西。所以这样更清楚这是一个叶节点。在这里我们简单地存储它们。所以我们说自我特征等于特征，自我阈值等于阈值。自我左等于左。自我右等于右。自我值等于值。现在我们还创建一个小辅助函数来确定我们是否处于叶节点。

定义判断是否为叶节点。它获取自点。在这里我们简单地说，如果，如果我们有一个值，那么我们处于叶节点，否则不在！

所以我们返回自点，该值不为None。如果我们有一个值，那么我们返回true。这是我们为注释准备的辅助类。现在我们可以开始实际的decision3类。因此这也获取一个init。它获取自点。然后它会获取一些停止标准。因此我们称之为最小样本分割。默认情况下，假设这是2。

所以进一步分割我们树所需的最小样本数，然后是最大深度。默认情况下，这是100。然后它还获取一个参数，我们称之为特征数量或nFes。这是None。所以我们不需要这个，但我们可以指定它。正如我所说，我们对所有特征进行贪婪搜索，但我们也可以仅循环遍历特征子集。

然后我们随机选择这个子集。这是随机因素之一。这也是为什么它被称为随机森林的原因之一。如果我们将决策树扩展为随机森林。那么这就是一个随机因素。现在我们简单地存储它们。因此我们说自点最小样本分割等于最小样本。抱歉。

min样本分割自点最大步长等于最大。深度。自点n特征等于和特征。我们还创建一个根节点。最开始时，这个值为None。因此我们后来需要知道我们的根节点，以便知道从哪里开始遍历我们的树。现在我们实现fit方法。该方法获取训练数据和训练标签。

在这里我们希望生长我们的树。然后它获取预测方法。带有测试标签。因此在这里我们想遍历我们的树。让我们开始生长我们的树。我们说自点根节点等于。现在我们调用并创建一个辅助函数自点grow3。它获取X和y。我们还应用一个安全检查。因此我们说自点和特征拟合等于。

X.dot.shape。of。1，所以这是nuy和DRA。第二个维度是特征数量。如果不是自点和喂养。如果没有指定，如果为None。那么我们简单地取最大特征数量。否则，我们取自点和特征与X.dot.shape 1的最小值。这只是确保它永远不会大于实际特征数量。

现在我们实现。生长树。方法，该方法获取自点，然后获取X和y。同时还有一个深度。最开始时为0。因此我们需要跟踪深度。现在让我们开始吧。首先，获取样本数量和特征数量。这是x.dot.shape。然后我们还想获取不同标签的数量。

这是 nuy 的长度。y 的唯一值。所以所有不同的标签。现在，首先我们在这里做的是，首先应用我们的停止标准 Tia。所以我们说如果。现在再看看我们所说的内容。我们想检查最大深度。

然后是所需的最小样本数，如果我们没有更多的类别分布，我们说如果。

我们说深度大于或等于自身的最大深度。或者，如果不同标签的数量等于一。所以如果我们在这个节点只有一个类别，或者样本数量小于所需的最小样本数。那么，如果这一切都成立，那么我们就在叶子节点。因此我们说让叶子值等于自身的最常见标签。

现在我们创建并返回我们的叶子节点。因此我们说返回节点。然后我们必须说值等于叶子值。现在可以清楚为什么我只用问风险。在这里我必须使用值作为关键字。现在很清楚这是一个叶子节点。我们还需要一个帮助函数来获取最常见的标签。

让我们把这个写下来。所以定义最常见标签，它获取自身。然后获取一个类别标签的向量。为此，我们使用一个 Python 模块，计数器模块。所以我们说从 collections 导入计数器。我在之前的视频中已经谈到过这个。

如果你对计数器模块不熟悉，请查看一下。因此在这里我们可以创建一个计数器对象。计数等于 y 的计数器。这将。嗯。计算所有 y 的出现次数，类似于 nu pin 计数。然后我们有一个最常见的函数。因此我们说最常见等于计数器的最常见值。

所以我们只需要最常见的标签。这将返回一个列表。因此我们想要列表的第一个元素。这是最常见的元组。在元组中，存储了值和出现次数。所以我们只需要值。因此我们再次说索引 0。所以请自己再确认一下。

然后我们返回这个。这将确定最常见的标签。所以现在我们有了层级。如果我们没有满足停止标准，那么我们继续。所以首先，我们选择特征索引。因此特征索引等于 nuy 随机选择。这将获取特征的数量。因此它会在 0 和特征数量之间选择随机数。

数组的大小应该是我们指定的自身的和 fes。我们还说替换等于假，因为我们不想多次出现相同的索引。现在，我们进行贪心搜索。所以，我们说最佳阈值。还有最佳，让我们反过来做。

最佳特征和最佳阈值等于 self.dot。最佳标准。这将获取 X 和 y 以及所有特征索引。所以这是另一个辅助方法。现在让我们在这里定义它。定义 self.best。标准。它获取 self 和 X 以及 y 和特征。索引。所以，在这里。我们进行贪婪搜索。

所以我们说最佳增益等于 -1。我们想要遍历所有特征和所有特征值，并计算信息增益。所以。现在，假设拆分索引和。🎼拆分阈值等于无。所以它们都是无的。然后我们有我们的第一个循环。对于特征。索引在。特征索引中。现在我们只想选择。这个 x 的列向量。所以我们说 x。X 列等于。X 的。

我们想要所有样本。 但仅在这个索引上。然后我们想要遍历所有可能的阈值，所以我们说。阈值等于 Ny，唯一。的。嗯。X 列。所以我们不想检查相同的值两次。就像在这个例子中。我们会检查 30，15，5，10。

20 和 25。现在我们遍历所有可能的阈值。所以我们说对于 th。旧在阈值中。现在我们计算信息增益，我们说增益等于 self.dot。信息增益。它获取 y 和列向量，以及当前阈值。然后我们说如果增益大于我们最佳增益，那么我们的新最佳增益就是当前增益。

我们的最佳拆分索引是当前特征索引。我们的最佳拆分阈值是当前阈值。最后，我们想要返回它们。所以我们先返回拆分。索引，然后是拆分阈值。所以这是贪婪搜索。现在我们需要另一个辅助函数来计算信息增益。

所以假设用单元格定义信息增益。然后它获取 y 和一个 X 列及阈值。所以我们称之为拆分阈值。现在。让我们再看看公式。所以。抱歉。我们想要计算父节点的熵，然后是子节点的加权平均。

所以。我们计算父节点熵。然后，我们生成。一个拆分。然后我们计算子节点熵的加权平均。然后我们返回信息增益。所以父节点熵，我们可以简单地说父节点。熵等于熵，因为我们已经有这个函数。所以父节点熵即 y 的熵。

然后我们生成我们的拆分。所以我们说左索引和右。索引等于 self.dot.split。我们根据这个 X 列和一个拆分阈值进行拆分。所以。我们需要另一个辅助函数，所以。希望你能继续跟上我。我尽量解释得尽可能清楚。但代码比通常的要复杂一些。不过是的，让我们继续。所以假设。

定义 split self。然后它获取 x 列和我们的分裂阈值。在这里我们可以说左索引。所以在这里我们应用我们的条件，我们可以使用一个叫做 nuy arc 的函数，在这里我们问 x 列的值是否小于或等于我们的分裂阈值。

所以这将返回一个数组，其中所有条件对我们 x 列中的所有值都为真，我们想要拉丁这个数组，因为我们只想要一个一维向量，请自己检查一下。我们对右索引做同样的操作，所以我们说 nuy。Arc，哪里。

在这里我们检查 X 列是否大于我们的分裂阈值。然后我们扁平化它。然后我们返回左索引和右索引。现在我们有了分裂函数。现在。如果我们有。嗯。通过这个函数，我们在这里生成分裂。首先，我们检查左索引的长度。是否为 0 或右边的长度是否为 0。

然后我们可以立即返回 0 作为信息增益。否则，我们继续。所以我们计算加权平均数。我们需要样本的总出现次数。所以，这是 Y 的长度，然后左样本的数量和右样本的数量等于 Lng 左索引和 Lng 右索引。然后我们计算熵。所以我们说 E，L 和 E R 等于 y 的熵。

所有左索引的熵和所有右索引的熵。现在，我们的子熵等于加权平均数。所以我们说 N L 除以 N 乘以左熵加上。现在 N R 除以 n 乘以右熵。所以这是子熵。现在让我们计算信息增益。这只是父熵减去子熵。

现在我们返回它。所以返回信息增益。现在我们有了这个，现在这个函数完成了。现在我们可以继续生长。所以。现在，在我们选择了最佳标准之后。我们想用这个最佳特征和最佳阈值来分裂我们的树。

所以我们说左索引和右索引等于自身的 dot split。再说一次。这里我们可以使用我们的 split 函数。所以我们说 X。Off。现在我们必须小心。所以现在我们想要所有样本。嗯。但只有最好的。特征索引。所以，这是一列。我们在这里放入最佳阈值。现在，有了我们的左索引和右索引。

我们可以继续生长。所以我们去左边并说左边。等于。我们在这里递归地调用这个函数。所以我们说 self dot。Grow tree。在这里我们说 X。然后我们只想要左索引，但我们想要所有特征。所以 S Y。我们只想要左索引。然后我们也说深度加一。

所以现在我们的深度增加了一。现在我们对右侧做同样的事情。所以我们说 right 等于 scroll3 的右索引。现在我们在中间返回一个新的节点。所以这将获得最佳。功能。最佳阈值。左子节点和右子节点。但这里没有值。这是生长方法。现在唯一剩下的就是实现预测方法。

我保证这会很简单。所以我们只需要一个辅助函数。所以我们说返回。嗯。Numpy 数组。在这里我们再次使用列表推导。所以我们遍历我们的树。所以 self.dot.traverse3，在哪里我们为大写 X 中的所有样本放入一个样本。这是我们的预测方法。现在让我们实现。Traverse3 方法作为最后一件事。

所以这将获得 self 和一个样本。它还获取我们开始的节点。所以我们必须在开始时放入 self.dot.root，因为我们从顶部开始。在这里，我们也这样递归进行。首先，我们可以检查停止标准，所以我们检查是否已经到达叶节点，所以我们可以说如果节点是叶节点。这就是我们实现这个辅助函数的原因。

然后我们返回节点的值，因为如果我们在叶子上。我们也有一个值，否则我们应用我们的问题，所以我们去左边或右边。所以。我们说如果。这节点的 X。我们存储的功能索引。是否小于或等于我们在这个节点开始的阈值。那么我们返回。Self.dot.Traverse3。

所以我们去左侧，把 X 和节点左放入。所以这就是为什么我们在节点处开始左和右节点。否则，我们返回。Self.dot.traverses3 的 x 和 no.dot.right。所以，是的，这就是整个 Traverse 实现。现在我们终于完成了。这就是我们需要的整个决策树实现。

让我们检查一下。所以我写了一点小帮助脚本。一个测试脚本。在这里我实现这个决策树类，并使用数据集。来自 psychic learn 模块的乳腺癌数据集。我将把我们的数据拆分为训练标签和训练样本，以及测试标签和测试样本。

然后我将创建我们的决策树并拟合数据。然后预测测试数据并计算准确性。所以让我们检查。让我们运行脚本，检查一切是否正常运作。需要一点时间去。嗯。对不起。作为 traverse3 缺少一个位置参数节点。嗯。Self do traverse 3 X。哦。

self do root 必须在这里，而不是这里。所以让我们清除这个，再试一次。祝我们好运。注意对象，测试没有属性功能索引。所以这是，我们怎么称呼它？

只是功能，对不起。如果注意到。功能。阈值。阈值，阈值你。所以，再一次。我希望我没有更多的错字。所以是的，现在我们有了准确性，一切都在正常运作。而且是的。我希望你喜欢这个教程。如果你喜欢，请订阅频道。在下一个教程中，我们将继续将这个决策树扩展到随机森林模型。

所以，好的，待会见，再见。😊。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P11：L11- 随机森林 - ShowMeAI - BV1wS4y1f7z1

大家好，欢迎来到你的新机器学习Sct教程。今天我们将使用仅内置的Python模块和Ny来实现随机森林。随机森林算法是最强大且最受欢迎的算法之一。所以我很兴奋我们终于能在这个教程中实现它，在上一个教程中。

我解释了单棵决策树是如何工作的。如果你还没有观看之前的教程，那么请去观看，因为我们的随机森林模型以及实现是基于上次的决策树模型。😊如果你理解了决策树，那么随机森林的方式就非常容易理解。如果我们看看这里的图像，它展示了整个想法。

所以这个想法是将多棵树组合成一片森林。因此我们训练多棵树，每棵树获取训练数据的随机子集，因此称为随机。最后，我们用每棵树进行预测。然后我们进行成熟投票以获得最终预测。这就是整个思路。

随机森林相比单棵树有一些优势，例如。通过构建更多的树，我们有更多机会获得正确的预测，同时我们也减少了单棵树过拟合的可能性，因此随机森林的准确性通常高于单棵树，这就是它如此强大的原因。

所以，是的，现在我们可以直接跳到实现部分。当然，我们导入。

Nampy、S和P。然后我们还从上次导入决策树类。因此我们说从决策树中导入决策树。现在我们可以开始了。我们创建我们的类decision3。抱歉，现在我们有了随机森林。所以现在我们创建我们的随机森林类。这将进行初始化。

这将获取我们想要在森林中拥有的树的数量。因此，默认情况下树的数量等于100。然后它还获取我们决策树初始化器的所有参数。所以它获取分裂所需的最小样本数，获取最大深度。

它获取一些更多随机性的可选特征数量。所以我们就复制粘贴在这里。然后我们存储所有这些。因此我们说self.dot number of trees等于树，self.dot min sample split等于min sample split，self.dot max depth等于max depth，self.dot N fats等于，和feats。然后我们实现我们的预测和拟合方法。

预测方法有测试数据。我们从拟合方法开始。所以我们说拟合自己，这将包含训练数据和训练标签。还有一件事，我们想要有一个空的树数组，用于存储我们现在要创建的每一棵树。因此，我们说 self.dot trees 等于一个空列表。然后在拟合方法中。

我们想确保列表再次为空。现在，我们开始训练我们的树。因此我们说 for underscore，因为我们在范围 self.dot number of trees 中不需要这个。然后我们创建我们的树。因此我们说 3 等于决策树。这将获取所有参数。因此它获取最小样本拆分等于 self.dot min sample split。

然后它将具有最大深度等于 self dot，最大深度，特征数量等于 self dot。特征数量。现在，我们想要做的是给我们的树一个随机子集。因此我们在这里定义一个全局函数。我们称之为。这也称为引导。因此我们称之为 Boott 样本，它将获取 X 和 y。

现在我们先看看我们有多少不同数量的样本。因此 n 样本等于 x.dot shape。和往常一样，这是一个 Ny 和 D，其中第一维是样本数量，第二维是特征数量。现在我们进行随机选择。因此我们说索引等于 numpy random choice。在这里我们输入样本数量作为整数。

这意味着它将在 0 和样本数量之间随机选择。因此我们的索引在这个范围内，大小也将是样本数量。但我们还说替换等于真。这意味着一些索引可以多次出现，而其他的会被丢弃。因此我们随机丢弃一些样本，仅使用一个子集。然后。

我们返回。这些 x。哦。这些索引。同时，也返回这些索引的 y。因此现在我们只有这些选择的样本。🎼现在我们可以用这些来训练我们的树。因此首先，我们说 x 样本和 y 样本等于 bootstrap 样本与 X 和 y。然后我们说树 dot fit，X 样本和 y 样本。然后我们简单地将其添加到我们的树列表中。因此我们说 self dot。

T st a pent。3。现在我们完成了训练阶段。现在，当我们进行预测时。我们对每棵树进行预测。因此我们说树预测或树预测等于。在这里我将使用列表推导，然后将其转换为一个 numpy 数组。因此在这里我说树 dot predict，X 43 在 self.dot trees 中。

因此对于每棵树，我们现在制作我们所称的树预测方法。现在我们想进行成熟投票。但现在我们必须小心，因为我们得到的是。假设，例如，我们有三棵树和四个样本。然后假设我们的第一棵树为了简单起见仅进行一次预测。因此对于每个样本。

它这里会有一个一。第二棵树只会生成零。所以我们有零。然后第三棵树也只预测一个。所以，然后再一次，这将是。一个数组。这将是一个数组，而这个数组将是这个数组中的一个数组。但。现在我们想进行成熟度投票。那么现在我们。

实际上，我们想要一个看起来像这样的数组，所以我们想要有 10，1，10，1，101 和 101。所以。这个。从所有树中。我们想要有对应的预测。所以我们将其转换为这个结构。并且 Nmpy 中有一个非常好的函数正好做到这一点。所以我们说 tree pres 等于 Nmpy swap。作为。嗯。用这三个预测。

然后我们交换 axis0 和 axis 1。所以这正是我们所做的。现在我们可以进行成熟度投票。所以我们说预测等于。现在我们为这三次预测中的每一个预测预测最常见的标签，所以。现在，如果我们有或。1，0，1，1，0，1，1，0，1。那么现在我们逐一查看它们。然后进行成熟度投票，再对它们进行投票。

所以我们再次使用列表推导。我们说，树预测中每个树预测的最常见标签。然后我们将其转换为 nuy。数组并返回它。现在我们唯一需要的是最常见标签函数。我们在决策树类中也需要这个。因此这里我们有最常见标签函数。

作为一个类函数。所以在这里，正如你所看到的，我们需要这个很多次。因此，把它作为一个全局函数可能更好。所以我们把它放在这里，你甚至可以把它放在另一个文件中，并从一个帮助类或其他地方调用它。但我们只是把它放在这里，所以。如果你不知道这个是如何工作的，我就不再解释了。

那么请观看最后一个教程，这样我们就不需要 self 了。我们还需要从 collections 中导入。导入 counter 模块。现在我们可以进行成熟度投票，现在我们完成了。所以我这里有一个小测试脚本来测试我们的类。我将从 Ecal learn 模块导入乳腺癌数据集。然后我会生成一些训练和测试标签，然后创建我们的随机森林实例。在这里，我只使用三棵树，因为训练可能需要一些时间。我们并没有优化我们的代码，所以。在我们的视频中，我现在只使用三棵。

然后我将拟合数据，并预测测试数据，然后计算准确性。让我们运行这个，希望一切正常。然后。我们犯了一个错误，所以我们说 self。哦。我们想把它添加到我们的树中，当然。现在再试一次。希望一切顺利。现在我们得到了准确性。所以现在我们看到我们的模型正在工作。是的。

我希望你能理解一切。如果你喜欢，请订阅频道，下次见，拜拜。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P12：L12- 主成分分析 - ShowMeAI - BV1wS4y1f7z1

嗨，大家好。欢迎来到我们的新机器学习教程。今天，我们将仅使用Python和Numpy实现主成分分析（PCA）。PCA是一个很好的工具，用于获取线性独立的特征，并减少我们数据集的维度。目标是找到一组新的维度，使所有维度彼此正交，从而线性独立，并根据数据沿着它们的方差进行排序。

这意味着我们想要找到一个变换，使得变换后的特征线性独立。然后可以通过仅保留最重要的维度来减少维度。这些新获得的维度应该最小化投影误差，投影点应该具有最大的扩展，或意味着最大的方差。

所以让我们看看一个图像，以更好地理解这一点。假设我们的二维数据分布是这样的，现在我们想将其投影到一维。我们想要找到彼此正交的轴。当我们将数据投影到这些轴上时，我们的新投影数据应该具有最大的扩展。所以在左侧，这些是正确的主轴。如果我们将它们投影到一维。

在最大的主成分上。如果我们将数据投影到这个轴上，那么它们具有最大的扩展。例如，如果我们看右侧。这些轴是错误的。那么，让我们看看投影数据的样子。所以在右侧，我们做得更糟，将其投影到Y轴上。

所以这些显然是错误的，因为我们可以看到很多数据集中在同一个点上。所以我们没有更多关于它们的信息。但在左侧，投影数据的扩展最大。所以我们可以包含大部分关于数据的信息。同时，投影误差意味着这会是。从这里到轴的线。

这是最小的，而右侧则相对较长。所以这里我们需要为每个点做一条很长很长的投影线。所以左侧是正确的答案。现在我们如何找到这些主成分呢？所以，正如我所说，我们想要最大化方差，因此我们需要一些数学。

所以我们需要样本X的方差，这个方差是通过样本数量的倒数来计算的。然后我们对每个分量求和，减去x bar，x bar是均值。所以我们从数据集中减去均值。现在我们还需要一个协方差矩阵。这表示两个变量共同变化的程度，而两个变量的协方差矩阵定义为，这样1/n，然后再次求和，这里减去均值，这里也减去均值，然后转置，在我们的案例中，我们想要两个x的协方差矩阵。

所以这也被称为自协方差矩阵。因此。我们必须计算这个，然后我们的问题被简化为特征向量或特征值问题。所以我不会在这里详细讨论特征向量，但如果你想了解更多，我会在描述中放一些链接。嗯。

但我们需要做的是找到这个协方差矩阵的特征向量和特征值，特征向量指向最大方差的方向，相应的特征值表示其对应特征向量的重要性。

所以现在如果我们再看一下左侧的这个图像。这两个我在这里画的向量，它们对应于我们数据集的协方差矩阵的特征向量。这就是我们需要做的。这里我写下了这个过程。首先我们从我们的 x 或数据集中减去均值。

然后我们计算协方差矩阵。接着我们必须计算特征向量和特征值。然后我们按特征值的降序对特征向量进行排序。然后我们可以指定想要保留的维度数量。接着我们只选择前 K 个特征向量。这将是新的 K 维度。

然后我们通过投影将原始数据转换到这些新维度中。这只是一个点积。我们的数据与新的特征向量进行点积。然后我们就完成了。这就是我们需要做的一切，再见。有一个很好的地方在于主成分分析和特征向量，它们彼此正交。

这意味着我们的新数据也是线性独立的。因此，这是 PCA 的一个小好处。

现在我们可以开始了。所以让我们导入 Ny S 和 P。然后我们创建一个类 PCA。这将初始化 self。接着我们指定要保留的组件数量。然后我们在这里存储它们，所以我们说 self.dot n components。等于 n。Components。我们想要找出特征向量。所以在这里我们称它们为组件。

这一开始都是 None。我们还想稍后存储均值。所以我们说 self 的均值等于 None。然后我们像往常一样定义我们的 fit 方法。这将获取我们想要转换的数据。然后我们不使用 predict 方法。所以现在我们调用 transform。这将会在我们拟合后转换我们的数据。

这只是投影。但现在让我们开始使用 fit 方法，所以。我们再说一次。让我们写下我们的过程。我们想要有均值。然后计算协方差矩阵。接着我们想计算特征向量和特征值。嗯，特征值。然后我们对特征向量进行排序。所以排序。特征向量。然后，我们只存储前面和特征向量。这就是我们需要做的。

这里我们必须对数据进行投影。所以，嗯，来吧，让我们这样做。我们可以说self dot mean等于，然后我们只需使用Numpy的均值函数，沿着第一个轴。然后我们减去均值。所以我们说x等于x减去self dot mean。所以。

我们必须这样做，因为如果我们再次查看我们的公式与协方差矩阵，均值总是被减去。

所以让我们在这里这样做。然后我们计算协方差矩阵。这被称为cof。然后我们简单地使用Numpy的Cof函数。如果我们在这里只放入一个输入，它将完全这样做。但现在我们必须小心。因为让我们，嗯，看看我们的数据。这将是一个Numpy和D数组，其中一行。

行是一个样本。每一列是一个特征。但如果我们查看文档，对于这个函数，情况是相反的。所以一列是一个观察值或一个样本。因此我们必须在这里转置。请自行仔细检查。然后我们继续。现在我们计算特征值。

向量，我，我不知道。这是反过来的。抱歉，特征值和特征向量。为此，我们也可以在Numpy中使用一个函数。所以合并Numpy线性。点积。像这样。😊。然后我们放入我们的协方差矩阵。这里我们也要小心。如果查看文档，它说特征向量以列向量形式返回。

一列。所有的。这里的一列是一个特征向量。为了便于计算，我们想反过来做。所以我们说特征向量等于特征向量转置。然后，我们对它们进行排序。所以为此，我们说在排序的索引中，是特征值的排序。我们想按降序排列，所以我们可以使用切片，从开始到结束。

我们先进行步骤1。所以这是一个反转列表的小技巧。现在我们有了按降序排列的特征值的索引。现在我们说我们的特征值等于特征值。使用这种顺序，特征向量也等于特征向量。根据这些索引。

现在我们存储前N个特征向量。所以我们说self dot components。嗯。这有一个小错误。self do components。等于，现在我们可以简单地说特征向量。从开始。也就是从0到self dot components。所以这就是为什么我们在这里转置它，以便可以轻松进行这种变换，还有这种变换。这是fit方法。现在我们只需进行变换。现在在这里我们。

不能忘记我们也应该在这里减去均值。所以我们说x。等于x减去self dot mean，这就是我们在这里开始的原因。现在我们可以进行投影并返回。所以我们说返回Numpy dot。然后我们将X投影到我们的。嗯。特征上。我们与self dot components进行点积。但现在我们再次需要小心。

因为在这里我们进行了转置，现在我们又想要一个列向量。所以这里我们又需要转置它。请自行仔细检查。现在我们完成了。这就是整个实现。现在我写了一个小测试脚本，使用著名的Iis数据集。然后我会创建一个PCA实例。

这个数据的维度是150乘以4，所以我们有105个样本和四个不同的特征。现在我们只想保留两个维度。因此，我们在初始化时输入2。然后我们拟合数据，接着进行转换。然后我打印出它们的形状。接下来我会绘制它们。所以现在我们有一个2D向量，可以在2D中绘制它。

让我们运行这个，看看它是否有效。哦，一页。所以我没有在这里写Python 3，但它仍然有效。让我们再测试一下。

所以这里我们有我们的4D特征向量转化或投影到2D中。我们看到所有三个不同的类别用不同的颜色绘制，所以我们可以看到我们的类别仍然很容易分开。所以是的，这很不错。这就是PCA，我希望你能理解所有内容。如果你喜欢的话。

请订阅频道，下次见，拜。😊。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P13：L13- K均值 - ShowMeAI - BV1wS4y1f7z1

大家好，欢迎来到新的机器学习教程。今天，我们将仅使用内置和Python模块以及Numpy实现K均值算法。K均值的目标是将数据集聚类为K个不同的聚类，这里我们有一个未标记的数据集。所以我们正在处理一种无监督学习技术，每个样本应该分配给与其最近的均值的聚类。让我们看看一些图像以了解这意味着什么。

这里是我们的未标记数据，现在在这种情况下我们想找到三个不同的聚类。所以应该看起来像这样。然后我们将标签分配给最近的聚类，即最近聚类的中心。所以这是我们想要做的，我们将如何实现这一点。这是一种迭代优化技术。首先，我们初始化聚类中心，随机选择一些样本并说这些是我们的第一个中心，然后我们执行这两个步骤，直到收敛。

首先，我们更新我们的聚类标签，这意味着我们将点分配给最近的聚类中心。聚类中心也称为质心。接下来，我们更新我们的质心。现在我们将新的中心设置为每个聚类的均值，我们重复这个过程，直到没有更多变化。让我们再来一次。

看一下图像以了解这个是如何工作的。首先，我们有我们的未标记数据集。现在我们随机选择三个质心。这里我画了它们。我希望你能看到它们。这些是我们的初始质心。现在我们将标签分配给数据中与最近质心的标签。这是我们的第一次初始化。

现在我们开始优化。因此，我们更新我们的质心。我们计算每个聚类的新均值。我认为这个质心会移动到这里，而这个可能会在这里。绿色质心可能会移动到这里。让我们看看发生了什么。是的，这是新的质心。现在我们更新我们的标签。

我们的标签。所以现在我们检查每个标签的最近质心。也许这些会变成蓝色，而更多的会变成橙色。所以这是下一步。现在再次更新我们的质心。我认为这个会进一步向右移动，而这个会向上移动，这个可能会保持不变。所以这是下一步。

现在再次更新标签。我认为这些现在会变成橙色，而这些会变成蓝色。现在我们几乎完成了。也许这里有一些微小的变化。再次更新质心，然后再次更新标签，然后是质心，然后是标签。现在没有更多变化。因此，我们已经收敛了。这就是整个方法。

我们需要的唯一数学是欧几里得距离。所以我在关于K近邻算法的教程中已经向你展示过这个。两个向量之间的欧几里得距离定义为平方和的平方根。

这就是我们所需的一切。所以现在我们可以开始。让我们导入nuy作为N P，当然。然后我会说，我将设置一个随机种子，假设是42，你不需要这个，但我想稍后重现我的数据。由于我们使用随机初始化，我希望得到相同的结果，或者我想重现我的结果。所以我会在这里设置一个随机种子。

现在让我们先定义我们的欧几里得距离函数。所以两个向量的欧几里得距离。x1和x2。所以这将是一个全局函数。我们必须实现我刚才给你展示的公式，我们可以用一行来完成。所以我们说返回，nuy首先，我们有平方根。然后我们有sum nu pi sum。然后我们对所有距离求和。

我们可以说x1减去x2的平方。所以平方距离。这就是函数。现在我们可以实现我们的K均值类。所以这将有一个init。它有self。然后它会得到一个K。所以这将是聚类的数量。默认情况下，假设是5。然后它会得到一个max its。这是最大迭代次数。

我们要为我们的优化做的事情。默认情况下，假设是100。然后它还会得到一个布尔值plot steps等于false。所以你不需要这个，但我将实现一个附加功能来绘制不同的步骤，就像我们刚刚看到的那样。所以，首先，我们设置它们或存储它们。所以我们说self dot K等于K，self dot max iters等于max iters，self dot plot steps等于plot steps。

现在我们创建空的聚类和中心点。所以self dot。Clus等于。Oops。Equals。现在我们要小心，因为这很重要。所以这是一个列表的列表。每个聚类的样本索引列表。开始时，每个聚类都有一个空列表。所以我们说，我们使用列表推导，然后说我们有一个空列表，underscore在范围self dot K中。

对于每个聚类，我们初始化一个空列表。然后我们说我们的self dot centroids等于。这也将是一个空列表。这里我们将存储每个聚类的特征向量或均值特征向量。所以每个聚类的均值特征向量。这里我们有实际的样本。我们只存储索引。这很重要。现在我们可以继续。

通常我们会实现fit和predict方法。但由于我们这里使用的是无监督学习技术，并且没有标签数据，我们只需要实现predict方法。所以，我们不需要fit方法。现在让我们定义我们的predict方法。用self和X。这里，首先，让我们存储我们的数据。

self x等于x。然后是维度。因此self number of samples和self dot number of features等于x dot shape，因为我们稍后需要这个。和往常一样，这是一个nuy和D数组。因此，是的。现在让我们执行刚才讨论的步骤。首先，我们要初始化我们的。我们的中心点。然后我们进行优化。因此在这里我们可以说四个下划线在范围内self dot max its。

现在在我们的循环中，首先更新我们的簇。所以，假设我们更新簇。然后，我们更新中心点。接着检查是否收敛。检查。如果收敛了。那我们就跳出循环。最后，我们想要将样本分类为其簇的索引。因此这里我们说返回。返回。簇标签。这就是我们需要做的。现在让我们开始吧。

假设我们想要初始化我们的中心点。我们想要随机选择一些样本。因此假设随机样本索引等于。现在我们使用列表推导式。哦不，抱歉。在这里我可以使用nuy dot random dot choice。这将获取self dot number of samples和self dot K，我们还需要说replace等于false，因为我们不想选择相同的索引两次。

这将是一个大小为self dot K的数组。对于每个条目，它将随机选择0到样本数量之间的一个值。现在，我们分配。与此索引对应的样本给我们的中心点。因此我们说self dot centroids等于。现在这里我们使用列表推导式。所以我们说self dot X。

当前索引为index的随机采样索引。因此这是我们中心点的初始化。现在我们可以进行优化。因此首先。我们说更新我们的簇。因此我们说self dot clusters等于self dot create clusters。这将获取self dot centroids。这是一个帮助函数。

创建我们现在要实现的簇。因此定义create clusters，参数为self和cents。在这里，我们将样本分配给最接近的中心点以创建我们的簇。首先，我们有一个空的列表列表用于我们的簇。现在我们遍历我们的数据。

所以我们说对于index和sample在enumerate self dot X中。因此这个enumerate函数将给我们当前索引和当前样本。现在我们想要获取最近的中心点。我们想要获取它的索引。因此我们说centroid index等于self dot closest。Centroid。这将获取当前样本。

然后它将获取中心点。这将是另一个帮助函数，我们会在稍后创建。但现在我们继续。因此，当我们有中心点索引时。我们附加。或者取当前。簇，因此这个。中心点索引的簇。然后我们附加。当前索引。所以我们把当前样本索引放入最近的簇中。

然后我们返回我们的簇。这就是我们如何创建我们的簇。现在我们需要定义closest centroid函数，参数为self、样本和中心点。在这里，我们计算当前样本到每个中心点的距离。然后，我们想要获取。

质心或质心的索引，其具有最近的距离。因此，让我们用列表推导计算所有的距离。在这里，我们使用已经有的欧几里得距离函数。因此，样本与每个质心点之间的欧几里得距离。因此，点4点在质心中。

然后我们想要的，我们这里有所有的距离，现在我们想看看哪个是最小的，或者是最小距离的索引。因此，我们可以在这里使用Ny arc min。所以我们说最近的索引等于这些距离的Ny arc min。然后，你只需返回它。因此，返回最近的索引。所以现在我们有这个。

现在我们创建了我们的簇，现在我们可以继续优化。因此，在这里我们更新质心作为下一步。但在此之前，我们想要存储质心。所以我们说质心alts等于self dot centroids，这样我们可以稍后检查收敛情况。然后我们说self dot centroids等于self dot get。质心。这。

这样会得到自我簇。所以这是另一个功能。这个将把簇的均值分配给质心。因此，对于每个簇，我们现在计算均值。让我们定义这个，定义。获取。可。注意我是否得到了质心。这个得到自我和簇。因此，在这里，我们在开始时用零初始化我们的质心。

所以我们说质心等于nuai零。这样将是self K和self dot N特征的大小。而这里应该是一个二元组。所以我们必须小心这里。因此，对于每个簇，我们将存储特征Ea。这就是为什么它必须具有这个维度。现在我们遍历簇。因此，我们说四个簇索引和簇在enumerate.Cluters中。

然后我们计算簇均值。因此，簇均值等于N pi均值我们的自我.x和这个簇的索引。🤢，而且这应该沿着第一轴。因此，再次让我们看看这意味着什么。因此，正如我所说，我们的簇是一个列表的列表。所以如果我们只有一个当前簇，那么这是一个列表，而这是一个在这个簇中的索引列表。

所以如果我们用这个索引调用self dot X。它将仅返回在当前簇中的样本。在当前簇中。然后我们计算均值。所以这就是将要发生的事情。现在一旦我们得到了均值，我们将其分配给当前簇的质心。因此，我们说当前的质心等于当前簇的均值。

然后我们完成了，可以返回质心。所以，是的。现在我们有了新的质心。现在我们检查是否收敛。因此，我们说如果self dot。已收敛。那么我们将中断，所以我们可以在这里停止。这将得到旧的和新的质心。因此，self do cents。这是另一个帮助函数。这个将简单。

计算所有质心之间的距离，检查是否为0。所以，定义is converged。self和旧的新质心。所以我们再次计算距离，使用较少的理解。这变成了相等。这里我们计算质心旧的欧几里得距离。

当前质心向量和新的质心，self.dot.k范围内的i。对于每个聚类，它将查看旧的和新的质心向量，计算欧几里得距离并将其存储在列表中。然后我们可以返回一些距离，等于0。这是一个内置函数，它会遍历这些条目并进行计算或求和。

如果这是0，那么我们的质心就没有更多变化。所以我们说它已经收敛了。好吧，现在我们有这个。现在我们想要返回聚类标签。我们可以返回self.dot.get cluster labels。这样就能获取self的聚类标签。对于每个样本，我们将得到它被分配到的聚类的标签。

让我们在这里创建这个。定义get cluster labels和clusters。首先，我们说我们的标签等于一个大小为self.dot number of samples的空数组。对于每个样本，我们想返回它被分配的聚类。但是这里要小心，因为这些标签并不是我们数据的实际标签，因为我们不知道它们。

这只是它被分配到的聚类的索引。好吧，现在我们遍历聚类。对于聚类索引中的聚类和enumerate.cluters中的聚类。然后我们遍历当前聚类。对于聚类中的每个样本索引，这又是一个列表的列表，每个聚类都有一个包含该聚类中所有样本索引的列表。

对于当前聚类中的每个样本索引，我们说样本索引的标签等于当前聚类索引。然后我们返回我们的标签。现在我们完成了。我还想实现一件事，但你不需要的是绘图函数。定义find plot和self。在这里，我们将使用matplotlib，所以我可以说import。

使用plt.plot，我不打算在这里解释细节，但如果你想看到更多关于我的plot的教程，请留下评论。让我们实现绘图方法。在这里，我想简单地绘制数据及其所属的聚类，以及质心。让我们创建我们的图形。

设置ax等于plt.subplot，并给它一个固定的大小，比如12乘8。然后我们遍历我们的聚类。对于索引中的每个i，在self.dot clusters中。现在我们得到当前的点，point等于self.dot X的索引，但我们必须在这里转置它。现在我们散点图。

在这里我解包了这个点。现在，这将绘制所有的点。对于每个聚类，它将使用不同的颜色。现在我们绘制所有的质心。所以对于点在 self.dot cents。A x.dot.scatter。再一次，我们解开我们的点。然后我们说 marker 等于。X，所以它有一个标记符号，color 等于。

黑色和线宽等于 2。所以，我们必须说 PLT.dot.show，当然。这个是绘图函数。在我们的优化过程中，如果我们将 plot steps 设置为 true。那么我们想在更新聚类后进行绘图，所以我们说。如果 self.dot Ploot steps，那么 self.dot plot。再一次，我们还想在更新质心后进行绘图。

所以我们把它放在这里。现在我们完成了。所以现在让我们运行这个。我希望一切都能正常工作。让我们清理一下并运行我们的脚本。哦。我在这里漏掉了一个逗号，行 37。更新质心，旧的质心等于。当前的！

所以再次，让我们试一下。现在它正在工作。这里我创建了一个包含四个不同聚类的数据集。我们可以看到它正确地识别了它们。

所以让我们把 plot steps 设置为 true，并且在最后不绘图。现在让我们再运行一次！

要查看不同的步骤。所以这里，这是我们初始化之后的状态。我们随机选取了一些样本，并表示这些是我们的第一个质心。因此，初始化可能不是很好，但。你可以在后面正确找到聚类。那么我们来看看发生了什么。

所以现在我们开始优化。现在在下一步中，我们正在计算新的质心。我认为蓝色聚类的质心正在移动到这里，而橙色质心正在移动到下面。让我们看一下下一步。所以是的，现在我们在更新标签。我认为这些不再是橙色，而是红色和绿色。所以。是的。

还有一些现在变成了红色。现在我们再次更新我们的质心。我认为这将进一步移动到这里。这个会向下移动。这些会移动一点。所以是的。现在我们再次更新我们的标签。我认为更多的将变成红色，这里更多的将变成绿色。所以，现在再次。

我们更新我们的质心。我认为这将进一步移动到这里。红色质心将移动到这里。这已经很好了。绿色的质心也移动到这里。我认为。是的，就是这样。现在我们再次更新标签。现在再次，质心和标签。现在我认为我们已经收敛了。所以，是的。

这就是 K 均值如何工作的。我希望你理解了一切。如果你喜欢，请订阅频道，下次再见！

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P15：L15- LDA - ShowMeAI - BV1wS4y1f7z1

嘿，大家好，欢迎来到新的机器学习Sc教程。今天，我们将使用Python和Numpy实现线性判别分析算法或LDA。LDA是一种降维技术，是机器学习管道中一个流行的预处理步骤。

LDA类似于我在之前的教程中展示的PCA技术。PCA和LDA的方式和实现有很多相似之处。因此，我强烈建议你先观看这个视频。现在在我们跳到代码之前，先快速谈一下LDA的概念。目标就是。

正如我已经说过的，这是特征减少。因此，我们希望将数据集投影到一个低维空间，并找到良好的类间分离。😊在这里，我们有PCA和LDA之间的区别，在PCA或主成分分析中，我们想要找到一个新的轴，以便最大化在新轴上的方差。而在LDA中，最大区别是我们知道特征标签。

这是一种监督技术。在这里，我们希望找到新的轴，使得类间分离最大化。如果你看看这里的图片，我们有两个不同的类。然后我们可以将数据投影到Y轴或X轴上。在这种情况下，Y轴不是一个好的选择，但X轴是一个不错的选择，因为在这里我们仍然有良好的类间分离。

这就是LDA的概念。我在这里再次列出了PCA和LDA之间的差异。因此，在PCA中，我们想要找到最大化数据方差的成分轴。而在LDA中，我们也想这样做。在绿色区域和蓝色区域内，我们仍然希望单个特征之间有良好的方差。

另外，我们还对最大化多个类之间分离的轴感兴趣。因此，这里基本上应该在新的轴上最大化这个差异。是的，LDA是监督学习。所以我们知道我们的标签，而PCA是无监督的。这是一个重要的事情，我们应该记住。

现在让我们跳到数学部分，这里我们有所谓的散布矩阵。我们有两个不同的散布矩阵，类内散布和类间散布。这基本上代表了我在这里所谈论的内容。因此，类内散布确保我们在一个类内的特征被很好地分开。

而类间散布确保两个或所有类被很好地分开。如果我们将其转化为数学，我们必须处理均值和方差。因此，类内散布的公式是对散布的总和，每个类的散布是特征值减去所有特征的均值的总和。

仅在这个类中，然后乘以相同的转置。然后我们对该类中的所有特征求和。因此，这基本上与我们想要计算协方差矩阵的 PCA 算法是相同的。因此，这几乎是协方差矩阵的相同公式。

只是在开始时我们没有缩放。因此，这是类内散布器。然后是类间散布器，这里的公式是对所有类求和。然后对于每个类，我们有该类中的特征数量，哦，不，应该是该类中的标签数量，然后乘以均值。

所以这个 x bar 是该类特征的均值减去所有特征的均值。所以总的。然后乘以相同的转置。所以这两者是我们必须计算的矩阵。然后我们计算类内散布器的逆，并将其与类间散布器相乘。

这是我们必须解决的特征值和特征向量问题。所以这与 PCA 中的情况相同。我不会再详细说明了。因此，请确保你知道特征值和特征向量是什么。基本上，我们必须做的是计算这些公式的特征值。

然后让我们再次看看整个方法。所以在这里我对它进行总结。首先，我们想要计算类间散布器和类内散布器。然后我们计算类内散布的逆，并将其与类间散布相乘。然后我们计算特征向量和特征值。

然后我们根据特征值按降序排序特征向量，然后我们只选择我们指定的前 k 个特征向量。所以仅保留我们想要的 k 个维度，这些特征向量被称为线性判别，因此它才有这个名称。接着我们将原始数据点转换到这 k 个维度，这种转换基本上就是一个投影。

通过点积。因此，这整个方法与 PCA 算法中的方法是相同的，只是我们必须为不同的公式解决特征值和特征向量问题。所以这就是方法。现在让我们跳到代码部分。

所以，当然，我们导入 nuy S N P。然后我们定义我们的类。我们称之为 LD A。接下来我们定义我们的初始化，它有 self。并且它还获取我们想要保留的组件数量。在这里我们简单地存储它。所以我们说 self 和。Components 等于 n components。我们还创建一个变量，称为 self dot linear this。Preriminence。

这一开始是 none。在这里，我们想存储我们计算的特征向量。然后我们定义我们的 fit 方法。在这里我们有 self，还有 X，还有 y。因为记住，这是一个监督技术。接着我们还实现了一个不是 predict 的方法，而是称之为 transform。变换与 PCA 中是相同的。

在这里，我们想获得想要投影的新特征。所以让我们实现 fit 方法。在这里，首先，我们想要获取特征的数量。我们通过说 x dot shape 来获取这个值，然后是 index1。所以 index0 是样本的数量，而我们只想得到特征的数量。

然后我们还想获得所有不同的类别标签。我们称之为类标签，这等于 nuy，然后我们可以应用 y 的唯一函数。因此，这将仅返回我们标签中的唯一值列表。现在我们想计算两个散布矩阵。

所以 S underscore W 是类内的聚合，S underscore B 是类间的聚合。让我们开始吧。首先，我想计算所有样本的均值，因为我们需要这个值。对于一个公式，我们说均值。总体均值等于 numpy dot mean of x，然后沿着轴 0。接着让我们初始化两个矩阵。所以我们说 S W 或 S underscore W 等于 nuy zeros。

所以我们希望用零填充这个，并希望将其大小设置为特征数量乘以特征数量。类间散布也是同样的处理。所以我们用零初始化这个。稍后，我们想用例如鸢尾花数据集的特征来测试这个。所以这个大小是。我认为是 150 个样本和四个特征。所以这个大小是 4 乘以 4。

这在四次四的情况下是相同的。

现在我们需要应用这两个公式。因此，我们需要对所有类进行求和，然后应用这两个公式，这样我们就可以在一个循环中完成。

所以我们说对于我们计算的类标签中的 C。首先，我们想要获取该类的样本。因此我们说 X，C 等于 X，其中 Y 等于 C。在当前迭代中我们有这个标签。然后我们想从这些特征中获取均值。mean C 等于。这是 Ny dot mean of X C 沿着 x 为 0。所以与我们在这里做的相同。

但仅针对这一类中的特征。然后我们来看看类内的情况。

公式。因此，在这里我们有特征，然后减去均值。基本上这是点积乘以转置。

所以让我们来做这个。在这里我们说我们的 S within 加上等于。因为在这里我们对所有类求和。所以加上等于。然后我们说 x C。

减去均值 C。然后我转置这个并计算点积，和我们在这里做的一样。所以。这里我们需要小心。如果我们再看一下公式，我们会看到我必须在最后转置项。这里我转置了第一个项。这是因为我们这里有一个额外的求和。因此，我们对这个类别中的所有样本都这样做。我们在一个操作中用点积来进行这个求和。

所以使用我们的 numpy 操作。然后我们必须注意尺寸。因此，我们最后想要的是一个像这里一样的 4 乘 4 矩阵。因为我们将其添加到这些矩阵中。在开始时，我们的 X C 和我们的均值 C 的大小为该类别中的样本数量乘以 4。😊。

所以我们必须调整这个顺序。我们必须说这是 4 乘以该类别中的样本数量。因为当我们将其相乘或计算与这里未转置的这个点积时。因此，我们这里有该类别中的样本数量乘以 4。然后如果我们乘以这个，就得到一个大小为 4 乘 4 的矩阵。

所以这些是矩阵操作的基本规则。确保你理解这一点。因此，第一个矩阵的最后一个维度必须与第二个矩阵的第一个维度匹配。然后最终输出大小由这两个大小组成。这就是为什么我们必须在这里转置第一个项。因此，这可能有点令人困惑。

确保自己仔细检查这一点。然后我们得到了类内散布。现在对于类间散布，我们想要的是该类别中的样本数量。我们通过说这是等于 X，C 点形状来得到这个 N C。在这里我们希望得到索引 0，因为我们想要样本数量。

然后在这里，我们必须小心，因为我们需要重塑我们的向量。假设我们的均值除。

再次查看公式。在这里。我们计算该类别的均值减去总体均值。哦，来吧！

所以这是，假设我们有该类别的均值减去总体均值。这是单维的，但我们想要的是，如果我们查看形状，则会说四，零。但我们希望它是 4 乘 1。因此，我们必须说重塑。然后是特征数量乘以 1。这是因为。

再次，如果我们查看最终的乘法。与我们正在进行的层次相同。我们想要一个大小为 4 乘 1 的矩阵，并将其与一个 1 乘 4 的矩阵相乘。因此，这基本上是 4 乘 1 转置。然后我们得到一个 4 乘 4 的输出。这就是为什么我们必须在这里应用重塑。然后我们说 S B。加等于。

然后这里我们有这个类的样本数量乘以。这里有均值的点积，均值差的转置，这两个都是我们的矩阵。我们终于得到了这些矩阵。现在，正如我所说，我们必须获取类内散布的逆，并与类间散布相乘。所以我们得到逆。也是用numpy获取的，通过说nuy L alk。Dot in of S W。然后点积。

我们与类间散布相乘。我们称之为a，并将其存储在这个矩阵中。然后为此，我们必须解决特征值和特征向量问题。所以我们必须计算特征值和特征向量。接下来的代码与PC A算法完全相同。所以请检查一下。

所以我们通过说，这是numpy。Lin Ark dot Ig of a来获取特征值和特征向量。然后我们对特征向量和特征值进行排序。对于这一点，和我们在PC算法中做的相同。所以我们通过说特征向量等于特征向量点T来转置特征向量。这样可以简化计算，然后我们对特征值进行排序。

所以我们说索引等于nuy dot arc sort off。在这里我们说特征值。为了使其更美观，我们实际上想要特征值的绝对值。然后我们想按降序排序。因此，我们使用这个切片并用步长为-1的这个小技巧从开始到结束。这样就可以将索引反转。然后我们就得到了降序排列。

现在我们通过说特征值等于这些索引的特征值，按降序获取特征值，特征向量也一样，特征向量等于这些索引的特征向量。然后我们只想存储前n个特征向量。

我们将其存储在我们这里的线性判别中。所以我们说self dot。线性判别等于特征向量。从开始的最大特征向量和最大或最高的特征值。然后是self dot指定的分量数量。

所以这是我们保留的维度数量。现在我们终于完成了拟合方法。这就是整个拟合方法。然后在一个变换下，我们要做的唯一事情就是将我们的数据投影到这些新分量上，而这个变换无非就是点积。

所以我们可以将其写成一行，并返回nuy dot。然后我们将数据投影到self dot线性判别上。由于在这里进行了转置，我们必须在这里再次转置。然后我们完成了。这同样是PCA中的内容。请自行仔细检查。

现在我们完成了，可以运行脚本。这里我有一个小的测试脚本，这基本上和PCA测试中的相同。唯一要交换的是，我们创建LEA并希望保留两个分量，然后调用拟合和变换。

我们对Iris数据集执行这个操作，然后我将新的标签绘制在新的两个维度上。让我们运行这个。假设是Python LDA。下划线测试饼图。希望一切正常。是的，这里我们看到我们的特征在只有两个维度中被转置。我们看到类别非常好，彼此分离。

所以我们有三个不同的鸢尾花类别。我们看到这个是有效的。

所以我们的LDA特征降维方法有效。请再次将其与PCA算法进行比较。希望你喜欢这个教程。如果你喜欢这个，请订阅频道，我们下次再见，拜。😊。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P16：L16- 从 CSV 加载数据 - ShowMeAI - BV1wS4y1f7z1

嗨，大家好，欢迎来到另一个机器学习教程。在我之前的所有机器学习示例中，我直接使用来自 S K learn 数据集模块的可用数据。很多人问我如果他们有自己的数据集，应该如何加载数据。因此今天，我想向你展示如何从文件中加载数据。我将展示四种不同的方法。

一个使用纯 Python，两个使用 Numpy，一个使用 Pandas 库。😊。我还将向你展示如何处理缺失数据以及如何获得正确的数据类型。所以请确保观看到最后。在这个教程中，我将使用基于垃圾邮件的数据集。所以如果我们搜索一下这个。

然后第一个条目引导我们到这一侧。这是一个获取机器学习数据集的热门网站。在这个基于垃圾邮件的数据集中，我们想将电子邮件分类为垃圾邮件或非垃圾邮件。因此，我们可以转到下载文件夹并加载 spambased.dot 数据。我已经做过了。所以我把这个放在这里。这是 Csv 格式的，即逗号分隔值。

通常这里的后缀是 .Csv，但这里是 .data，这也没问题。所以让我们开始，看看如何加载这个。

所以首先，让我们使用纯 Python 和 CSV 模块加载这个文件，因此我们可以导入 CSV。这在 Python 中已经内置了。然后让我们指定我们的文件名等于。所以让我们再看一下。这被称为 spam basedase data。所以我们称它为 spam based.dot 数据。现在我们说以读取模式打开我们的文件名 S F。

然后我们说我们的数据等于。然后我们可以使用 Csv 模块并调用 reader。在这里，我们必须提供我们的 F 和分隔符。因此，分隔所有数据的值。在这种情况下，它是一个逗号。这将给我们一个迭代器。然后我们可以使用列表方法将其转换为列表。

现在我们将数据转换为列表。所以让我们把它转换为 Numpy 数组。让我们导入 Numpy 的 S 和 P。然后在这里，我们说我们的数据等于从数据创建的 nuy 数组。然后，例如，我们可以打印 data.dot.shape。让我们运行这个。然后我们看到它成功了。

如果我们看看这个网站。然后我们可以看到样本数量是 4601，特征数量是 57。因此这里我们有 4601 和 58。这是因为我们的。

数据当前同时包含特征和类别标签。因此在这种情况下，类别标签是最后一列。所以我们想做的下一件事是将我们的列表分成特征和类别标签。为此，让我们获取形状。所以我们说样本数量和特征数量等于 data.dot.shape。

然后我们使用列表切片。我们想做的第一件事是将其减少一个。因此假设特征数量减去1，因为我们只有57。然后我们使用列表切片。因此我们说x等于数据，然后我们说冒号。因此我们想要所有行，对于列，我们希望从第0列开始，一直到特征数量。

并且最后一列被排除了。因此这将仅包含特征，y是数据。同样，我们想要所有行，但只有最后一列。现在我们已经拆分了这个。现在，例如，如果我们打印x.dot.shape和y.dot.shape。如果我们运行这个，我们会看到它成功了。现在我们有了正确的格式。例如。

现在我们可以把它放进去，或者把它给我们的分类器用于fit方法并开始训练。这是我想展示的第一种方法。然而，我不推荐这种方法，因为它通常较慢，并且需要的代码比其他方法更多。我现在要给你展示的其他方法。但你仍然应该知道如何手动加载文件。

所以我们现在忘记这一点。并且我们来删除这个。现在让我给你展示如何在Nmpy中做到这一点。我们在Numpy中只需一行代码即可实现。因此我们可以说数据等于Numpy。然后我们使用一个叫做load T X T的方法，这也需要文件名和分隔符等于逗号。这就是我们所需要的一切。

所以现在如果我们运行这个。然后我们看到它也成功了。这要简单得多，并且更快。这是我们可以使用Nmpy的第一种方法。然而，还有一种更好的方法，我推荐这种。因此数据等于nuumpy，第二种方法叫做Cheen from T X T。这也需要文件名和分隔符等于逗号。

现在如果你运行这个，那么我们也看到它成功了。因此这是我在nuumpy中首选的方法。它基本上与这个一样，但为参数提供了更多选项。例如，在这里，我们可以处理缺失数据，这我想在一秒钟内给你展示。因此，是的，这是使用numpy的函数。现在作为最后一件事。

我想向你展示如何用pandaas做到这一点。如果你已经熟悉pandaas，你也可以这样使用。这里有一个函数叫做read CSV。因此我们说数据框，因为在pandas中我们通常处理或称之为数据框。然后我们说PDd.dot.read_ CSV，再次给出我们的文件名，我们也可以给它分隔符等于逗号。

然后我们把它作为数据框。接下来我们可以把它转换为numpy。因此我们可以说数据等于data frame to nuy to Num pi。然后我们可以做与这里相同的事情。例如，我们可以将其拆分为x和y。现在，如果我们运行这个。我们会看到它也成功了，但这里我们少了一行。

这是因为在这里我们必须小心，因为 pandas 尝试读取一个标题，而在这种情况下我们没有标题。所以我们必须指定 header 等于 none。然后如果我们加载这个，就会发现它是正确的。因此，这就是我们如何使用 pandas。两者都可以。所以如果你只想使用 numpy，我会推荐使用这个。如果你熟悉 pandas，那么我会使用这个，因为它提供了更多选项。

而且这样也稍微快一些。所以，是的。这就是你如何加载这个。现在让我们谈谈数据类型、标题和缺失数据。一件好习惯是，如果你知道的话，提前指定数据类型。所以。例如，在这里我们可以给出参数，data type 等于，例如，nu load 32，下面。

我们也可以对 pandas 函数做同样的事情。所以现在如果我们运行这个，我们会看到这个词 2。例如，我们也可以打印数据类型。那么，我们看到。哦，这里我们看到它只有一个 Nmpy 数组。让我们打印一下数据类型。我们说 0，0。然后我们应该看到，它是一个 Ny float 32，最好总是指定这个，如果你知道的话。

如果你知道数据类型，就把它放在这里，因为否则函数必须自己推断数据类型。这通常会花费更多时间。而且可能也会出错。是的，一些算法，一些分类器期望这是 float。我认为大多数都期望这是 float。因此这就是我在这里推荐的做法。

如果你不把它放在这里，想稍后转换，顺便说一下。你仍然可以通过说 data 等于 nuy S array 来做到这一点。然后你放入数据。然后作为数据类型，data type 等于，然后这里你的 float 32。是的，这就是你可以用数据类型做的事情。现在让我们谈谈标题。

在这种情况下，我们没有标题。但假设在我们的文件中，我们有一个标题，其中包含特征描述，例如特征 1、特征 2，等等。所以在加载过程中，我们当然不希望这个。我们可以先运行这个，看看会发生什么。然后我们会收到一个错误，因为我们的函数无法识别第一行。

在这里我们可以简单地跳过这个。因此对于 text 方法中的 ch，我们需要指定 skip header。然后是我们想要跳过的行数。在这种情况下是 1。对于 pandas 函数也是一样。但是这里我们必须小心，因为参数叫做 skip rows 等于 1。现在如果我们运行这个，那么这又成功了。我们。

再次，得到了正确的形状，并且跳过了标题。如果你这里有标题的话，这就是你应该做的。最后，我想谈谈缺失值。很多时候，例如，可能会有缺失值。比如这里，我们只是有一个逗号然后没有条目。所以如果你运行这个，我们来打印一下。

例如，让我们打印X，然后在第一行打印特征0到5。这里也是一样。所以现在如果你运行这个。我们看到我们有N A N。这代表不是数字。这些函数可以自己判断出来。所以如果它是空的，或者我认为如果有一个破折号或N A N。

那么它们可以自动看到这不是一个数字。但有时你这里也有一个字符串，这没有意义。现在，如果我尝试运行这个，那么这应该会产生一个错误，因为它无法判断这里的字符串。因为你说这些应该都是浮点数。所以你可以在这里指定额外的缺失值。

通过说missing.Values.等于，然后在这里放入一个列表。在这里我们可以放入hello。对于pandas函数，参数是N A values。然后你必须使用一个列表。因此，我建议在需要参数时查阅文档。你不需要记住这些。因此这里我们说hello，然后它知道应该忽略这些。

所以现在如果你运行这个，之前的方法又成功了，它用不是数字填充了这些“hello”。你也可以指定应该用什么来替代。因此这里我们可以使用参数填充值等于。你可能想把这个设置为0。但在这个例子中，建议我们可以看到，我会把这个设置为9，9，9，9，作为浮点数。

对于pandas函数，加载后我们可以调用data frame，然后设置data frame fill N A。不是数字填充为9999。0。现在，如果我们运行这个。我们看到这里用9，9，9，9替换了不是数字。这里我必须说，当然，data frame等于这个新data frame。现在，如果我再次运行这个。

然后我们看到对于pans方法它也有效。这就是我们如何处理缺失的数字。通常你想把这个设置为0，然后你应该就可以开始了。因为许多初学者看到的错误是因为缺失的数字。然后你的算法崩溃，因为它不知道如何处理这个。

所以一定要确保处理缺失的数字。然后我建议指定数据类型。现在你还应该知道如何处理标题。嗯，这就是你应该知道的两个首选方法：Thempy Chen的文本方法和pandas的Re CS SV方法。所以，是的，这就是你需要的全部。希望你喜欢这个教程。如果你喜欢这个。

请订阅频道，下次见，拜拜。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P2：L2- 神经网络 - ShowMeAI - BV1wS4y1f7z1

嗨，大家好。欢迎来到一个新的教程。这是一个名为“从零开始学习机器学习”的新系列的第一期视频。在这个系列中，我们将仅使用内置的 Python 模块和 Numpy 实现流行的机器学习算法。所以今天，我们将从关键的最近邻算法开始，简称 K-N 算法。😊 K-N 的概念非常简单。一个样本通过其最近邻的投票来进行分类。

所以我们来考虑一个包含两个类别和一个二维特征向量的例子。

所以让我们看看这个图。这里我们有两个类别，蓝色类别和橙色类别，我们有两个维度的特征向量。所以在这个轴上是 x1，在这个轴上是 x2。我们这里有一些训练样本。然后对于每个我们想要分类的新样本。

我们计算这个样本到每个训练样本的距离。然后我们查看最近的邻居。在这个例子中，我们查看三个最近的邻居。就是这些。然后我们根据最常见的类别标签来选择或预测标签。

所以我们有两个蓝色的类别和一个橙色的类别。所以这将是一个蓝色类别。这就是 K-N 的整个概念。我们还需要知道的是，为了计算距离，我们使用了欧几里得距离。

在二维示例中，两个点的欧几里得距离定义为平方根，然后我们对每个特征向量组件计算平方差。所以我们有 x2 减去 x1 的平方加上 y2 减去 y1 的平方。所以这是二维情况下的欧几里得距离，而在更一般的情况下，公式是。

定义为。这个，所以它是从 I 等于 0 到 n 的总和的平方根，其中 n 是维度的数量。然后我们对每个组件进行求和，对于每个组件，我们计算平方距离或平方差。所以这是欧几里得距离，这就是我们在实现 K-N 时需要知道的一切。

所以让我们开始。首先，我们定义一个名为 K-N 的类。

当然，这有一个初始化方法。所以我们会得到一个 K。这是我们想要考虑的最近邻的数量。并且这还会有一个默认值。所以默认是 3。在初始化中。哦，抱歉。我们定义初始化。所以在初始化中，我们只是想存储 K。所以我们说 self.dot K 等于 k。

然后我们想在这里实现的就是遵循其他机器学习库的约定。例如，心理学习库。因此我们有一个。嗯。拟合方法。这将拟合训练样本和一些训练标签。通常这将涉及到训练步骤。所以我们想要实现这个。

然后我们还想实现一个预测方法。抱歉，这里也有self。以及预测方法。因此，我们想要预测新样本。这是我们想要实现的方法。在继续之前，首先让我们看看我们的数据的样子。这X和Y是什么？

我写了一些测试脚本。在这里我使用了著名的鸢尾花数据集。你可能听说过这个。所以我可以从心理学习模块中获取这个数据。然后我将生成一些训练样本和一些测试样本，以及相关的训练标签和测试标签。

首先让我们看看这些训练样本的样子。我们想打印一下它的形状。这是一个形状为120 x 4的n维数组。所以120是样本的数量，而4是每个样本的特征数量。例如，让我们打印第一个样本。它包含四个特征。

所以这就是我们的训练样本的样子。现在让我们看看我们的训练标签。这是一个一维行向量，大小也是120。因此，对于每个训练样本，我们都有对应的标签。如果我们打印出来，我们会看到这是一个只有一行的一维向量。

现在我们看到的标签有0、1和2。这是一个三分类问题。我们也来绘制一下。嗯。比如说，我这里绘制的是前两个特征，以便我们有一个二维的情况。这就是我们的数据的样子。我们有三个类别，红色、绿色和蓝色。

是的。这就是我们的数据的样子。现在我们可以通过实现这一点继续。所以在我们的拟合方法中。在K和N算法中，这并不涉及训练步骤。因此，我们在这里所做的就是简单地存储我们的训练样本，然后我们可以稍后使用它们。所以我们可以说，存储它们。因此我们可以说self。

然后我们将X train设为X，而self Y train设为y。这就是我们的拟合方法的全部。现在，对于我们的预测方法，这将获取多个样本。因此，我们可以看到，因为我们使用了大写的X。这样可以有多个样本，因此我们可以写一个小的辅助方法。我们想对每个样本执行这个。

我们想说我们想要获取预测的标签。等于，然后。我们使用。或者我们写一个帮助方法，称之为下划线预测。这个方法只会处理一个样本。所以在这里我们使用列表推导。然后我们想做的是调用这个 self。预测。使用一个样本 X。然后我们想对我们所有的样本进行这个操作。在我们的测试样本中。

所以对于大写的 x 中的小 x。然后这将是一个列表。让我们把它转换为一个 nuy 数组，然后。这是我们的预测方法。当然，我们需要导入 Nmpy。所以我们说导入 Ny S 和 P。现在，我们的下划线预测方法看起来如何？再来看看。

在这里的图中。所以我们要做的是。我们想计算所有的距离。然后查看最近邻居和最近邻居的标签。然后我们进行投票，选择最常见的类标签。让我们在这里写一些注释。首先，我们想计算距离。

然后，我们想要获取最近的邻居，所以获取 Ca。最近的样本，并且。我们也想要获取标签。然后我们进行投票。因此，我们想要得到最多的。来自类标签。所以。让我们这样做。让我们说，距离等于。正如我所说。我们在这里使用欧几里得距离。让我们定义一下。

我们希望将其定义为一个全局函数。因此，你可能想把它写在一个单独的文件中，或者在某个工具类中调用它。因此在这里我将简单地在同一个文件中做。所以我说。要。Kiyian。这两个特征向量的距离。我们说 x1 和 x2。现在再来看看公式。这是平方根。然后是每个平方距离的总和。所以我们得到平方根。

所以我们可以说。

Nampai 的 dot S，Q，R T。

然后我们有了总和。所以我们可以使用 numpy 的 dot sum。这样就可以计算每个的总和。

特征向量组件。在这里我们有平方差。所以我们可以说 x1 减去 x2 的平方。

所以这就是我们需要的全部。我们当然想返回这个。

现在在我们的预测方法中。我们要做的是。我们想计算这个新样本与所有训练样本的距离。因此，我们在这里也使用列表推导，并将这个新的测试样本与我们计算的欧几里得距离结合起来。因此，然后对每个训练样本进行计算。所以我们说小 x train。

然后我们想为此计算。在 capital 中，或在 self.dot。X train。所以现在我们有了所有的距离。现在我们想获取最近的样本和标签。所以我们在这里做的是排序我们的距离。我们可以这样做。所以让我们称之为 decay。Indices。然后这里我们使用 nuumpy.dot。Ark sort。所以这将排序距离。

将返回排序的索引。所以这里我们调用。Distances。这将是一个数组。我们只想要 K 个最接近的样本。所以让我们在这里使用切片。并从开始处开始。所以 0。或者我们可以省略这个。这仅适用于 self.dot K。所以这将是 K 最近样本的索引。现在让我们获取标签。所以我们得到。

K。最近。标签等于。在这里我们可以。我们也使用列表推导式。然后我们获取每个训练标签的标签。用这个索引。所以索引 I。然后对于 I 在 K indcs 中。所以现在我们有了最近邻的标签。然后我们使用投票机制，得到最常见的类别标签。

所以让我们称之为最常见的等于。为此，我们使用另一个 Python 模块。所以我们使用 counter 模块。所以我们说从 collections 导入。Counter。然后。我们ii。

到达那里。或者我们获得最近标签的计数器。

然后这是一个叫做最常见的的方法。我们只想要第一个或最常见的项目。嗯。现在让我们看看这是什么样子，所以。如果我注释掉这个，让我们写一个短示例，collections 或 counter 模块将会做什么。

假设我们有一个列表 A，它等于一些值。所以 1，1，1，2，2。然后有一些错误。标签，就好像也从 collections 导入了。Counter。现在我们得到最常见的元素。所以我们创建这个列表的计数器，然后取出一个最常见的元素。

所以。让我们打印这个。

所以。我必须。先关闭这个。所以让我们再次运行这个。嗯。所以这将是一个列表。然后我们有一个最常见项目的元组。所以，例如，如果我们在这种情况下。我们只想要一个，最常见的项目。这个是一个元组。这里的第一个项目是最常见的项目。所以这是 1。第二个项目是。

这个元素在我们的列表中出现的次数。所以它出现了三次 1。例如，如果你使用 2。那么它也会放入第二个最常见的项目。在这种情况下，是 2。我们有两个 2。所以我们只想要一个最常见的。所以正如我所说，这是一个列表。为了获得第一个项目，我们使用索引 0。

现在我们有了元组，接下来要再次获取实际的项目，我们使用第一个索引。然后我们有 1。所以这里我们也要做同样的事情，我们想返回这个。所以让我们返回索引 0 的最常见的索引 0。这就是我们 K 和 N 算法的实现。让我们试一下这个，所以。让我们。

在我们的测试示例中，我们已经有了测试文件。我们已经有了训练和测试样本。所以让我们使用我们的。K和N类。所以我们可以说从K和N导入。K和N。然后创建一个分类器。所以C，F等于。

K和N。所以，让我们使用。

K等于3。然后我们想先调用fit方法。所以我们想拟合我们的X训练。和。为什么训练。然后我们得到预测。这是。通过调用CF.dot.predict来实现。然后我们想预测。我们的。测试样本。所以x test。现在让我们计算准确率。所以准确率。这是由我们有多少预测。被正确分类来定义的。

所以这是。这里我们使用总和。嗯。

总和。在这里，我们写。预测等于，等于。

为什么测试。所以每个预测，就是。正确的。或者和正确标签相同，它。Es1。然后我们将其除以测试样本的数量。所以我们将其除以Lng，y。

测试。让我们打印我们的准确率。

看看这个是否有效。所以，在这种情况下，它是1。0。所以我们所有的预测都是。正确的。所以我们使用另一个。邻居数量。所以K等于5。通常你会想在这里使用一个奇数。所以让我们运行这个。哦，抱歉。在这种情况下，它是096，所以。没有三个邻居那么好，但也非常不错。嗯。

我们看到这在工作。这是我们整个K和M的实现。嗯。我希望你喜欢这个教程，下个教程见，拜拜。😊。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P3：L3- 线性回归 - ShowMeAI - BV1wS4y1f7z1

大家好，欢迎来到新的教程。这是机器学习系列教程的第二个视频。在这个系列中，我们将仅使用内置和Python模块以及Numpy实现流行的机器学习算法。今天，我们将实现线性回归算法。所以让我们首先谈谈线性回归的概念。在回归中。

我们想要预测连续值，而在分类中，我们想要预测一个离散值，比如类标签0或1。因此，如果我们看看这个示例图，我们有我们的数据，蓝点。我们想用一个线性函数来逼近这些数据。

这就是为什么它叫做线性回归。我们使用线性函数来预测值。😊。所以我们可以将逼近定义为y帽等于w乘以x加B。这是直线方程，其中W或我们的权重是斜率，B是偏差或仅是2D情况下沿Y轴的平移。因此，这是逼近。现在我们需要得出这个W和B。

我们如何找到这个呢？为此，我们定义一个成本函数。在线性回归中，这就是均方误差。这是实际值与逼近值之间的差异。因此，我们需要训练样本来获取这个实际值。然后我们平方这个差异，对所有样本求和，然后除以样本数量。

通过这种方式，我们得到了平均误差。这是成本函数，所以这是误差。当然，我们希望误差尽可能小。因此，我们必须找到这个函数的最小值。那么我们如何找到最小值呢？为此，我们需要计算导数或梯度。

因此，我们计算我们的成本函数关于W和B的梯度。这是梯度的公式。请自行检查，我也会在描述中放一些链接以供进一步阅读，但我现在不打算详细讲解。现在有了这个梯度。

我们使用一种叫做梯度下降的技术。这是一种迭代方法，用于达到最小值。因此，如果我们在这里有我们的目标或成本函数，我们就从某个地方开始。我们初始化权重和偏差，然后我们想朝着最陡的下降方向前进。而最陡的下降也是梯度。因此，我们想沿着梯度的负方向前进。我们会迭代这个过程，直到最终达到最小值。每次迭代时，我们都有更新规则来计算新的权重和新的偏差。

所以新的W是旧的W减去alpha乘以导数。😊。所以减去是因为我们想进入负方向。然后这个alpha是所谓的学习率。这是我们模型的一个重要参数。因此，学习率定义了我们每次迭代步长中前进的距离。

例如，如果我们使用较小的学习率，那么可能需要更长的时间。但它最终可以达到最小值。如果我们达到，或者如果我们使用较大的学习率。那么可能会更快，但也可能会像这样四处跳动，永远找不到最小值。因此，这是一个重要的参数，我们必须指定。请记住这一点。

现在我们知道了更新规则，我在这里再次写下了导数的公式。然后稍微简化了一下。请你自己检查一下。这些是更新规则和导数的公式。这就是我们需要知道的一切。现在我们可以开始了。现在让我们定义一个名为线性回归的类。

当然，这里面会有一个方法。或者双下划线分数在其中。然后它有self，并且获取学习率。我将给这个一个默认值。所以通常这是一个非常小的值。因此我将其设为0001。然后我将给它一个迭代次数。所以我们在梯度下降法中使用多少次迭代。

我还会给这个一个默认值。我会说这是1000。然后我会简单地将它们存储在这里。因此我会说self L R等于L R和self。Itders等于它的。然后稍后，我们必须得出权重。但是在这里一开始，我会简单地说self weights等于none，self dot bias等于none。

然后我们必须定义两个函数，并且我们将在这里遵循其他机器学习库的惯例。因此我们将定义一个fit方法，该方法接收训练样本及其标签。这将涉及训练步骤和梯度下降。然后我们将定义一个predict方法。因此，当它获取新的测试样本时。

然后它可以近似这个值并返回该值。这就是我们需要实现的函数。在我们继续之前，让我们快速看看数据X和Y。这看起来如何。为此，我写了一个小示例脚本，并使用了psychic learn模块生成了一些示例数据。

我会将数据分成训练样本和测试样本，以及训练标签和测试标签。因此首先，让我们看看这些数据的样子。

所以这里是图表。这就是我们的数据看起来的样子。现在我们想在这里找到一个函数来近似这个值。

让我们看看我们 x 和 y 的形状。所以让我们运行这个。我不想再看到这个图了。嗯。如果我们看到我们的 x 是一个大小为 80×1 的 N D 数组。这是因为我在这里输入，我想要 100 个样本。每个样本一个特征。然后我会拆分这个。所以我们的训练样本只有 80 个样本。

这是一个大小为 80×1 的 N D 数组，而我们的训练标签只是一个大小为 80 的 1 D 向量。所以对于每个训练样本，我们有一个值。这就是我们的数据的样子。现在让我们继续。所以让我们实现 fit 方法。正如我所说。我们需要在这里实现梯度下降法。

梯度下降总是需要从某处开始。所以我们需要一些初始化。

所以。让我们来做。让我们初始化我们的参数。对于这一部分。让我们得到样本的数量和特征的数量。我们可以通过说这是 x.dot.shape 来获取。然后我们简单地将所有权重初始化为 0。所以我们可以说 self.weights 等于 nuy0s。大小和特征。对于每个分量。

我们输入 a0 和 self.du.bias 等于 0。这只是一个值。所以你也可以在这里使用随机值，但 0 就很好。所以我们在这里使用 0。然后我们使用梯度下降。这是一个迭代过程。所以我们使用一个循环。所以对于 I，哦，实际上，我们不需要这个。所以对于下划线在范围内，然后 self.dot 和它的。

现在，我们需要的是什么。我们首先必须进行近似。或者让我们再看一下公式。

所以，我们的公式。新的权重是旧的权重减去学习率乘以导数。关于 W 的导数是 1 over n。然后我们有总和，和总和为两个 X I 的乘积。然后，这个近似值和实际值之间的差异。所以让我们先。首先。

计算这个近似值。所以我们有这个公式。近似值是。权重乘以我们的 x 加上偏置。

所以让我们这样做。假设我们叫它 y。预测等于。然后我们可以使用 N 点点。然后 x 和 self 点权重。加上 Bs，这将把 x 与权重相乘。现在我们有了近似值，可以计算关于 W 的导数。这是。让我们再看看这个公式。

1 over n。然后。总和。然后在总和内部，我们有 x 乘以这个的乘积。所以，我们说。

1 over。样本。我们已经得到了样本的数量。然后乘以。然后我们有了总乘积。所以这没别的，也就是点积。所以 N P 点点。但现在我们得小心。所以我们在这里做了什么。嗯。在这里，我们将每个权重分量与特征向量分量相乘并求和。

我们对所有样本进行这个操作，然后为每个样本得到一个值。在这里，我们希望为每个特征向量组件得到一个值。所以我们将每个样本与预测值相乘并求和。所以。然后我们对每个特征向量组件这样做，并为每个组件得到一个值。

所以这就是相反的方向。沿着另一个轴。因此，我们必须在这里使用x的转置，x dot T。这是转置X的点积。然后我们有预测的y减去实际的y。所以请自己检查nuy dot函数。因此，这就是W的和偏差的导数也是1。或者再次。

让我们看看这个公式。所以这就是相同的。只是这里没有x。所以这是1/n，然后就是求和。

这个差异。顺便说一下，我。我把两个省略掉了。所以这只是一个可以忽略的缩放因子。所以这里1/n，然后是差异的和。

所以再一次，样本的倒数。然后我们可以说nuy dot sum和预测的y减去实际的y的和。所以这些是我们的导数。现在我们更新我们的权重。所以我们说self weights减去等于self dot学习率乘以这个导数。并且self的偏差等于self。减去等于self dot学习率乘以导数。还有。是的。

所以这是梯度下降。现在我们需要预测方法。所以，再一次，我们近似。

我们用这个公式近似值，所以。

我们已经有了这个。所以这是。x和权重的点积，加上偏差。然后。我们简单地返回这个。所以这是我们需要的整个实现，我忘记导入Ny了。当然。所以我说，假设，导入Ny S和P，以便我们可以使用它。现在，让我们测试一下。所以。嗯。让我们导入这个类。所以假设，从。线性回归。导入线性回归。

然后创建一些回归等于。线性回归。然后我们说回归器dot fit。我们想要拟合训练样本和训练标签。然后我们可以说我们可以得到预测值等于。回归器。点预测。现在我们想预测。测试。嗯。样本。现在。

为了计算或查看我们的模型表现。现在我们不能使用准确性度量。但在这里我们使用均方误差。所以如我所说。这是我们的成本函数，均方误差告诉我们有多大。

实际值与近似值之间的差异。所以让我们定义均方误差。假设M，E，这将得到。

实际值和预测值。这就是。这里的numpy，我们可以使用Numpy均值。然后，简单地，差值。平方。因此，为什么真实值。是我的预测值的平方。然后我们想返回这个。让我们看看。假设。MSE值等于ME。Off。W。测试。和预测值，让我们打印这个。所以现在如果我们运行这个。嗯。看看，它没有运行。

偏差未定义。那么我们说我们。我们在这里遗漏了什么，点偏差。让我们再次运行这个。所以。L，27。哦，对不起。我复制了这个并忘记了这一年。所以下一次尝试。现在。我们看到我们的。性能，因此均方误差为783。这相当高。所以我们在这里使用另一个学习率。假设LR等于。t0，1。然后让我们运行这个。

现在我们看到我们的误差更小了。让我们实际绘制这个。所以。首先绘制。用原始学习率，看看我们的。图看起来如何。现在。我们的图看起来像这样。所以是。

几乎像正确的斜率，但不完全。现在让我们使用另一个学习率。所以让我们使用这个学习率。并运行这个。

现在我们的图看起来像这样。实际上这看起来相当不错。所以这是一个相当不错的。用线性函数对这个数据的良好拟合。所以我们看到我们的实现是有效的。希望你喜欢这个教程，下次见。😊

嗨，大家好。欢迎来到新的机器学习基础教程。今天。我们将仅使用构建的Python模块和Numpy来实现逻辑回归。如果你还没有观看我关于线性回归的前一个视频。我强烈建议你先观看，因为我在那里对一些概念进行了更详细的解释。

但我会在这个视频中再次涵盖所有重要概念。所以让我们谈谈逻辑回归的概念。😊所以。如你所记得，在线性回归中。我们用线性函数W乘以x加B来建模我们的数据。这将输出连续值。而在逻辑回归中，我们不想要连续值，而是想要概率。

为了对这种概率建模，我们将sigmoid函数应用于我们的线性模型。sigmoid函数是1除以1加上负x的指数函数。所以这是sigmoid函数，Min和x。在我们的案例中，就是我们的线性模型。所以。这将输出0到1之间的概率。所以如果我们绘制sigmoid函数。

你可以看到这是在0和1之间。所以通过这个函数。我们可以对我们的数据建模概率。现在，通过这个。近似输出，我们必须得出参数W。因此我们的权重和偏差。我们怎么做到这一点。所以再次，我在之前的视频中已经解释过这个。

所以我们应用一种叫做梯度下降的方法。首先，我们需要一个成本函数。在这里，我们不再使用均方误差，而是使用一个叫做交叉熵的函数。这就是公式。我不会详细讨论这个，但我会在描述中放一些进一步阅读的材料。

使用这个公式。我们想要优化我们的参数W和B。因此，我们使用梯度下降。这意味着我们从某个点开始，然后迭代地更新我们的参数。因此，我们必须计算导数。然后沿着这个导数的方向前进，直到最终达到最小值。所以，我们还需要定义一个所谓的学习率。

所以学习率决定了我们在每一步中向这个方向走多远。这是一个重要的参数。它不应该太高，否则可能会跳来跳去，永远找不到最小值，但也不应该太低。抱歉。现在，利用这个梯度下降。我们有我们的更新规则。因此，我们的新权重是旧权重减去。

因为我们想要朝负方向走，减去我们的学习率乘以导数。偏置也是一样。这里是我们所需的导数公式。这些公式实际上和线性回归中的导数是一样的，所以你可以自己检查背后的数学。我也会在描述中放一些链接。

这就是我们现在需要的全部，接下来我们可以开始实现我们的。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P5：L5- 回归重构 - ShowMeAI - BV1wS4y1f7z1

大家好，欢迎来到你的新Python教程。在这个视频中，我将简单地重构前两个视频中的代码。如果你还没有观看关于线性回归和逻辑回归的前两个视频，请先去看。所以现在如果你比较代码，你会发现它们几乎相似。

所以这两个类的in it方法完全相同。两个类的fit方法也几乎相同。所以在这两个类中，我们在in it中传入参数，然后执行相同的梯度下降。除了在线性回归中，我们仅有这个线性模型来逼近y，而在逻辑回归中，我们也有这个线性模型，但随后我们还应用sigmoid函数。

同样的差异出现在预测方法中。所以在线性回归中，我们简单地应用线性模型，而在逻辑回归中，我们应用线性模型，然后是sigmoid函数，接着判断它是1还是0。我们有一个辅助函数。但很多代码是相似的。所以让我们进行重构。然而。

让我们创建一个基类，称为base.Regression，我们的两个类将从这个基回归派生。所以我们说，线性回归从基回归派生，逻辑回归也是如此。然后我们可以切分init方法，将其放入基回归中，因为这对两者都是相同的。所以，让我们在这里切分这个。

然后我们也切分fit方法。这几乎是相同的。所以我们在这里不需要这个，放到上面去。嗯，现在唯一需要不同的是why predicted，因为有时我们仅需要线性模型，有时我们需要线性模型和sigmoid函数。所以让我们创建一个辅助函数，称为_approximation。

这将获取我们的数据X，或样本，然后它还会获取权重和偏置。在我们的基类中，我们将引发一个未实现的错误。所以这必须在派生类中实现。现在在线性回归类中，让我们也创建这个。在这里我们将实现它，并在我们的线性回归模型中。

这简单就是线性模型，所以我们可以返回它。返回x和W的点积加上偏置。然后，我们还需要，嗯，或者我们可以切分。将逻辑回归方法中的fit方法提取出来并实现逼近方法。所以在这里，让我们复制这个。是哦。因此，让我们记住我们需要线性模型，然后应用sigmoid函数。

所以让我们切分这个。并创建我们的_U逼近方法，参数为self，X，W和偏置。然后我们创建我们的线性模型，表示为nuy.Dot.X.W.Plus偏置。然后我们应用sigmoid函数并返回它。所以让我们返回self.dot._sigmoid的线性模型。这是逼近值。

现在，预测方法有点不同，所以。让我们。在我们的基类中，定义这个预测方法。嗯。在这里我们将实现一个辅助函数，并称之为underscore_predict，它将获取self.X和W以及B。在基类中，我们将简单地抛出一个未实现的错误。所以这必须在派生类中实现。

所以我们在基类的Predict方法中调用并返回这个。让我们返回self.underscore_predict，并使用测试样本。现在，我们有了计算出的权重和偏差。在我们的线性回归类中，我们定义这个underscore_predict，它将获取x。

W和偏差。所以，在这里，它将获取。所以这将是相同的代码。点积。x和w的点积加上偏差。我们可以在这一行返回它。所以我们不需要这个。在逻辑回归中，我们将其定义为underscore_predict，带有X、W和B。然后我们在这里有相同的代码。所以我们使用W和B，然后应用sigmoid函数。

定义它是1还是0并返回。现在，我们可以将这个复制到这里，并放在同一个文件中。

然后我们完成了。所以现在我们有两个模型，线性回归和逻辑回归，仅用60行Python代码。看起来干净多了。那么，是的，这就是全部。希望你喜欢这个教程，下次见，拜。😊！

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P6：L6- 朴素贝叶斯 - ShowMeAI - BV1wS4y1f7z1

大家好。欢迎来到一个新的从零开始的机器学习教程。今天，我们将仅使用构建和Python模块及Numpy实现朴素贝叶斯分类器。😊 朴素贝叶斯分类器是基于贝叶斯定理的，该定理表明，如果我们有两个事件A和B，那么事件A的概率，给定B已经发生。

等于事件B的概率，给定事件A发生的概率，乘以事件A的概率除以事件B的概率。如果我们将其应用于我们的案例，那么我们的公式是类Y的概率，给定特征向量X，等于给定Y的X的概率乘以P(y)，再除以P(x)。

而x是我们的特征向量，它由多个特征组成。现在之所以称为朴素是因为我们假设所有特征都是相互独立的。这意味着，例如，如果你想预测一个人出去跑步的概率，给定太阳在照耀，以及给定这个人健康的特征。

然后这两个特征可能是独立的，但都对这个人出去的概率有贡献。因此在现实生活中，很多特征并不是相互独立的，但这个假设在很多问题上效果良好。根据这个假设，我们可以将这个概率分割。并使用链式法则。所以我们为每个特征计算概率。

给定y，并乘以每一个。然后我们将其乘以P(y)并除以P(x)。顺便提一下，P(y|x)被称为后验概率，P(x|y)被称为类条件概率，P(y)被称为y的先验概率，而P(x)被称为x的先验概率。

现在我们想要进行分类。给定这个后验概率，我们希望选择概率最高的类。所以我们选择y，即y的弧最大值。在这个后验概率中。现在我们可以应用我们的公式。因为我们只对Y感兴趣，所以不需要这个P(x)，所以可以将其划去。

然后我们的公式是这样，为什么是弧最大值。然后我们乘以每个类的条件概率，再乘以先验概率。然后我们用一个小技巧。因为所有这些值都是在0到1之间的概率。所以如果我们乘以很多这些值，那么我们会得到非常小的数字。

我们可能会遇到溢出问题。因此，为了防止这个，我们应用锁定功能。我们对每一个概率应用锁定。通过锁定或对数的规则，我们可以将乘法符号转换为加法符号。所以现在我们有了一个加法。现在我们有了我们需要的这个公式。

现在我们需要提出这个。AP 概率，所以先验概率就是频率。我们可以在一瞬间看到这一点。然后这个类别条件概率，即 P（x | y）。在这里，我们用高斯分布来建模。所以我们可以看到这个公式。所以这是 1 除以，然后是 2π的平方根乘以 y 的方差。

乘以指数函数的负 x 减去均值的平方除以 2 乘以方差。在这里，我们看到不同均值和方差的高斯函数的图。这个概率总是在 0 和 1 之间，是的，使用这些公式。这是我们开始所需的一切。所以现在我们可以。

开始并实现它。首先，当然，我们导入 Ny S N P。然后我们创建一个名为 naive 的类。但它不需要一个 init 方法，因此我们可以首先实现 fit 方法。我们希望拟合训练数据和训练标签。然后我们还想实现一个预测方法。

在这里我们预测测试标签或测试样本。现在让我们开始。所以我们从 fit 方法开始。我们可以在这里做什么。

所以我们需要先验，我们可以在这个 fit 方法中计算它们。我们需要类别条件。所以在这里我们需要每个类别的均值和方差。因此我们也可以计算这些。

所以让我们这样做。首先获取样本数量和特征数量。顺便说一下，我们的输入 X 是一个 nuy N D 数组，其中第一维是样本数量，第二维或行数是样本数量，列数是特征数量。所以我们可以解包这个并说这是 x.shape。我们的 y 是一个 1D 行向量，大小也为。

样本数量。这是我们的输入。现在让我们获取唯一类别。假设 self.classes 等于 nuy.unique(y)。这将找到数组的唯一元素。如果我们有两个类别，0 和 1。那么这将是一个数组，里面仅包含 1、0 和 1 y，以及 1。假设类别的数量等于。🤢，这个 self.classes 的长度。现在。

让我们初始化或。初始化均值、方差和先验。假设 self.mean 等于。我们想先用零初始化。它的大小为类别数量和特征数量的元组。所以它也。对于每个。类别。它有。每个特征所需的均值数量。

我们想要将这个或给它一个 float 类型，即 nuy.float64。我们想对方差做同样的事情。假设 self.do。玩儿。等于这个。然后我们希望 self.priers 等于 N.zeros。在这里，对于每个类别，我们希望有一个先验。所以这只是一个大小为类别数量的 1D 向量，数据类型为 N.float64。

现在让我们计算它们。因此对于self dot classes中的每个类别，我们。现在。我们只想要将这个类别作为标签的样本。因此我们将其称为X，C等于X。然后在哪里。C等于等于。Y。现在我们可以为每个类别计算均值并填充我们的self do mean。因此我们想填充。这一行和所有列。我们说，这是x。X，C。

dot和nuly有一个或一个N D。数组必须内置均值函数。因此我们可以沿着轴0计算均值。因此请自己检查均值。函数。我们想对var做同样的事情。因此self var在这一行的每一列。是X C dot var。因此Numpy也有一个var方法。然后我们计算先验，因此self。Priers。这个类别。等于。现在。

我们已经掌握了哪些信息。如果我们有训练样本和训练标签。我们可以说这个类别发生的先验概率等于该类别在训练样本中的频率。因此，我们说。我们得到X，C。形状为0，因此只有。这将获得带有此标签的样本数。然后我们将其除以总样本数。因此。

我们必须将其转换为浮点数，因为我们不希望这里是整数。因此我们说浮点数样本数。所以这是频率。这个类别C出现的频率。现在这就是我们fit方法的全部。现在让我们实现predict方法。因此为了这个。我们创建一个小的辅助方法。我们将其称为_预测self。

这只会获取一个样本。因此在这里我们可以有多个样本。因此我们说为什么预测等于，然后我们使用列表推导。调用这个_预测方法。仅用于一个样本。然后我们对测试样本中的每个样本执行此操作。然后，我们返回它们。现在我们必须实现我们的_预测方法。因此在这里。

我们现在需要的是我们需要。

应用此函数。因此。我们必须计算后验概率。并计算。每个类别条件和先验，然后选择具有最高概率的类别。

现在让我们创建一个名为posteriors的空列表。等于一个空列表。接下来我们遍历每个类别。假设对于索引和C在。枚举。Self dot classes。因此这里我们也得到了索引和类别标签，使用这个枚举函数。现在我们可以说。首先，我们得到pia。那么pia等于，我们已经计算出的p。因此这是。

self dot Priers的先验。在当前索引中。

现在，正如我所说，最后我们应用锁定函数。因此我们在这里应用它。因此我们说NP P dot lock。

然后创建后验。所以，后验等于。让我们称之为。类。条件。等于。然后我们应用高斯函数。所以对于这个。让我们创建这个辅助函数，称之为概率密度函数。使用self。然后它获取。类索引。然后它获取x。这里我们应用这个公式。

所以我们需要均值和方差。然后。嗯。应用这个函数。所以，首先。让我们得到均值等于。我们已经有均值了。所以我们可以说self。

该类别索引的均值以及方差等于self。Vre的该类别索引。然后我们创建一个分子，等于nuumpy点x。所以。负的指数函数。然后我们有x减去均值。的平方。除以。然后，两倍的方差。接着，我们有。分母，次分母等于。

在这里我们有N点。S。Co是Ts的平方根。两倍的。然后我们有π。我们也可以从Nami和Peter π中获得。乘以theva，然后我们返回。分子。除以。你知道我Na。所以这是我们的概率密度函数。然后我们可以说我们的类条件是。嗯。Self。点。我们索引的概率密度函数。

然后x。然后。嗯。我们想要。我们想要有logo的边缘。所以我们说N点锁。然后。

我们将它们全部相加。

所以，我们可以使用。Nampy点一些这个。嗯。然后我们说我们的后验。Tior等于。Pya，加上。类条件。我们的类条件。然后我们将它们附加到我们的后验。所以posteriors点附加后验。

现在我们使用或应用这个的arc max，并选择概率最高的类别。所以Ny也有一个arc max函数。所以这非常简单，所以我们现在可以说返回self点。

类。关闭，索引现在是。这。最高概率的。后验。所以我们可以说。N点Arc max。这张海报。现在，我们完成了。这就是整个实现。然后。现在我们可以运行它。所以我已经有一个小的测试脚本，我使用p Psych库加载数据集，并为每个样本创建一个包含1000个样本和10个特征的数据集。我们有两个类别。然后我们将数据分为训练样本和测试样本及其标签。

然后我们创建我们的朴素贝叶斯分类器，我从这里的文件中导入。然后我拟合训练数据和训练标签。然后我为测试样本获取预测。接着我会计算准确度。所以让我们运行这个，看看是否可以，这是否有效。所以，是的，这有效。

我们的分类准确率为0。96。所以相当不错。所以是的，就这些。我希望你喜欢这个教程，下次见，再见。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P7：L7- 感知器 - ShowMeAI - BV1wS4y1f7z1

大家好，欢迎来到新的从零开始的机器学习教程。今天，我们将仅使用内置和Python模块实现一个感知器。感知器可以看作是人工神经网络的一个单元。因此，感知器是生物神经元的简化模型。

它模拟了仅一个细胞的行为。让我们看看这个图像，我们有一个细胞。我们的细胞接收输入信号，这些信号经过加权并相加。如果整个输入信号达到某个阈值，我们的细胞就会发出信号并提供输出。在我们的例子中，它要么发出1，要么发出0。😊

现在如果我们从数学上建模，那么看起来是这样的。我们有输入特征，它们与一些权重相乘并相加。然后我们应用一个激活函数，得到我们的输出类别。这就是模型，线性部分，线性模型看起来就是这样。

这只是一个线性函数。W的转置乘以x加上B。在这里，我们将权重和偏置相乘并相加。因此，偏置是这个图中的W 0。在这个线性模型之后，我们应用激活函数。在最简单的情况下，我们使用所谓的单位阶跃函数。它被定义为如果我们的输入达到某个阈值，则输出为1，否则为0。在这个图中，阈值是0。因此，如果输入大于0，则输出为1，否则为0。现在这就是我们建模输出所需的全部。最终的输出看起来是这样的。

首先，我们应用线性函数，然后应用激活函数。现在我们需要设定权重和偏置。为此，我们使用一个简单的更新规则，称为感知器规则。我们查看每个训练样本X I，然后对每个训练样本应用更新步骤。

这被定义为新权重等于旧权重加上增量权重，而增量权重或delta W被定义为alpha乘以实际标签减去预测标签乘以训练样本X。这里的alpha是介于0和1之间的学习率。所以这只是一个缩放因子。现在让我们看看这个更新意味着什么。

让我们看看在两个类别问题中可能出现的四种情况。我们的输出可以是1，实际标签可以是1，而预测标签也是1。那么差异为0。因此，我们在这里的权重没有变化。如果实际类别是0，而预测类别也是0，同样也是正确分类，差异为0。因此，权重没有变化。

但现在如果我们有误分类会发生什么。所以如果实际类别是 1，预测类别是 0。这意味着我们的权重太低。然后我们看到差值是 1。因此我们的权重在这里被增加。如果实际类别是 0，预测类别是 1。那么我们的权重就太高了。

我们看到差值是 -1。因此我们的权重被减少。因此，在误分类的情况下，权重朝着正类或负类移动。这是一个简单直观的规则，但它有效。这就是我们所需的一切。因此，我们查看每个训练样本，然后应用更新规则。

然后我们执行几次。因此我们迭代一定次数。然后我们就有了最终权重，完成了。这就是我们需要知道的一切。现在我们可以开始实现它。

首先，我们当然使用 numpy。因此我们导入 numpy S 和 P。然后我们创建一个类并称之为感知器。感知器。它有一个固有的方法，当然。这里它有自我，并获得学习率。我将默认值设为 0.01。然后它获得一个迭代次数。所以 n 次。我也会给这个一个默认值。

假设 1000。然后我会简单地存储它们。因此我会说 self.dot.L R 等于学习率，self.dot.n.其 equals，和其。然后我们创建激活函数。因此假设 self.dot.activationation fun。等于，现在让我们在这里创建它。正如我所说，激活函数就是单位阶跃函数。因此我们称之为。Unit step。Fk。

有了自我和输入 X，以及。我们可以简单地说如果 x 大于或等于 0，则返回 1，否则返回 0。但。我们稍后会看到，这只对单个样本有效，但我们稍后会看到，我们希望在预测方法中对所有测试样本应用激活函数。因此，我们也希望对 N D 数组应用这一点。为了这一点。

我们可以使用一个简单的函数，称为 numpy.dot.where。因此我们返回 nuy.dot.where。这将获取一个条件。因此 x 大于或等于 0。如果条件为真，那么我们返回 1，否则返回 0。因此这将对单个样本有效，但也对一个向量中的多个样本有效。因此现在这是我们的激活函数。

现在我们可以说 self.dot.activationation fun 等于 self.dot.unit step fun。现在让我们创建权重。说 self.dot.weights 等于 none，self.dot.Bs 等于 none。因此现在我们知道必须实现它们。或者获取它们。现在我们实现两个函数。和往常一样，我们实现 fit 和 predict 方法。因此首先。定义 fit 方法，带有 X 和 y。

因此，这获取训练样本和训练标签。然后，当然，哦。我忘了这个 self。然后，我们。还定义了。预测方法，它获取 self。然后是测试样本。现在我们开始。使用这个预测方法，因为这非常简单。

让我们再次查看我们输出的近似值。这里首先。我们应用这个线性函数，然后是激活函数。我们开始吧。所以首先，线性函数。假设是linear。

输出等于。这是w转置乘以x加上偏置，而W转置乘以x不过是点积，所以我们可以使用np.dot。off。X和self dot。self dot weights加上self dot bias。现在我们有了线性函数，接下来我们应用激活函数。所以我们说y预测等于self dot激活函数。

作为输入，它获取这里的线性输出。然后我们简单返回y预测。这就是整个预测方法。现在让我们跳到拟合方法。首先，我们获取x向量的维度。这是一个大小为M乘N的N维数组，其中M或行数是样本数，N或列数是特征数。所以我们说N样本和N特征等于x dot shape。现在我们初始化我们的权重。

我们必须给它们一个初始值，我们可以简单地将它们设置为0。所以我们说self dot weights等于nuy dot zeros。大小为特征数。所以对于每个特征，我们在这里放一个0作为我们的权重。而且，偏置，简单为0。现在我们可以开始，还有一件事我们要做的是确保我们的y只包含类别0和1。

所以我们假设Y下划线等于。现在我们将所有值转换为0或1。如果情况并非如此。我们使用列表推导式来实现。所以我们说如果i大于0则为1，否则为0，针对y中的i。现在将其转换为Ny数组。所以。现在，我们有了我们的Y，现在可以开始训练。

所以我们再次查看这个更新规则。我们希望查看每个训练样本，并且我们还想进行几次迭代。所以我们这里需要两个、四个循环。我们假设第一个循环是下划线，因为我们在范围内不需要这个self dot和它的。

🤢。

这是我们定义的迭代次数，然后是我们的第二个循环。为此，我使用了enumerate方法，所以我可以说四个。索引和X，Y在。enumerate X中。所以我想遍历训练样本，enumerate函数将给我索引以及当前样本。这是我们的两个循环，现在。

抱歉。让我们应用。这个更新规则。所以，再次。我们必须计算预测值然后应用更新。我们假设线性输出等于nuy dot of。

当前样本。还有我们的 self，那等待。加上 self 的偏置。然后我们应用激活函数并得到预测值。所以 y 预测等于 self.dot.activation_function 的线性输出。因此在这种情况下，我们只为一个样本使用它。

在 predict 方法中，我们对多个样本使用激活函数。这就是为什么我们在激活函数中需要这个 nuy 的原因。所以是的。现在继续。现在我们有了预测的 y。现在我们再看看公式。所以我们有学习率乘以差值。

然后，乘以 x。所以。我们称这个更新为 self.dot.learning_rate 乘以。这里我们有实际的。标签，所以 y_下划线 当前索引 减去 y 预测。然后。我们说 self.dot.weights 加上等于更新乘以 X，我。和 self.dot.bias 加上等于更新乘以 1。所以我们不需要这个乘以 1。现在我们完成了。

这就是感知器的整体实现。现在让我们测试一下。所以我在这里写了。我已经写了一个小测试脚本，所以我在这里导入感知器。然后我会创建两个。两个 blops。所以我可以使用 SK learn 模块中的一个叫 make blops 的函数。这将创建两个类别。

然后我将把数据分成训练样本和测试样本，以及训练标签和测试标签。然后我将创建一个感知器。我会拟合训练数据。然后我将预测测试标签。然后我将计算准确率。还会绘制这个。所以让我们运行它。我希望我没有忘记任何事情。

现在这是绘图。因此我们看到我们的两个 plotlops。在这里我们有我们的线性决策边界。这是我们的感知器生成的决策函数。我们看到它完美地分开了我们的两个类别。所以，我们也看到我们的准确率是 1。在这种情况下是完美的。是的。

我们看到感知器可以工作。我们需要注意的一点是，感知器仅适用于线性可分的类别。所以如果类别可以用线性函数分开，比如在我们的案例中。我们再看一下这个。那么它工作得非常好，但否则效果就不那么理想。为了进一步改善，我们可以尝试不同的激活函数。例如。

sigmoid 函数，然后应用梯度下降方法，而不是感知规则来更新我们的权重。不过，现在我想展示的应该就是这些。我希望你喜欢这个教程，下次再见，拜拜。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P8：L8- 支持向量机 - ShowMeAI - BV1wS4y1f7z1

大家好，欢迎来到全新的机器学习入门教程。今天，我们将仅使用内置的 Python 模块和 Numpy 来实现 SVM 算法。😊 SVM 或支持向量机是一个非常流行的算法。它的核心思想是使用线性模型，寻找最佳分隔我们数据的线性决策边界，亦即超平面。

在这里，最佳超平面的选择是代表两个类别之间最大分隔或最大间隔的那个。因此，我们选择超平面，使其到每侧最近数据点的距离最大化。

如果我们看看这个图像，那么我们希望找到一个超平面，而这个超平面必须满足这个方程 W 乘以 x 减去 B 等于 0。我们希望找到超平面，使得到两个类别的距离最大化。因此我们在这里使用类别 +1，而在这里使用 -1。所以，这个间隔应该被最大化。首先，让我们看看背后的数学。

所以这比我之前的教程稍微复杂一些。但我保证一旦你理解了，最终的实现相对简单。因此，我们使用线性模型，W 乘以 x 减去 B，应该等于 0。然后我们的函数也应该满足 W 乘以 x 减去 B 应该大于等于 1。

对于我们的类别加一。因此，这里所有的样本必须位于这个方程或这条线的左侧。而类别 -1 的所有样本必须位于这个方程的右侧。所以如果我们用数学表示，那么我们应该满足 W 乘以 x 减去 B 必须大于等于 1 对于类别 1，或者对于类别 -1，必须小于等于 -1。所以如果你将这些放入一个方程中。

然后我们将我们的线性函数与类别标签相乘。这应该大于等于 1。这是我们希望满足的条件。现在我们想要得出 W 和 B，也就是我们的权重和偏置。为此，我们使用成本函数，然后应用梯度下降。

如果你对梯度下降还不熟悉，请观看我之前的某个教程。例如，在关于线性回归的教程中，我对此做了更详细的解释。那么现在，让我们继续。我们在这里使用一个成本函数。在这种情况下，我们使用铰链损失。

这被定义为 0 和 1 减去的最大值。而这里是我们的条件。Y I 乘以我们的线性模型。那么这意味着，如果我们绘制铰链损失，这里蓝线就是铰链损失。如果 Y 乘以 F 大于等于 1，那么这是 0。所以如果它们具有相同的符号，那么结果就是 0。

如果它们被正确分类并且大于1，那么我们的损失为0。这意味着如果我们再看看这个图像，如果。对于绿色的玻璃，如果它在这一侧。那么，它是0。对于蓝色类别，如果它在这一侧。那么也是0。否则，我们将得到一个线性函数。

所以，我们距离决策边界线越远，损失就越高。这是我们成本函数的一部分。另一部分是。正如我之前所说，我们希望在这里最大化间隔。所以在这两个类别之间，间隔被定义为2除以w的大小。因此，这取决于我们的权重。

依赖于我们的权重向量。因此我们希望最大化这个，因此。我们希望最小化大小。所以我们将这个或添加到我们的。成本函数中。因此，我们还添加这一项。W的大小的平方乘以一个lambda参数。然后这里是我们的铰链损失。所以lambda参数试图在这两个项之间找到一个折衷。

所以基本上这说明了哪个更重要。所以我们当然希望有正确的分类。我们希望位于线的正确一侧。但我们也希望线的间隔是。最大化的。嗯。所以，如果我们看看这两种情况，如果我们在正确的一侧。

如果Y I乘以F在x上，F的值大于或等于1。那么我们仅仅有这一项，因为铰链损失为0。否则，我们的成本函数就是这一项。现在我们希望最小化这个。因此，我们想要获得成本函数的导数或梯度。在第一种情况下。

如果我们大于或等于1。我们的导数仅为2倍lambda乘以W。因此，我们这里只看W的一个分量。因此，我们去掉大小。对B的导数为0。所以请自行确认。我不会解释导数和细节。在另一种情况下。

如果Y I乘以F在x上不大于或等于1。那么我们对W的导数是这里的方程。对我们的偏差的导数仅为Y I。因此，请再次自行确认。当我们有了梯度，我们可以使用更新规则。

所以新的权重是旧的权重减去，因为我们使用梯度下降。所以我们朝负方向前进，减去学习率或步长乘以导数。这是我们的更新规则。现在，我希望你能理解这个概念及其背后的数学。现在我们可以开始实现它了。这现在很简单。所以，首先。

我们当然导入Ny S和P！

然后我们创建我们的类S，我们将获得一个init方法。在这里我将放入一个学习率，默认值为0001。它将获得一个lambda参数，默认值也将得到。我会说这是001。所以这通常也是一个小值。然后它将获得我们优化的迭代次数。

这将获得默认值1000。所以我将简单地存储它们。我会说self dot L R等于学习率。Self do。Lambda Para等于Lambda Para。请注意，我不能在这里使用Lambda，因为Lada是Python中Lada函数的关键字。所以。是的，self do。然后它等于并且它的。然后我会说self dot W等于none，self dot B等于none。

所以我必须稍后想出它们。然后我们定义我们的两个函数。像往常一样。一个是预测函数，我们拟合训练样本和训练标签。对不起，这是fit方法。另一个是预测方法。我们预测测试样本的标签。现在让我们开始预测方法。

因为这非常简短，所以。

我们想要，如我所说，如果我们查看数学，我们应用这个线性模型。然后我们查看这个的符号。如果是正数，我们就说它是类1。如果是负数，我们就说它是类-1。所以我们说线性。

输出等于Ny dot。Dot，所以点积。X和self dot W的结果减去self dot B。然后我们选择大小。因此我们可以简单地说，返回Nampy dot的这个线性输出的符号。所以这是整个预测实现。现在让我们继续fit方法，所以。首先，如我所说，我们在这里使用类+1和-1。

所以我们想确保我们的y只有-1和+1。所以通常它有0和1。让我们转换一下。所以我们说y underscore等于。在这里我们可以使用nuy dot where，这将获得一个条件。所以我们说y。如果小于或等于0，我们就放-1，否则放+1。所以。

这将把所有的零或更小的数字转换为-1，其他数字转换为+1。现在。让我们获取样本数和特征数。这简单地是X dot Shape。因为我们的输入向量X是nuy和DRA。行数是样本数，列数是特征数。然后我们想要初始化我们的W和B。我们一开始简单地放入零。

所以我们说self。Tt W等于Ny的大小和特征的零。对于每个特征组件，我们将a0放入我们的权重组件中。然后我们说self dot B等于0。现在我们可以开始我们的梯度下降。所以我们说，for underscore。因为我们不需要在范围self dot中，它迭代。

所以我们想要进行的迭代次数。然后，我们迭代我们的训练样本。所以我说4索引和X，我在枚举X中。这将给我当前的索引和当前的样本。现在。

我现在想做的是让我们再看一下数学。所以我想计算权重或我们的成本函数关于W和关于偏差的导数。这里我首先，但首先，我会查看这个条件是否满足，所以我会说。条件是Y I乘以我们的线性函数。所以我说条件等于。

为什么当前索引使用下划线。乘以，然后是线性函数，所以。Nampai.dot。当前样本和我们的self.dot.W减去self.dot.B。嗯。这应该大于或等于1。所以如果满足这个条件并且条件是真的，否则就是假。所以现在我说如果。

条件，所以如果这是真的。那么，我们的导数看起来像这样。关于B的导数就是0。所以我们只需要这个，所以。我说。嗯。所以是两倍lambda乘以W。然后在我们的更新中，我们去。所以我们说新的方式是旧的权重减去学习率乘以这个。所以我将其写在一步中。

所以我说self.dot.W减去self.dot.learning rate乘以。现在在这里。

我们有两倍self.dot.Lambda参数乘以self.dot.W。所以这是第一次更新。或者如果我们的条件满足，我们只需要这个更新。否则，我们说self.dots.W减去self乘以L R学习率乘以。让我们再看看这个方程。所以是。

两倍lambda乘以w减去Y，I乘以X，I，所以。

两倍。我们的lambda乘以。W减去nuy.dot。所以我想乘以我们的向量，X，I和Y I，所以当前索引的y下划线。这是我们对W的更新，我们的self.dot.B是减去self乘以学习率乘以导数，而导数只有。

或者只是Y I，所以只有。

为什么索引使用下划线。现在我们完成了。这就是整个实现。现在让我们测试一下。所以我写了一个小测试脚本，它会导入这个SVM类，然后生成一些测试样本。它将生成两个玻璃。然后我会创建我的SVM分类器并拟合数据。

然后我写了一个小函数来可视化这个，所以你可以在GitHub上找到代码，顺便说一下。请自己查看一下，如果我们运行这个。所以我们说Python as we am underscore Te P。

现在，这应该计算权重和偏差，并且还应该绘制决策。

有趣的是这里的黄线和两边的两条线。我们看到它在工作。 所以，是的。这就是关于 S VM 的全部内容。我希望你喜欢这个。如果你喜欢，请订阅我的频道，下次见，拜。

用 Python 和 Numpy 实现最热门的12个机器学习算法，彻底搞清楚它们的工作原理！＜实战教程系列＞ - P9：L9- 决策树第 1 部分 - ShowMeAI - BV1wS4y1f7z1

大家好，欢迎来到新的机器学习教程。今天，我们将仅使用内置的Python模块和Numpy实现一个决策树。决策树是一个非常简单但强大的概念。其核心思想是构建一棵树来分割数据，以实现类别之间的最佳分离。

决策树也是非常流行的随机森林模型的基础，我们将在下一个教程中实现。因此，我希望你们能跟着我。😊，和往常一样，我们首先从理论开始。所以让我们看一个例子，以理解决策树背后的概念和数学原理。假设我们想预测一个人是走路还是乘公交车去上班。

我们有10个观察值或10个样本，具有两个不同的特征。所以我们有一个特征，即是否在下雨，然后我们有另一个特征，他们有多长时间？

然后我们得出预测或类别标签，是或否。

现在我们想构建一个将数据分割的树。所以我们把所有样本放在根节点，然后我们提出一个问题，我们问是否在下雨，如果答案是“是”。然后我们向右移动，把所有答案为“是”的样本放进去。所以这三个放在右节点，如果答案是否。

然后我们向左移动，把所有其他样本放入左节点。

这里在右侧，我们可以立即说答案是否，他们不走路。所以我们把。

或返回类别标签0。这里在左侧，我们可以进一步分割数据并扩展我们的树。所以我们问下一个问题。那就是他们是否有超过10分钟，如果答案是“是”，我们就向右移动，把所有的。

样本如果有超过10分钟的时间就放在右节点，所有其他样本放在左节点，然后在这里我们可以说答案是“是”或类别标签是1，而这里的类别标签是0。

我们也可以在这里停止生长并返回最常见的类别标签。所以我们可以说，他们更有可能走路。但我们也可以进一步分割数据，但我们不想让数据过度生长，因为我们不想过拟合数据。但我们也希望有一个好的预测。

所以这是决策树工作的概念，现在我们唯一需要找出的就是在什么节点上应用哪个问题，为什么我们一开始问雨而不是天气，为什么我们问时间是否大于10，为什么不问是否大于5或大于20。

所以这就是所谓的最佳。

划分特征和我们想要找出的最佳划分值或划分阈值。

所以，概念是。在每个节点，我们想找到最佳的划分值和最佳的划分阈值并存储它们。这是我们的训练阶段，后来当我们想预测一个新的测试样本时，我们从顶部开始，遍历我们的树，应用开始的问题或特征，然后向左或向右移动，直到到达叶子节点，叶子节点是底部的节点。然后我们应用基于测试样本存储的最常见标签。

所以这是这个概念。那么我们如何找到最佳划分呢？为此，我们需要一些数学。我们计算熵，熵也是不确定性的衡量标准。公式是负号，然后我们有p(x)乘以p(x)的对数的总和，而p(x)是发生次数除以样本总数。在我们的例子中，我们有110个样本，其中五次答案是0，五次答案是。

1。然后我们得出，熵是-5除以10乘以5除以10的对数减去。然后我们看下一个标签，所以再次，五个标签。因此是-5除以10乘以5除以10。如果你计算这个，那么结果是1。所以这是最糟糕的情况，在第一个节点我们无法预测是1还是0。

因为我们有相等数量的两者。

这里的样本或两类。所以一个是最糟糕的情况，这里的熵为0。这是最好的情况，我们非常确定我们有类0。

现在我们计算熵，然后对数据进行分割，并计算子节点的熵。接着我们计算通过这次分割获得的信息量，这个度量实际上称为信息增益。它是通过父节点的熵减去所有子节点熵的加权平均值来计算的。因此在我们的示例中，我们有根节点和10个观察值。

然后在左侧，我们有7个观察值，其中2个为零，5个为1。在右侧，我们有3个零。因此我们的熵是父节点的熵减去7/10乘以左侧的熵加上3/10乘以右侧的熵。

这是信息增益。

现在我们进行贪婪搜索，因此我们检查所有可能的特征和所有可能的特征值或阈值。对于降雨，我们检查它是“是”还是“否”，意味着1或0，对于时间特征，我们检查5、10、15、20、25和30，因此我们进行贪婪搜索。

然后，我们存储或选择并存储最佳特征和最佳阈值。所以这是。

概念，让我们更详细地看看这种方法。因此首先，我们有训练阶段，在此阶段我们想要构建我们的树。我们从顶节点开始，在每个节点，我们根据最佳信息增益选择最佳分割。

我们进行贪婪搜索，因此我们遍历所有特征和所有阈值。然后我们在每个节点保存最佳分割特征和分割阈值，并递归地构建树。

我们还必须应用一些停止准则来停止生长。在我们的示例中，我们将使用最大深度。

例如，我们说如果深度是3且为5，那么我们将停止。

我们在节点使用最小样本数。因此，例如，我们可以说如果一个节点中的样本少于五个，那么我们就不再进一步分割。

如果在一个节点中没有更多的类别分布，就像这里那样。我们就无法再进行分裂，因为这里只有类别 0 的标签。所以这些是我们需要的停止标准。当我们有一个叶节点时，我们会存储该节点中最常见的类别标签。所以这里我们存储 0、1 和 0。

这是我们的训练阶段，随后在测试新样本时，我们遍历树，并且也是递归进行。因此我们实现一个调用自身的函数。在每个节点，我们查看测试特征向量的最佳分裂特征，然后根据情况向左或向右走。

这个特征的值是否小于或等于我们存储的阈值？

当我们到达叶节点或底部时，我们返回存储的最常见类别标签。这就是这个概念。

决策 3。现在我想在这里停止这个视频，我们将在下一部分或第二部分继续实现。所以到时见。

用Pandas进行数据处理与分析！真实数据&实时讲解，学完就能上手做数据分析了！＜实战教程系列＞ - P1：1）数据分析入门 - 安装和加载数据 - ShowMeAI - BV1M64y187bz

嗨，大家好，最近过得怎么样？在这个视频系列中，我们将学习如何使用pandas库和Python。pandas是一个数据分析库，使我们能够轻松读取和处理不同类型的数据。我们可以用它来分析CSV文件、Excel文件和其他类似格式。

如果你想进入数据科学领域，那么这个库是必学的。它是Python中下载最多的包之一，这有很好的理由。它不仅让我们轻松读取和分析数据，而且由于是基于NumPy构建的，因此性能也很出色。

在这个系列中，我们将学习不同类型的数据分析。因此，在这个视频中，我们将讨论如何安装pandas，如何下载我将在这个系列中使用的数据，以及如何在Jupyter notebook中打开这些内容。

这样我们就可以准备进行编码和分析了。现在，我还想提到，我们有这个系列视频的赞助商，那就是brilliant.org。所以我非常感谢brilliant赞助这个系列。如果你们能通过下面描述部分的链接查看他们并支持赞助商，那就太好了。

我会稍后详细介绍他们的服务。那么，话不多说，我们开始吧。首先，让我们安装pandas。我为这个系列使用了一个干净的虚拟环境，但如果你不想使用虚拟环境，也没关系。如果你不知道虚拟环境是什么，并希望了解更多信息。

那么我会在下面的描述部分留下我关于这个主题的视频链接，供有兴趣的人参考。安装pandas真的很简单。我们只需输入pip install pandas，然后让它运行。一旦我们安装了pandas，我们还需要安装Jupyter，以便使用Jupyter notebooks。

我对在这个系列中使用Jupyter有些犹豫，因为有些人觉得它很难上手。但老实说，如果你要使用pandas进行大量工作，那么它绝对是一个不错的工具。所以现在并不是必要的。如果你使用常规编辑器，也可以很好地跟随这个系列。

Jupyter notebooks可以通过浏览器更轻松地展示我们的数据和表格，使其更容易可视化。因此，我将在这个系列中使用它，但你不必这样做。要安装Jupyter，我会输入pip install jupyterlab，这个拼写是J U P Y T E R L A B。我们将安装它。

现在我不会在这个系列中深入探讨如何使用 Jupyter。我主要会专注于 pandas。但如果你想要详细了解如何使用 Jupyter，我有一个相关的视频。

Jupyter 深度介绍，如果有人想了解更多关于使用它的详细信息，我将在下面的描述部分留下那个视频的链接。好的，现在我们已经安装了 pandas 和 Jupyter 笔记本，现在我们需要下载我将在本系列中使用的数据。对于那些一直在观看我最新视频的人，你们知道我喜欢使用 Stack Overflow 开发者调查进行不同类型的数据分析。之所以喜欢使用这些数据，是因为它是现实世界中的数据，并且其中有很多我认为对观看这些视频的人来说有趣的数据。

我见过一些其他的教程，其中的数据似乎有些不切实际，不太相关。因此，希望使用这些数据能让人们保持兴趣，同时也能让你对如何从来源下载真实数据并开始使用 pandas 进行分析有一个好的了解。

为了下载这些数据，我在浏览器中打开了这个。我们可以去 Stack Overflow 调查结果页面。现在这很简单，只需 Google 一下即可。但为了简单起见，我将在描述部分提供这个下载页面的链接。好的，现在在这个页面上，你可以下载任何年份的 CSV 格式的数据。

现在我要下载 2019 年的数据，这是这里的顶部数据。因此，我将下载这个 cv，然后我们再点击下载，这应该会为我们下载。好的，确实下载了，现在我要在我的查找器中打开它。我将解压这个数据，它以压缩包的形式提供。一旦数据下载并解压。

我将把那个文件夹拖到我桌面上的一个文件夹里。我们也将在那里创建一个笔记本并分析这些数据。快速说一下，我没有打开这个。让我打开它。

Pandice 演示文件夹。然后这将会在查找器中打开。现在我将数据拖入我桌面上的这个 pandas 演示文件夹。因此，你的项目可以在任何地方。但我刚刚在桌面上创建了一个名为 pandas demo 的项目文件夹。这个文件夹除了我们刚刚拖入的数据外是完全空的。

现在我将重命名这个文件，因为这个名字有点长。我将把它重命名为数据，这个数据被命名为开发者调查2019。但我只是称之为数据，这样我们在脚本中更容易找到。好的。那么在我们解压的这个数据目录中，我们有什么文件呢？

让我把这个放大一点。好的，首先，如果你下载的数据附带有readme文件，那么这通常是有帮助的。我们在这里有一个readme文件。它告诉你其他文件将是什么。所以在这种情况下，我们有。

调查结果包含主要调查结果，每个响应者一行，每个答案一列。调查结果模式在这里有与结果中每个列名对应的问题。如果现在有任何内容不清楚，那么在我们打开这些数据时就会明白。所以我这里只是给出一个大概述。不要让我说的所有内容让你感到不知所措。

一旦我们在Jupyter中打开它，这会更有意义。所以我们就开始吧。为了在Jupyter笔记本中打开这个，我会回到我的终端。所以我会关闭这里打开的Finder窗口，回到我的终端，现在在这里，我将导航到放置数据的文件夹。

在Mac、Linux和Windows上，这应该是相同的命令。所以我会说C，并将转到我的桌面。这个位置将是你项目目录的所在位置。

但我的演示在桌面的这个Pandas上，一旦我导航到该目录就可以启动Jupyter笔记本。我们只需要输入Jupyter notebook并运行它。我们应该看到一个服务器在这里启动。看起来花了一秒钟。好吧，来了。现在，回到我们的终端，这将运行一个Jupyter服务器。在你使用Jupyter时，你需要保持该终端窗口打开。

Jupyter在浏览器中运行，所以如果你关闭这个服务器，你将无法访问我们的笔记本。好的，所以让我们回到浏览器。这是我们有Jupyter笔记本的地方。让我放大一点，这样大家就能看得比较清楚。好的，我将放大到差不多这个位置，我觉得很好。好的。

所以我们可以看到我们下载的数据文件夹，放在我们的Jupyter演示文件夹里。不久前。但现在让我们创建一个新的笔记本。为了创建新的笔记本，我将在右上角点击“新建”，然后选择Python 3。😊。

现在我们可以命名我们的笔记本。所以上面说无标题的地方，我要点击这里，称其为 pandas 演示并重新命名。好的，现在我们准备开始使用 pandas，因此我们可以通过说 import pandas as PDD 来导入它。将 pandas 导入为 PDD 是使用 pandas 的常见惯例。所以让我们运行它。

我通过按 shift 和 enter 运行了那个单元。再次说明，我不会在这一系列中深入讨论在 Jupyter 中工作的具体细节，但如果你想了解我将使用的功能和快捷键的概述，我在下面的描述部分有我的 Jupyter 视频链接。好的。

所以在视频的其余部分，我们将看到如何加载数据，并查看一些关于该数据的信息。我们的数据是 CV 格式的。因此，为了读取这个 CV，我们可以简单地说 D F，这将代表数据框。我们将在稍后学习有关数据框的一切。

我们将说 D F 等于 P D.dot.read_ CV。我们将使用这里的 pandas 的 read CSV 方法。现在我们只需传入 CV 文件的路径。我的文件在数据文件夹内，文件名为 survey_ results_ public。😊，CSV。

现在如果我按下 shift，然后那将运行这个单元。所以一开始，我们可以看到这非常简单易用。因此在使用原生 Python 来读取 CV 文件时，我们需要使用 Cv 模块来创建 CSV 读取器等。

但这里我们只是将这一切放在一行中。因此当它读取时，它将以数据框的形式读取。因此，数据框几乎是 pandas 的支柱，我们将在下一个视频中深入探讨数据框和序列对象。

但就基础而言，数据框基本上只是数据的行和列。我们可以通过打印出来看看数据框的样子。这就是使用 Jupyter 笔记本的好处，因为它允许我们以其他编辑器无法做到的方式可视化这些内容。

所以在 Jupyter 中，我可以简单地说 D F，然后运行它。它将打印出我们的。😊。数据框。因此我们甚至不需要在这里用 print 函数包裹它。现在，如果你使用普通编辑器，你仍然可以打印出数据框信息，但它看起来不会像在 Jupyter 中那样好，因为我们得到了这个交互式表格。所以这是我们数据的一个小概览。

现在这里实际上有 85 列，但如果我滚动这些，它看起来并没有实际打印出 85 列。因此，这实际上是默认连接的，只是为了给我们一个数据的广泛概览。因此，默认情况下，Jupyter 显示我们数据框的 20 列。现在。

我是怎么知道这个数据框有85列的呢？有一些属性和方法可以帮助我们了解数据的样子。首先，我们有形状属性，shape。它以元组形式给我们行数和列数。让我们来看看这个。在下面的单元格中，我要说 Df.shape。

我将运行这个。现在这里是一个属性。它不是一个方法。所以你不需要加括号。所以 Df.shape。我们可以看到我们有88000行和85列。如果你想要更多信息，我们可以使用信息方法。信息方法会告诉我们行数和列数。

还有所有列的数据类型。在我运行这个之前，看起来我的文本有点被切断了。有时在使用Jupyter时会发生这种情况。为了修复这个问题，我通常会上面重新启动并重新运行我的所有单元格。

这通常可以解决问题。让我们看看是否有效。好的，这似乎有效。你还可以做的另一件事是完全重新加载页面和浏览器。当你重新加载页面时，我觉得这只是因为我把文本放大了，所以它有点影响这些的显示，但现在我们可以清楚地看到这些。好的。

正如我所说，我们可以看到这里有88883行和85列。如果你想要更多信息，我们可以使用信息方法，这将告诉我们行数和列数，以及所有列的数据类型。让我们运行这个。如果我输入 Df.info。哦，Df.info。这实际上是一个方法，所以我们需要加上括号。让我运行这个，现在让我们查看这个输出。我们可以看到这里说我们有88883条记录。

所以这些是我们的行，我们总共有85列，然后列出了我们所有的列数据。这些是我们加载的CSV文件中的所有列。现在它还给出了每一列的数据类型，我们将在未来的视频中讨论数据类型，但大多数情况下，对象通常表示字符串，然后还有其他类型。因此，int64就是整数，float是浮点数，可能是小数。这个数据中没有其他数据类型，但一般来说还有更多数据类型。所以我会确保在不久的将来专门制作一个关于数据类型的视频。好的，现在我们知道行数和列数，让我们在Jupyter中更改一个设置，以便我们可以看到所有列。我认为看到这些会很有用，即使有很多需要滚动浏览的内容。

更改一个设置，我将来到这里的底部，使用PD.set_option来更改一个设置。在这里，我将说display.max_columns，并将其设置为85，这样我们就能看到所有列了，我将运行这个。现在如果我们打印出数据框，我会返回到打印这个数据框的地方，重新运行那个单元格，现在如果我滚动这些列。

然后我们可以看到，现在看起来我们确实有这85个不同的列在这里。因此我可以继续滚动，继续滚动，而不是像之前那样在20的地方被截断。现在，显然行也在这里被连接在一起，我们肯定不想打印出所有89000行。

不过在某些数据集的例子中，您可能想看到所有行。例如，我提到的下载中包含的调查结果模式CSV文件提供了与这些列名对应的匹配问题。

所以如果我们想知道这些列名在这个数据中意味着什么，那么我们也可以加载那个模式CSV文件，让我来做这个。我将到达笔记本的底部，只需通过说schema_df来加载它。现在我不想仅仅称其为Df，因为我们不想覆盖其他数据框，我将像之前那样通过说PD.read_csv来加载它，这在数据文件夹中，名为survey_results_schema.csv。现在我运行这个，看看我们刚加载的模式数据框，这里在这列中，给出了我们其他数据框中的所有列。

主要分支，爱好者，如果我向上滚动到那个数据框，我将删除这里的信息，因为我们不再需要它。如果我向上滚动到这个数据框，我们可以看到响应者的主要分支和爱好者。所以如果我们想知道这些意味着什么，那就是我们使用模式的原因，这样我们就可以看到主要分支或爱好者意味着作为爱好编写代码，主要分支则是哪个选项最能描述。

现在它实际上连接了文本，为了看到完整的文本，我们可以更改一个选项，或者直接访问这个值。我将在下一个视频中向您展示如何做到这一点。但是现在我们可以看到，我们看不到与每个列名相关的问题的所有行。

记住我们有85列。但是在这里我们只能看到前五列，然后我们看到这里的省略号，接着可以看到最后五列。所以我们来设置一下，以便查看85行，然后重新打印，这样我们就能看到所有内容了。因此回到我们设置最大列数的同一个单元格，现在我们也要为行添加一个设置。我只是复制并粘贴，但这里不再是最大列数。

我将把这个设置为最大行数，然后运行它，现在我们将重新运行这个模式数据框。我们可以看到所有列和相应的问题文本。如果你想知道这些列的含义，这就是我们的做法。例如，“你是你家里的支持者吗？”这可能是一个是或否的问题。这就是它们的意思。如果你在自己查看这些数据时，不知道某一列在我们的调查数据中意味着什么，你可以随时使用这个作为参考。

如果你不想翻阅所有内容来寻找特定的行或列名，那么在未来的视频中，我们将学习如何过滤数据框，并查看如何获取某一列等于特定值的行。目前我们可以看到我们模式数据框的85行，但你可能在想。

嗯，那很好，但我不想每次查看调查数据时都看到85行。不过，我们可以使用几种方法，只查看特定数量的行。这些方法你可能会经常使用，以便确认你的过滤器和数据框是否正常工作。因此，我们可以通过说而不是直接使用Df来查看前五行。

我们可以说Df.head()，如果我运行这个命令，我们将得到前五行数据。你可以传入一个数字，如果你想看到特定数量的值。如果你想查看前10行，那么我们可以传入10给df.head()，这将给我们前10行，因此我们可以看到从0到9的所有数据。如果你想查看最后几行而不是前几行，那么我们可以使用tail()方法。

但是如果我们传入一个数字，就像使用head()一样，那么我们现在要说的是我们希望在数据中获取最后10个条目。这是我们数据的最后10个项目。好的，这就是关于安装pandas、下载数据以及如何将数据加载到Jupyter中的简要概述，以及如何读取这些内容。在结束之前。

我想提一下这个视频的赞助商，那就是brilliant org。在这一系列中，我们一直在学习关于pandas的内容，以及如何使用它。

在Python中分析数据，brilliant是补充你在这里学习内容的绝佳方式，他们提供实践课程，可能有一些优秀的课程和课程内容，深入探讨如何正确思考和分析数据，特别是数据分析基础。

我非常推荐查看他们的统计课程，它展示了如何分析图表并确定数据中的显著性。同时，我也推荐他们的机器学习课程，这个课程将数据分析提升到了一个新水平，同时你将了解那些允许机器在变量过多时做出决策的技术。因此，请支持我的频道，并进一步了解Brilliant。

你可以访问brilliant.org/cs注册免费账户。而且，前200个访问该链接的人将享有年费高级订阅20%的折扣。你可以在下面的描述部分找到该链接。再次强调，这是brilliant.org/cs。所以我认为这就是我们第一次关于Pandas视频的全部内容，希望你们觉得对如何安装Pandas和加载数据有了良好的介绍。

在下一个视频中，我们将学习更多关于数据框的内容，并学习系列数据类型。因此，我们将以更易于理解的方式思考数据框，并查看如何抓取特定的元素、列和行。

所以请确保继续关注。但如果有人对本视频涵盖的内容有任何问题，请随时在下面的评论区询问，我会尽力回答。如果你喜欢这些教程并想支持它们，还有几种方式可以做到这一点。

最简单的方式就是给视频点赞并支持。此外，分享这些视频给任何你认为会觉得有用的人也是非常有帮助的。如果你有条件，可以通过Patreon进行支持。该页面的链接在下面的描述部分，确保订阅以获取未来的视频，谢谢大家的观看。

😊。

用Pandas进行数据处理与分析！真实数据&实时讲解，学完就能上手做数据分析了！＜实战教程系列＞ - P2：2）DataFrame和Series基础 - 选择行和列 - ShowMeAI - BV1M64y187bz

嗨，大家好，最近怎么样？在这个视频中，我们将继续学习更多关于Pandas的知识。具体来说，我们将学习数据框和系列数据类型。因此，正如我在上一个视频中所说的，这些基本上是Pandas的支柱，是你最可能使用的两种主要数据类型。在这个视频中，我们将讨论如何以不同的方式看待数据框和系列数据类型。

然后我们将了解如何从这些数据类型中获取信息的基础知识。现在，我想提到的是，我们为这个视频系列提供了赞助商，那就是Brilliant.org。因此，我真的很感谢Brilliant赞助这个系列。如果大家能通过下面描述部分的链接查看他们，并支持赞助商，那就太好了。

我会稍后再谈谈他们的服务。说到这里，让我们开始吧。好的，首先，让我们看看什么是数据框，然后我们将更多地了解如何将其视为Python对象。我们在上一个视频中简单查看了数据框，以确保我们的数据正确加载。

所以这些是😊，在Jupyter中显示为行和列的项目。基本上是一个表格。那么让我们看看这是什么样子。如果你跟着上一个视频，这基本上是我之前的同一个Jupyter笔记本，只是稍微整理了一下。因此，我们在这里导入Pandas，读取我们的Cv文件。

所以一个是我们调查结果的主要数据框，一个是我们模式结果的模式数据框。然后我们在这里设置了一些选项，最大列数设置为85，这样我们就可以看到所有列，最大行数设置为85，这样我们就可以看到所有模式。如果你到目前为止还没有跟上视频。

那么我在下面的描述部分有一个链接，指向你可以下载这些数据并跟随这个视频的地方。好的，这里是一个数据框。因此，当我们打印出Df的头部时，这就是返回的结果。所以这是我们数据框的前五行，你可以看到数据框由多行组成，我们也有多列。所以就这组数据而言，这些是调查结果，但你的数据可以是任何东西，最有可能以行和列的形式呈现，就像一个表格。因此，对于这组数据，作为调查结果，每一行是一个回答调查的人的回答，每个问题是他们对调查中该问题的回答。举个例子。

这个回应者编号一在这里回答说是的。他们是一个爱好者，如果你想知道爱好者是什么意思，我们可以像在上一个视频中看到的那样查看我们的模式数据框，所以让我在这里打印出来，让我们看一下。如果我查看爱好者的定义，我们可以看到那个问题是“你是否把编码作为爱好”。

所以这就是这些数据的含义。这让我们对数据框有了一个基本的概念。数据框基本上就是行和列。但现在让我用原生 Python 来解释我对数据框的理解。如果我们只使用 Python，而不使用 pandas 来将信息存储在行和列中，我们该如何做到呢？对于那些熟悉字典的人，你可能会认为以这种方式存储信息是个好主意。

所以让我在这里打开一个新笔记本，其中有一些代码片段，让我们来看看这个。好的，让我们看一下第一个单元格。我们中的很多人可能都熟悉 Python 字典，其中有键和值。所以如果我在这个例子中表示一些数据，例如一个人，那么我们可以使用字典。首先，我有一个键是“first”，表示名字，然后它的值是 Corey，我们还有姓氏和邮箱的键和值。

好的，这个字典代表一个人的数据。但我们如何表示多个人的数据呢？嗯，可能有几种不同的方法可以做到这一点，但我喜欢在学习 pandas 时将字典中的所有值都视为列表。

所以让我们在第二个单元格中看看这是什么样子的。现在在第二个单元格中，我们可以看到我们有一个与上面相似的字典，但现在值不再是单个字符串，而是一个列表，目前这个列表中只有一个人。但现在由于这是一个列表，我们可以在这里添加更多的名字和信息。

所以我们的列表的第一个值将是我们的第一个人。如果我在底部查看第三个单元格，现在我们可以用这个例子来看一下多个人的情况。列表中的第二个值将是我们的第二个人，列表中的第三个值将是我们的第三个人。

所以如果我们在这里查看，我们有人的信息，有一个键是“first”。所以如果我们想要这里的第二个人，我们查看第二个值。那是简。姓氏是 Do，邮箱是第二个值，Jane Do at email do com。如果你想要第三个人，那就是约翰，第三个值的姓氏是 Do。

第三个值和电子邮件是John Do at email com。所以我们可以将其视为行和列。键是列，值是行。现在，如果你在线查找pandas数据框的定义，你会看到许多定义，仅仅说它是一个二维数据结构。虽然这听起来有点混乱，但用外行的话来说，基本上就是指行和列。好吧，正如我所说，电子邮件的键将是我们的电子邮件列，并包含所有电子邮件值。如果我们想查看电子邮件列，那么我们只需访问那个键。

所以如果我在这里下来，实际上让我快速运行所有这些，我想我在没有运行这些的情况下打开了这个，所以我想确保我们已注册好。如果我想查看那个电子邮件列，我可以简单地说people，然后访问那个电子邮件键。如果我运行它，我们可以看到所有的电子邮件。现在，我想向你展示这一点是因为我觉得这真的帮助我理解了如何思考数据框。

所以数据框与此非常相似，但功能比我们在标准Python中拥有的更多。现在我们实际上可以从这个字典创建一个数据框，看看它是什么样子。让我们这样做，看看一些基本的数据框功能，然后我们将利用上个视频中的Stack Overflow数据深入探讨。所以在这个底部单元格中，为了从这些信息创建一个数据框。

我们在这里有的信息，我将继续导入pandas。所以我将说import pandas as PD，现在我们可以使用上面这个字典实际创建一个数据框。所以要做到这一点，我可以简单地说Df等于PD的data frame，注意大小写，这里是大写的D和F。

然后我们将传入一个包含值作为列表的字典。如果我运行这个，似乎没有任何错误运行良好。现在让我打印出Df。如果我打印出来，我们可以看到现在我们的数据框以一种方式表示，能够可视化出行和列。所以我们得到了这些人以一个漂亮的表格显示出来。

现在我们左边还有一些没有列名的值，这就是索引。我现在不想深入讨论，因为下一个视频将会涉及这个内容，但基本上这是我们行的唯一值。它不需要是唯一的，但我们将在专门讨论索引的视频中详细讨论。

现在我们对如何思考数据框有了一定的了解。现在让我们看看如何在数据框中访问信息。首先，让我们访问单个列的值。就像我们在字典中做的那样，我们可以像访问字典的键一样访问单个列。

就像我在这里做的人和电子邮件一样。我可以在这里做类似的事情，只需说我想要数据框的电子邮件列。现在，这实际上并不是一个访问数据框列的关键。但是我们可以看到，我们从数据框中得到了所有电子邮件。因此，我想强调的是，我只使用纯 Python 示例。

我们可以对数据框的思考方式有一个大致的想法，但正如我所说，数据框远不止是一个列表字典。例如，我们可以看到当我们显示这里的电子邮件列时，它的显示方式与我们从字典中显示值的列表不一样，因为这实际上返回的是一个系列，如果我检查这个电子邮件列的类型，我们就能看出。

所以让我运行一下。我们可以看到这是 pandas 核心系列对象。所以这是一个系列对象。那么什么是系列呢？系列基本上仍然是一个数据列表。但正如数据框一样，它比这要具备更多功能。现在，如果你在网上查找系列的定义，你会看到很多定义只说它是一个一维数组。

这可能听起来有些困惑，但通俗来说，这基本上意味着它是数据行。因此，你可以将数据框视为行和列，而系列则是单一列的行。因此，数据框基本上是多个系列对象的容器。所以这很重要。让我再说一遍。

所以我们可以看到，这里数据框是二维的，因为它有行和列。我们可以看到它包含名字、姓氏和电子邮件。现在，每当我们只访问电子邮件时，我们就可以看到这里的所有电子邮件。现在，这是一个系列。我之前提到过，数据框基本上是多个系列对象的容器。

所以我们可以将这里的电子邮件列视为一个系列，这最后一列视为一个系列，这第一列也视为一个系列。我们还可以看到，当我们打印这个电子邮件的系列时，这个系列也有一个索引，就像我们的数据框一样。

所以这个索引在左侧，有0、1和2。好的，所以我们可以像访问关键一样访问数据框的单个列，就像我们在这个单元格中做的那样，但你可能还会看到一些人使用点表示法来完成同样的事情。所以你可能会看到一些人这样做，他们可能会写 Df. email。如果我运行这个单元格。

然后我们可以看到，让我去掉这个单元。为了让我们能够比较这两者，我们可以看到这给我们带来了相同的结果。无论我们是像键那样访问还是使用点符号，这都会返回相同的电子邮件值系列对象。无论你想用哪种方式，这真的只是个人偏好，我实际上更喜欢使用括号的第一种方式，原因有几个，我更喜欢使用它而不是点符号，首先是我喜欢使用括号，因为有可能你的某一列与数据框的某个属性或方法同名。

如果是这种情况，那么使用点符号可能会给你一些错误。例如，如果一个数据框有一个名为 count 的方法。如果你有一个名为 count 的列，而你尝试使用点符号访问那个 count 列，那么实际上这会访问。

数据框的 count 方法，而不是 count 列。所以我们这里的做法实际上是不可行的。如果你想访问实际名为 count 的列，虽然在这个特定数据框中我们没有这个列，但如果有，我们将不得不这样访问。所以这就是我更喜欢使用括号的原因。

所以在这个系列中我将会使用括号。但我想让你知道点符号的用法，因为如果你和其他使用 pandas 的人一起工作，那么你可能会看到他们用点符号来访问列。所以你需要知道这至少是一种可能性。而且再一次。

这并不意味着他们在做错，只是个人偏好。我更喜欢使用括号。所以我说数据框的功能远比我们使用标准 Python 所看到的要多得多。那么让我们看看我们可以在这里做的一些其他事情。

假设我们想要访问多个列。为了访问多个列，我们可以使用括号符号并传入我们想要的列的列表。所以如果我想要姓氏和电子邮件这两列，那么我们可以说 Df 并使用我们的括号，就像我们之前看到的那样。

但现在我将放入一组内层括号，作为我想要访问的列的列表。所以对于第一个值，我将输入姓氏，对于第二个值，我将输入电子邮件。所以如果我运行这个，我们可以看到现在返回了一个包含姓氏列和电子邮件列的数据框。现在我想再次强调，我在这些括号中传入了一个列表。

所以有两对括号。你不能省略内层括号，因为你很可能会遇到键错误，因为 pandas 会认为你将这两个字符串作为单个列名传入。还有一点我想在这里指出的是，现在我们在获取。

多个列这不再是一个系列，因为记住，系列基本上是单列的行。所以当我们像这样获取多个列时，它只是返回另一个DataFrame。在这种情况下，它是一个仅包含这些特定列的过滤DataFrame。

所以我们过滤掉了第一列的名字，只保留了姓和电子邮件。好的，这就是我们如何获取特定列或多列，我们也可以像切片列表一样进行切片。不过我将在稍后的更大Stack Overflow数据集中展示这一点。现在，如果你有很多列并想轻松查看所有列。

我们可以通过说Df.columns来特定地获取列。我们可以运行这个，看到它给我们所有的列。所以我们的列是first、last和email的索引。好吧，现在我们已经看到如何获取一列，但我们该如何获取一行呢？因此，要获取行。

我们可以使用lo和i lo索引器，分别是lo和i Lo。让我们看看这些。首先，我们来看i Lo。i Lo允许我们通过整数位置访问行，因此名称为i Lo即整数位置。所以如果我想获取第一行，我们可以直接说Df.i Lo，然后在这里使用括号，因为这是一个索引器，使用括号并传入0，这样就能给我们第一行。

所以如果我运行这个，我们可以看到第一行的名字是Cory，姓是Shaefffer，电子邮件是coreium.schaffer@gmail.com。所以它返回的是一个包含第一行数据值的系列，正如我所说的，这是名字。

这是这个例子中第一个人的姓和电子邮件。再说一次，我们还没有讨论索引，这将在下一个视频中讲解，但这里的索引是列名，以便我们知道这些值是什么。所以在这里我们的索引是0、1和2，但每当我们实际访问一行时。

它将把索引设置为列名，以便我们知道这些值是什么，因为如果它只是说0、1和2，我们可能不知道它们是什么。就像当我们选择多个列时，我们也可以通过传入一个整数列表来选择多行。所以如果我想要第一和第二行，我们只需说，再次强调，这将在这些括号内形成一对括号，因为我们在这里将一个列表传给索引，我将传入0和1的列表。

所以如果我运行这个，我们可以看到现在我们得到了前两行数据。再说一遍，请确保在这些括号内传入一个整数列表，这样它才会按预期执行。同时，我们可以看到现在我们得到了一个包含这些多行的DataFrame。现在，使用这些i lo和lo索引器，我们也可以选择列。

这将是我们传递给外部括号的第二个值。所以如果我们把ilo和lo看作函数，那么我们可以把想要的行视为第一个参数，把列视为第二个参数。让我给你展示一下这是什么样的。这里是我们的内部括号。那些是我们想要的行。但是现在在那个列表后面，我们可以加一个逗号。

现在我们可以指定想要的列。使用i Lo时，我们不能指定实际的列名，因为这些使用的是整数位置。因此这些仅适用于整数。记住，我们的名字是第一列，姓氏是第二列，电子邮件是第三列。

如果我们想要前两行的电子邮件地址，那么我们可以抓取索引为2的列，这将是第三列，因为所有这些都是从零开始的。如果我在这里传入一个2并运行它，那么我们可以看到现在得到了这前两行的电子邮件地址。好的，这就是ioc。现在让我们看看Lo。与ioc相比。

我们之前是通过整数位置进行搜索的，现在我们将通过标签进行搜索。当我们谈论行的标签时，这些将是索引。而且目前我们没有自定义索引。所以这个索引只是一个默认的整数范围。因此，目前这在某种程度上与i Lo相似。

我们将看看使用实际标签的Lo的用例，下一期视频将介绍索引。因此，快速来看一下我们的整个数据框。我会在这里打印出来。正如我所说，左边这些是我们的索引。这些是该行的标签。如果我想要第一行，那么默认情况下。

这只是一个标签为0的行。所以我可以说Df do lo并传入一个0。如果我运行它，我们可以看到得到了标签为0的那一行。再说一次。我知道目前看起来与i Lo相似，但我们将在下个视频中看到如何使用带标签的索引。就像使用i Lo一样。

我们还可以传入一个列表，以指定多个行。因此，如果我想要第一行和第二行，就像使用i Lo一样，我可以在这里传入一个内部列表。假设我想要第一行和第二行。我会运行它。我们可以看到现在得到了第一行和第二行。再说一次。

现在我们可以看到，返回了一个数据框，因为我们有多个R，而且就像I Lo一样，我们也可以在索引器中传入第二个值，以选择这些行的特定列。现在，使用Ilo时，我们用整数选择列。但现在使用Lo时，我们可以使用标签。所以如果我们想要这前两行的电子邮件列。

现在我们可以直接传入电子邮件的值。如果我运行它，我们可以看到现在得到了这前两行的电子邮件值。我没有在IL中展示这一点，但我们也可以为列传入一个列表。所以如果我想要这几行的姓氏和电子邮件。

然后在这里作为第二个值传入字符串，而是可以传入我们想要的列的字符串列表。所以我将把它用括号括起来。我知道所有这些内部括号可能会让人有点困惑。但假设我们想要电子邮件和姓氏。所以如果我运行这个。

现在我们可以看到这些特定的列。电子邮件和姓氏对应于这特定行，标签为 0 和 1 的行，同时注意到列的显示顺序与我们在 Lo 中使用的列表顺序不同，上面是先名后姓，但我们请求的是电子邮件和姓氏，它以电子邮件和姓氏的顺序返回给我们。现在我们已经看到了从小数据集中抓取特定行和列的基础知识，现在让我们回到上一个视频中的数据，看看如何从 Stack Overflow 数据集中抓取一些行和列。我将回到我们的 pandas 演示，这里再快速回顾一下我们拥有的数据，我们在导入 pandas，Df 是我们的主要调查结果。

我们的模式 Df 作为我们的模式。我们在这里设置了一些选项。这是我们的主数据框头部的样子，即前五行。然后这是我们的模式的样子。所以我将在我们的模式下方进行一些操作。现在让我们稍微复习一下我们学到的内容，并挑选出某些行和列。

但首先，让我们看看这个数据框中有多少行和列。我们在上一个视频中看到了几种不同的方式来做到这一点。所以最简单的方法是使用 shape 属性。所以如果我说 Df.do.shape 并运行这个，那么我们可以看到我们有 88000 行和 85 列。

所以让我们抓取 hobbyist 列的所有响应。再次重申，我在这里想做的是，如果我们查看我们的主数据框，我想抓取这一列的所有响应，hobbyist。好的，我们该如何做到这一点呢？如果你还记得，如果你要查看可用的列。

然后你可以说 Df 做列来查看所有这些。我们可以看到这些列有点长。这里有 85 列。但这里我们有 hobbyist，这是我们想要的。这个问题是人们是否把编程当作爱好来回答的。接下来的视频中，我们将讨论索引。

我将展示我们如何搜索模式数据框以找到确切的问题，这样我们就可以看到数据框中哪些问题对应于特定的列。但现在，让我们直接抓取这些 hobbyist 响应。所以如果你记得我们刚刚看到的小数据集，要抓取 hobbyist 列，我们可以像访问键一样访问它。所以如果我说 Df，然后传入 hobbyist。

然后我们得到了所有回复的系列。幸运的是，这不会在我们的浏览器中显示所有 89000 行。但是我们确实得到了数据的头部和尾部，以便了解这些回复的样子。现在，快速让我给你展示一些我们在系列后面会更深入讨论的内容。

但我想让你了解 pandas 这样的东西有多强大。所以假设我们想知道这些回复中有多少是回答“是”的，有多少是回答“否”的。现在，如果我们使用常规 Python，我们可能会导入计数器类，或者写一个快速函数或循环来做到这一点。

但是 pandas 已经内置了很多这样的功能。因此，为了获取这一列中唯一值的计数，我可以直接使用这个值计数方法来计算。所以在这里，我只需添加一个 value_counts 方法。现在，再次。

这将是未来视频的内容。但我只是想让你了解 pandas 能做什么。因此，每当我添加这个值计数方法时，我们可以看到在我们返回的这个系列中，对于所有回答这个爱好者问题的人中，71000 人表示是，他们确实把编程作为爱好，大约 18000 人表示否，他们并不把编程作为爱好。再次提到，当我们深入学习数据分析时，我们会在未来的视频中讨论更多内容。

但是我想让你快速了解一下，为什么学习 pandas 是有益的，就像我们在这里做的那样。这使得这类事情变得非常简单，我们可以进一步绘制图表等等。好的，但在这个快速的偏离话题之后，让我们继续并回顾一下我们之前学到的其他内容。所以我们这里有一列。

所以让我去掉那个值计数。所以我们有我们的列在这里。那么现在让我们获取特定的行和特定的列。我们获取第一行，同时也获取那一行的相同爱好者列。那么我们如何抓取行呢？请记住，如果我们想抓取行，我们使用 lo 或 i Lo。

indexers 所以我将继续使用 Lo，因为请记住，这是允许我使用标签的那个，我将为爱好者列名使用一个标签，而不是整数。现在再次提到，由于我们只是使用默认索引，我们可以在这里看到索引，0，1，2，3。

由于我们只是使用默认索引，而不是自定义索引，我们当前的索引标签只是从 0 到 88000 的一系列值。因此，为了获取第一行，我可以说 Df 的 Lo，并传入那个第一个索引的标签。在这种情况下，它只是 a0。这是第一位受访者的所有回复。所以这是某个人的整个调查结果。

现在如果我们想查看仅针对那个爱好者问题的结果，那么请记住。在这里的括号内，我可以传入我想要的列的第二个值。所以如果我传入爱好者，那么我们可以看到他们的回答是否作为爱好编程是“是”。而且像我们之前看到的，我还可以传入多个行或多个列的列表，以获取我们想要查看的确切行和列。

所以要获取爱好者列的前三个响应，而不是仅仅传入一个值，我可以在这里放一些内括号，并传入多个行的列表。如果我在这里传入三个行的列表，并运行这个，那么这些就是爱好者列的前三个结果。现在，我们还没有看到的一件事是，我们也可以使用切片来抓取多个行和列。如果您熟悉列表切片，那么这几乎是同样的事情。唯一的区别是我们的最后一个值将是包含的，至少在Lo中是这样。

所以如果我们想要前三行，那么我们可以说我们想从0开始，然后切片到2的索引。如果我运行这个，哎呀，我不小心在这里犯了个错误，实际上，无论何时使用切片，我们都不将其包装在括号中。所以我将把它去掉。所以对于我们的第一个值。

我们只是说我们不再传入一个值的列表，我们只是传入从0开始的切片，然后是冒号2。所以如果我运行它，我们可以看到现在我们得到的结果与之前相同。我们也可以用列来做到这一点。所以现在，我们只获得爱好者列。

但是让我们回去看看我们的列，看看爱好者列之后有哪些列。在这里，这些都是我们的列，我们打印出来了。所以让我们看看爱好者之后的几列。所以我们有开源者，开源就业。假设我们想从爱好者一直获取到这个就业列的所有列。

为了做到这一点，我只是复制那个。我们可以在这里向下走，我们可以直接传入一个冒号然后是就业。这样就会从爱好者切片到就业。现在，我还想指出，这是切片包含这些值的原因，因为想象一下这会多麻烦。

如果我们想要从爱好者到就业的所有列，但最后一个值不是包含的，我们必须上面说，如果我从爱好者到就业，那么我真的需要传入，您知道的，爱好者到国家，而国家不包含。那就会太混乱了。

所以这里变得更加包容。如果你在想他们为什么这样做，那就是原因所在。所以如果我运行这个，那么我们可以看到现在前面有这三行数据。对于前三行，我们获得了从业余爱好者到就业的所有列的响应。现在我们已经概述了到目前为止我们所学的关于探索数据框和系列对象的所有内容，以及如何提取一些基本信息。

现在还有很多关于数据框和系列对象的内容需要学习，我们将继续在pandas系列中学习更多内容，因为这两种数据类型是我们在pandas中使用的主要数据类型。因此我们将学习更多关于高级过滤查询的内容。

如何查看每一列的数据类型，还有很多其他内容。在结束之前，我想提到我们这段视频的赞助商是Brilliant。Brilliant是一个解决问题的网站，通过积极进行指导课程帮助你理解基础概念，Brilliant将是补充你在这里所学知识的极佳方式，他们有一些关于数据科学的优秀课程和教程，深入探讨如何正确思考和分析数据。因此，如果你在观看我的pandas系列，因为你正在进入数据科学领域，那么我强烈推荐你。

还建议你查看Brilliant，看看你可以学习到哪些其他数据科学技能。他们甚至在统计课程中使用Python，并会考核你如何正确分析语言中的数据。他们的指导课程将挑战你，但如果需要，你也可以获得提示或解决方案，这些课程非常适合理解材料。为了支持我的频道并了解更多关于Brilliant的信息，你可以访问brilliant org cms免费注册，前200位访问该链接的人将获得年度高级订阅20%的折扣，你可以在下面的描述部分找到该链接，再次感谢Brilliant。

org cms。

好的，我想这就是这段pandas视频的全部内容。我希望你觉得自己对数据框和系列对象有一个好的介绍，以及如何浏览一些数据。正如我所说的，关于这些数据类型还有很多内容要学习，以及一些高级过滤将在未来的视频中学习。所以请务必关注接下来的内容。在下一个视频中。

我们将学习更多关于索引的内容。在这个视频中我们看到了基本的默认索引。但在下一个视频中，我们将学习如何将索引设置为特定列及其好处。如果有人对我们这里讨论的内容有任何疑问，请随时在下面的评论区提问，我会尽力回答。

如果你喜欢这些教程并希望支持它们，有几种方式可以做到这一点。最简单的方式就是给视频点赞，点个赞。此外，分享这些视频给任何你认为会觉得有用的人也是巨大的帮助。如果你有条件的话，也可以通过Patreon进行支持。

在下面的描述部分有一个链接到那个页面。确保订阅以便观看未来的视频。感谢大家的观看。😊。