原文：Pandas Cookbook

协议：CC BY-NC-SA 4.0

译者：飞龙

在本章中，我们将介绍以下主题：

当以某种方式组合多个序列或数据帧时，在进行任何计算之前，数据的每个维度会首先自动在每个轴上对齐。 轴的这种无声且自动的对齐会给初学者造成极大的困惑，但它为超级用户提供了极大的灵活性。 本章将深入探讨索引对象，然后展示利用其自动对齐功能的各种秘籍。

如第 1 章，“Pandas 基础”中所讨论的，序列和数据帧的每个轴都有一个索引对象，用于标记值。 有许多不同类型的索引对象，但是它们都具有相同的共同行为。 除特殊的多重索引之外，所有索引对象都是一维数据结构，结合了 Python 集和 NumPy ndarrays的功能和实现。

在本秘籍中，我们将检查大学数据集的列索引并探索其许多功能。

从许多索引对象操作中可以看到，它与序列和ndarrays似乎有很多共同点。 最大的差异之一来自第 6 步。索引是不可变的，创建后就无法更改它们的值。

索引支持集合运算，并集，交集，差和对称差：

索引与 Python 集共享一些相同的操作。 索引在另一重要方面类似于 Python 集。 它们（通常）是使用哈希表实现的，当从数据帧中选择行或列时，哈希表的访问速度非常快。 当使用哈希表实现它们时，索引对象的值必须是不可变的，例如字符串，整数或元组，就像 Python 字典中的键一样。

索引支持重复值，并且如果在任何索引中碰巧有重复项，则哈希表将无法再用于其实现，并且对象访问会变得很慢。

每当两个序列或数据帧与另一个序列或数据帧一起操作时，每个对象的索引（行索引和列索引）都首先对齐，然后再开始任何操作。 这种索引对齐方式是无声的，对于那些刚接触 Pandas 的人来说可能是非常令人惊讶的。 除非索引相同，否则这种对齐方式总是在索引之间创建笛卡尔积。

笛卡尔积是一个数学术语，通常出现在集合论中。 两个集之间的笛卡尔积是两个集的偶对的所有组合。 例如，标准纸牌中的 52 张纸牌代表 13 个等级（A, 2, 3,..., Q, K）和四个花色之间的笛卡尔积。

生成笛卡尔积并非总是预期的结果，但是了解发生的方式和时间以避免意外后果至关重要。 在此秘籍中，将具有重叠但不相同的索引的两个序列相加在一起，产生了令人惊讶的结果。

请按照以下步骤创建笛卡尔积：

每个序列都是使用类构造器创建的，该类构造器接受各种各样的输入，最简单的是每个参数index和数据的值序列。

笛卡尔数学乘积与对两个 Pandas 对象进行运算的结果略有不同。s1中的每个a标签与s2中的每个a标签配对。 该配对在所得序列中产生六个a标签，三个b标签和一个c标签。 笛卡尔积在所有相同的索引标签之间发生。

由于带有标签c的元素是序列s2所特有的，因此 pandas 默认将其值设置为 missing，因为s1中没有标签可以对齐。 每当索引标签对于一个对象唯一时，Pandas 默认为缺少值。 不幸的结果是，将序列的数据类型更改为float，而每个序列仅具有整数作为值。 发生这种情况是因为 NumPy 缺少值对象。np.nan仅对于浮点数存在，而对于整数不存在。序列和数据帧的列必须具有齐次数值数据类型； 因此，每个值都转换为浮点数。 对于这个小的数据集，这几乎没有什么区别，但是对于较大的数据集，这可能会对内存产生重大影响。

当索引以相同顺序包含相同的完全相同的元素时，将发生上述示例的异常。 发生这种情况时，不会发生笛卡尔积，而是按其位置对齐索引。 请注意，每个元素均按位置精确对齐，并且数据类型仍为整数：

如果索引的元素相同，但是序列之间的顺序不同，则会产生笛卡尔积。 让我们在s2中更改索引的顺序，然后重新运行相同的操作：

有趣的是，Pandas 在同一项操作中有两个截然不同的结果。 如果笛卡尔积是 Pandas 的唯一选择，那么将数据帧的列加在一起这样的简单操作将使返回的元素数量激增。

在此秘籍中，每个序列具有不同数量的元素。 通常，当操作维中不包含相同数量的元素时，Python 和其他语言中的类似数组的数据结构将不允许进行操作。 Pandas 可以通过在完成操作之前先对齐索引来实现此目的。

先前的秘籍中有一个琐碎的示例，其中将两个小序列与不相等的索引一起添加。 处理较大的数据时，此问题可能会产生可笑的错误结果。

在此秘籍中，我们添加了两个较大的序列，它们的索引只有几个唯一值，但顺序不同。 结果将使索引中的值数量爆炸。

首先出现步骤 2，以创建两个唯一的对象，但实际上，它创建了一个由两个不同的变量名称引用的对象。 表达式employee['BASE_SALARY']从技术上讲创建的是视图，而不是全新的副本。 使用is运算符对此进行了验证。

在熊猫中，视图不是新对象，而只是对另一个对象的引用，通常是数据帧的某些子集。 此共享对象可能导致许多问题。

为了确保两个变量都引用完全不同的对象，我们使用copy序列方法，并再次使用is运算符验证它们是否是不同的对象。 步骤 4 使用sort_index方法按种族对序列进行排序。 第 5 步将这些不同的序列加在一起以产生一些结果。 仅检查头部，仍不清楚产生了什么。

步骤 6 向其自身添加salary1，以显示两个不同序列添加之间的比较。 此秘籍中所有序列的长度都已输出，我们清楚地看到series_add现已爆炸超过一百万个值。 索引中的每个唯一值都会产生笛卡尔积，因为索引并不完全相同。 此秘籍显着显示了将多个序列或数据帧组合在一起时索引可能产生的影响。

通过做一些数学运算，我们可以验证salary_add的值的数量。 当笛卡尔积在所有相同的索引值之间发生时，我们可以求和它们各自计数的平方。 索引中甚至缺少的值也会与它们自身产生笛卡尔积：

当使用加法运算符将两个序列加在一起并且一个索引标签没有出现在另一个索引标签中时，结果值始终会丢失。 Pandas 提供了add方法，该方法提供了一种填充缺失值的选项。

在本秘籍中，我们使用add方法的fill_value参数将baseball数据集中具有不等索引的多个序列合并在一起，以确保结果中没有缺失值。

add方法的工作方式与加法运算符相似，但通过提供fill_value参数代替不匹配的索引，可以提供更大的灵活性。 在此问题中，将不匹配的索引值默认设置为 0 是有意义的，但是您可以使用其他任何数字。

有时每个序列都包含与缺失值相对应的索引标签。 在此特定实例中，当添加两个序列时，无论是否使用fill_value参数，索引标签仍将对应于缺失值。 为了澄清这一点，请看以下示例，其中索引标签a对应于每个序列中的缺失值：

此秘籍展示了如何仅将单个索引添加到序列中。 也完全可以将数据帧一起添加。 将数据帧加在一起将在计算之前对齐索引和列，并产生不匹配索引的缺失值。 首先，从 2014 年棒球数据集中选择一些列。

Let's also select a few of the same and a few different columns from the 2015 baseball dataset:

如果行或列标签无法对齐，则将两个数据帧一起添加会丢失值。 使用style属性访问highlight_null方法可轻松查看缺失值的位置：

只有两个数据帧中都出现playerID的行才会丢失。 类似地，AB，H和R列是两个数据帧中唯一出现的列。 即使我们在指定fill_value参数的情况下使用add方法，我们仍然缺少值。 这是因为在我们的输入数据中从来没有行和列的某些组合。 例如，playerID congeha01和列G的交集。 他只出现在 2015 年没有G列的数据集中。 因此，没有任何值被填充：

所有数据帧都可以向自己添加新列。 但是，像往常一样，每当一个数据帧从另一个数据帧或序列添加一个新列时，索引都将在创建新列之前首先对齐。

此秘籍使用employee数据集添加一个新列，其中包含该员工部门的最高薪水。

步骤 2 和 3 找到每个部门的最高工资。 为了使索引自动对齐正常工作，我们将每个数据帧索引设置为部门。 步骤 5 之所以有效，是因为左侧的数据帧中的每行索引；employee与来自右侧数据帧max_dept_sal的一个且仅一个索引对齐。 如果max_dept_sal在其索引中重复了任何部门，则该操作将失败。

例如，让我们看看当我们在具有重复索引值的等式的右侧使用数据帧时会发生什么。 我们使用数据帧的sample方法随机选择十行而不进行替换：

注意索引中有几个重复的部门。 现在，当我们尝试创建新列时，将引发一个错误，警告我们有重复项。employee数据帧中的至少一个索引标签与random_salary中的两个或多个索引标签结合在一起：

并非等号左侧的所有索引都需要匹配，但最多只能有一个匹配。 如果左对齐的数据帧索引没有任何内容，则将缺少结果值。 让我们创建一个发生这种情况的示例。 我们将仅使用max_dept_sal序列的前三行来创建新列：

该操作成功完成，但仅为三个部门的填充了薪水。 没有出现在max_dept_sal序列的前三行中的所有其他部门导致值丢失。

college数据集有许多数字列，它们描述了有关每所学校的不同指标。 许多人都对在某些指标上表现最好的学校感兴趣。

此秘籍发现每个数字列具有最大值的学校，并设置数据帧的样式以突出显示信息，以便用户轻松使用。

idxmax方法非常强大，当索引被有意义地标记时，它变得非常有用。 出乎意料的是，MD_EARN_WNE_P10和GRAD_DEBT_MDN_SUPP均为object数据类型。 导入时，如果列中至少包含一个字符串，则 pandas 将列的所有数值强制转换为字符串。

通过检查步骤 2 中的特定列值，我们可以清楚地看到 在这些列中有字符串。 在第 3 步中，我们以降序排序，因为数字字符首先出现。 这会将所有字母值提升到该序列的顶部。 我们发现PrivacySuppressed字符串造成严重破坏。 Pandas 可以使用to_numeric函数将仅包含数字字符的所有字符串强制转换为实际的数字数据类型。 要覆盖在to_numeric遇到无法转换的字符串时引发错误的默认行为，必须将coerce传递给errors参数。 这将强制所有非数字字符串变为缺失值（np.nan）。

几列没有有用或有意义的最大值。 在第 4 步到第 6 步中已将它们删除。select_dtypes对于具有许多列的非常宽的数据帧极为有用。

在步骤 7 中，idxmax遍历所有列以找到每个列的最大值的索引。 它将结果作为序列输出。 SAT 数学和口语成绩均最高的学校是加利福尼亚理工学院。 洛杉矶东国大学的 25 岁以上的学生人数最多。

尽管idxmax提供的信息很好，但它不会产生相应的最大值。 为此，我们从max_cols序列的值中收集所有唯一的学校名称。

最后，在步骤 8 中，我们使用.loc索引器根据索引标签选择行，在第一步中将其作为学校名称。 此过滤器仅适用于具有最大值的学校。数据帧具有实验性style属性，该属性本身具有一些方法来更改显示的数据帧的外观。 突出显示最大值可使结果更加清晰。

默认情况下，highlight_max方法突出显示每列的最大值。 我们可以使用axis参数突出显示每行的最大值。 在这里，我们只选择college数据集的种族百分比列，并突出显示每所学校百分比最高的种族：

尝试在大型数据帧上应用样式会导致 Jupyter 崩溃，这就是为什么仅将样式应用于数据帧的头部的原因。

尝试自行实现内置数据帧方法可能是一个很好的练习。 这种复制可以使您对通常不会遇到的其他 Pandas 方法有更深入的了解。idxmax是仅使用本书到目前为止介绍的方法进行复制的一种挑战性方法。

此秘籍将基本方法缓慢地链接在一起，以最终找到包含最大列值的所有行索引值。

第一步通过将两列转换为数字并消除二进制列来复制上一个秘籍的工作。 我们在步骤 2 中找到每列的最大值。在这里，需要谨慎，因为 Pandas 会默默地丢弃无法产生最大值的列。 如果发生这种情况，则第 3 步仍将完成，但将为每列生成所有False值，而没有可用的最大值。

步骤 4 使用any方法在每一行中进行扫描，以搜索至少一个True值。 具有至少一个True值的任何行都包含一列的最大值。 我们在步骤 5 中对所得的布尔序列求和，以确定多少行包含最大值。 出乎意料的是，行多于列。 步骤 6 深入说明了为什么会发生这种情况。 我们对步骤 3 的输出进行累计，并检测等于每列最大值的总行数。

许多大学只有一个种族就拥有 100% 的学生人数。 到目前为止，这是最大的多个行的最大贡献者。 如您所见，SAT 成绩栏和大学本科生只有一排具有最大值的行，但是某些种族栏有最大值。

我们的目标是找到具有最大值的第一行。 我们需要再次取累加总和，以使每一列只有一行等于 1。步骤 8 将代码格式化为每行只有一个方法，并完全按照步骤 4 的方式运行any方法。 此步骤成功后，则True值应不超过列数。 步骤 9 断言这是真的。

为了验证我们是否在前几列中找到与idxmax相同的列，我们对has_row_max2本身使用了布尔选择。 列将以不同的顺序排列，因此我们将列名称的顺序转换为集合，这些集合固有地无序比较相等性。

可以用一长串代码将索引运算符与匿名函数链接起来，从而完成此秘籍。 这个小技巧使您无需执行第 10 步。在此秘籍中，我们可以估算直接idxmax方法与我们的手动工作之间的差异：

不幸的是，我们的工作速度是 Pandas idxmax内置方法的五倍，但是不管其性能如何下降，许多创新且实用的解决方案都使用布尔序列和cumsum累积方法来查找条纹或一个轴的特定模式。

大学数据集包含超过 7,500 所大学的 8 个不同种族的本科人口百分比。 找到每所学校本科生人数最多的种族，然后为整个数据集找到此结果的分布将是很有趣的。 我们将能够回答一个类似“哪个机构的白人学生比其他任何种族都要多”的问题。

在此秘籍中，我们使用idxmax方法找到每所学校的本科生百分比最高的种族，然后找到这些最大值的分布。

此秘籍的关键是要认识到所有列都代表相同的信息单元。 我们可以将这些列相互比较，通常是而不是情况。 例如，直接将 SAT 口语成绩与大学生人数进行比较是没有意义的。 由于数据是以这种方式构造的，因此我们可以将idxmax方法应用于数据的每一行，以找到具有最大值的列。 我们需要使用axis参数更改其默认行为。

第 2 步完成此操作并返回一个序列，我们现在可以简单地对其应用value_counts方法以返回分布。 我们将True传递给normalize参数，因为我们对分布（相对频率）感兴趣，而不是原始计数。

我们可能想探索更多并回答这个问题：对于黑人学生多于其他种族的学校，第二高种族百分比的分布是什么？

在此秘籍中应用相同的方法之前，我们需要删除UGDS_BLACK列。 有趣的是，这些黑人人口较多的学校似乎倾向于拥有较高的西班牙裔人口。

在本章中，我们将介绍以下主题：

数据分析过程中最基本的任务之一是在对每个组执行计算之前将数据分成独立的组。 该方法已经存在了相当长的时间，但是最近被称为拆分应用组合。 本章介绍了功能强大的groupby方法，该方法可让您以可想象的任何方式对数据进行分组，并在返回单个数据集之前将任何类型的函数独立地应用于每个组。

Hadley Wickham 创造了术语“拆分应用组合”，用于描述将数据分为独立的可管理块，将函数独立应用于这些块，然后将结果组合在一起的通用数据分析模式。 可以在他的论文中找到更多详细信息。

在开始使用秘籍之前，我们只需要了解一些术语。 所有基本的分组操作都有分组列，这些列中值的每个唯一组合代表数据的独立分组。 语法如下所示：

该操作的结果返回一个分组对象。 正是这个分组对象将成为驱动整个整章所有计算的引擎。 在通过对象创建此分组时，Pandas 实际上很少执行，仅验证了分组是可能的。 您必须在该分组对象上链接方法，以释放其潜能。

从技术上讲，该操作的结果将是DataFrameGroupBy或SeriesGroupBy，但为简单起见，在整章中将其称为分组对象。

groupby方法最常见的用途是执行聚合。 实际是什么聚合？ 在我们的数据分析世界中，当许多输入的序列被汇总或组合为单个值输出时，就会发生汇总。 例如，对一列的所有值求和或求其最大值是应用于单个数据序列的常见聚合。 聚合仅获取许多值，然后将其转换为单个值。

除了介绍中定义的分组列外，大多数聚合还有两个其他组件，聚合列和聚合函数。 汇总列是其值将被汇总的列。 聚合函数定义聚集的方式。 主要的聚合函数包括sum，min，max，mean，count，variance和std等。

在此秘籍中，我们检查航班数据集，并执行最简单的可能的汇总，仅涉及单个分组列，单个汇总列和单个汇总函数。 我们将找到每家航空公司的平均到达延误时间。 Pandas 具有相当多种不同的语法来产生聚合，本秘籍涵盖了它们。

groupby方法的语法不像其他方法那么简单。 让我们通过将groupby方法的结果存储为自己的变量来拦截步骤 2 中的方法链

首先使用其自己独特的属性和方法来生产一个全新的中间对象。 在此阶段没有任何计算。 Pandas 仅验证分组列。 该分组对象具有agg方法来执行聚合。 使用此方法的一种方法是向其传递一个字典，该字典将聚合列映射到聚合函数，如步骤 2 所示。

有几种不同的语法产生相似的结果，而步骤 3 显示了另一种方法。 与其标识字典中的聚合列，不如将其放在索引运算符中，就如同您从数据帧中将其选择为列一样。 然后，将函数字符串名称作为标量传递给agg方法。

您可以将任何汇总函数传递给agg方法。 为了简单起见，Pandas 允许您使用字符串名称，但是您也可以像在步骤 4 中一样明确地调用一个聚合函数。NumPy 提供了许多聚合值的函数。

步骤 5 显示了最后一种语法风格。 如本例所示，当仅应用单个聚合函数时，通常可以直接将其作为对分组对象本身的方法进行调用，而无需使用agg。 并非所有聚合函数都具有等效的方法，但是许多基本函数都有。 以下是几个聚合函数的列表，这些函数可以作为字符串传递给agg或作为方法直接链接到分组对象：

如果您不对agg使用聚合函数，则 pandas 会引发异常。 例如，让我们看看将平方根函数应用于每个组会发生什么：

可以对多列进行分组和聚合。 语法仅与使用单个列进行分组和聚合时稍有不同。 与任何分组操作一样，它有助于识别三个组成部分：分组列，聚合列和聚合函数。

在本秘籍中，我们通过回答以下查询来展示数据帧的groupby方法的灵活性：

要像步骤 1 一样按多列分组，我们将字符串名称列表传递给groupby方法。AIRLINE和WEEKDAY的每个唯一组合均形成一个独立的组。 在每个组中，找到已取消航班的总数，然后将其作为序列返回。

步骤 2，再次按AIRLINE和WEEKDAY分组，但这一次汇总了两列。 它将两个聚合函数sum和mean中的每一个应用于每个列，从而每组返回四个列。

步骤 3 进一步进行，并使用字典将特定的聚合列映射到不同的聚合函数。 请注意，size聚合函数返回每个组的总行数。 这与count汇总函数不同，后者会返回每组非缺失值的数量。

执行聚合时，会遇到几种主要的语法。 以下四个伪代码块总结了使用groupby方法执行聚合的主要方式：

在前面的四个代码块中，当按单个列进行分组或聚合时，可以用字符串代替任何列表。

不可避免地，当使用groupby时，您可能会在列或行或两者中都创建多重索引。 具有多重索引的数据帧更加难以导航，并且有时列名称也令人困惑。

在本秘籍中，我们使用groupby方法执行聚合，以创建具有行和列多重索引的数据帧，然后对其进行处理，以使索引为单个级别，并且列名具有描述性。

当使用agg方法对多个列执行聚合时，pandas 将创建一个具有两个级别的索引对象。 聚合列变为顶层，聚合函数变为底层。 Pandas 显示的多重索引级别与单级别的列不同。 除了最里面的级别以外，屏幕上不会显示重复的索引值。 您可以检查第 1 步中的数据帧以进行验证。 例如，DIST列仅显示一次，但它引用了前两列。

最里面的多重索引级别是最接近数据的级别。 这将是最底部的列级别和最右边的索引级别。

步骤 2 通过首先使用多重索引方法get_level_values.检索每个级别的基础值来定义新列。此方法接受一个整数，该整数标识索引级别。 它们从顶部/左侧以零开始编号。 索引支持向量化操作，因此我们将两个级别与下划线分开。 我们将这些新值分配给columns属性。

在第 3 步中，我们将两个索引级别都设为reset_index作为列。 我们可以像在第 2 步中那样将级别连接在一起，但是将它们保留为单独的列更有意义。

默认情况下，在分组操作结束时，pandas 将所有分组列放入索引中。 可以将groupby方法中的as_index参数设置为False，以避免此行为。 您可以在分组后将reset_index方法链接起来，以获得与步骤 3 中相同的效果。让我们看一下其中的一个示例，该示例通过查找每个航空公司从每个航班出发的平均距离来得出：

看一下先前结果中航空公司的顺序。 默认情况下，pandas 对分组列进行排序。sort参数存在于groupby方法中，并且默认为True。 您可以将其设置为False，以使分组列的顺序与在数据集中遇到分组列的顺序相同。 通过不对数据进行排序，您还将获得较小的性能提升。

Pandas 提供了许多最常见的聚合函数，供您与分组对象一起使用。 在某些时候，您将需要编写自己的自定义用户定义函数，而这些函数在 pandas 或 NumPy 中不存在。

在此秘籍中，我们使用大学数据集来计算每个州的本科生人数的均值和标准差。 然后，我们使用此信息从每个状态的任何单一总体值的均值中找到最大标准差数。

不存在预定义的 Pandas 函数来计算偏离均值的最大标准差数。 我们被迫在步骤 2 中构造一个自定义函数。请注意，此自定义函数max_deviation接受单个参数s。 展望第 3 步，您会注意到函数名称位于agg方法内，而没有直接调用。 参数s没有明确传递给max_deviation的地方。 相反，Pandas 将UGDS列作为序列隐式传递给max_deviation。

每个组都会调用一次max_deviation函数。 由于s是序列，因此所有常规的序列方法均可用。 在称为标准化的过程中，从组中的每个值中减去该特定组的平均值，然后再除以标准差。

标准化是一种常见的统计过程，用于了解各个值与平均值之间的差异。 对于正态分布，数据的 99.7% 位于平均值的三个标准差之内。

由于我们对均值的绝对偏差感兴趣，因此我们从所有标准化得分中获取绝对值并返回最大值。agg方法必须从我们的自定义函数中返回单个标量值，否则将引发异常。 Pandas 默认使用样本标准差，该样本标准差对于只有单个值的任何组均未定义。 例如，州缩写AS（美属萨摩亚）返回了缺失值，因为它在数据集中只有一个机构。

可以将我们的自定义函数应用于多个聚合列。 我们只需将更多列名称添加到索引运算符。max_deviation函数仅适用于数字列：

您还可以将自定义的聚合函数与预构建函数一起使用。 以下是按国家和宗教派别进行的分组：

请注意，pandas 使用函数名称作为返回列的名称。 您可以使用重命名方法直接更改列名称，也可以修改特殊功能属性__name__：

在编写自己的用户定义的自定义聚合函数时，pandas 隐式地将每个聚合列作为一个序列一次传递给它。 有时，您将需要向函数传递的参数不仅仅是序列本身。 为此，您需要了解 Python 将任意数量的参数传递给函数的能力。 在inspect模块的帮助下，让我们看一下分组对象的agg方法的签名：

参数*args允许您将任意数量的非关键字参数传递给自定义的聚合函数。 同样，**kwargs允许您传递任意数量的关键字参数。

在此秘籍中，我们为大学数据集构建了一个自定义函数，该函数可按州和宗教隶属关系找到本科生人口在两个值之间的学校所占的百分比。

步骤 1 创建一个不接受任何额外参数的函数。 上下限必须硬编码到函数本身中，这不是很灵活。 步骤 2 显示了此聚合的结果。

我们在第 3 步中创建了一个更加灵活的函数，该函数允许用户动态定义上下限。 步骤 4 是*args和**kwargs的魔力发挥作用的地方。 在此特定示例中，我们将两个非关键字参数 1,000 和 10,000 传递给agg方法。 Pandas 分别将这两个参数传递给pct_between的low和high参数。

在步骤 4 中，有几种方法可以达到相同的结果。我们可以在以下命令中明确使用参数名称来产生相同的结果：

关键字参数的顺序并不重要，只要它们位于函数名称之后即可。 更进一步，我们可以混合使用非关键字和关键字参数，只要关键字参数排在最后即可：

为了便于理解，最好按函数签名中定义的顺序包含所有参数名称。

从技术上讲，当调用agg时，所有非关键字参数都收集到名为args的元组中，而所有关键字参数都收集到名为kwargs的字典中。

不幸的是，当同时使用多个聚合函数时，Pandas 没有直接使用这些附加参数的方法。 例如，如果您希望使用pct_between和mean函数进行汇总，则会出现以下异常：

Pandas 无法理解需要将额外的参数传递给pct_between。 为了将我们的自定义函数与其他内置函数甚至其他自定义函数一起使用，我们可以定义一种称为闭包的特殊类型的嵌套函数。 我们可以使用通用闭包来构建所有自定义函数：

make_agg_func函数充当创建自定义聚合函数的工厂。 它接受您已经构建的自定义聚合函数（在这种情况下为pct_between），name参数以及任意数量的额外参数。 它返回一个已经设置了额外参数的函数。 例如，my_agg1是一个特定的定制聚合函数，可以找到大学人口在一千到三千之间的学校所占的百分比。 额外的参数（*args和**kwargs）为您的自定义函数（pct_between）指定了一组精确的参数 ）。name参数非常重要，每次调用make_agg_func时必须唯一。 它将最终用于重命名聚合列。

闭包是一个在其中包含一个函数（一个嵌套函数），并返回此嵌套函数的函数。 此嵌套函数必须引用外部函数范围内的变量才能成为闭包。 在此示例中，make_agg_func是外部函数，并返回嵌套函数wrapper，该函数从外部函数访问变量func，args和kwargs。

在数据帧上使用groupby方法的直接结果将是一个分组对象。 通常，我们将继续对该对象进行操作以进行聚合或转换，而无需将其保存到变量中。 在中，检查此分组对象的主要目的是检查单个组。

在本秘籍中，我们通过直接在其上调用方法以及遍历其每个组来检查分组对象本身。

步骤 1 正式创建了分组对象。 显示所有公共属性和方法以揭示所有可能的函数（如在步骤 2 中所做的那样）很有用。每个组由元组唯一标识，该元组包含分组列中值的唯一组合。 Pandas 允许您使用第 5 步中显示的get_group方法选择特定的组作为数据帧。

很少需要遍历整个组，通常，如果有必要，应避免这样做，因为这样做可能会很慢。 有时候，您别无选择。 当通过对象遍历分组时，将为您提供一个元组，其中包含组名和数据帧，而没有分组列。 在步骤 6 中，此元组在for循环中解包为变量name和group。

在遍历组时可以做的一件有趣的事情是直接在笔记本中显示每个组的几行。 为此，可以使用IPython.display模块中的打印函数或display函数。 使用print函数可得到纯文本格式的数据帧，而没有任何不错的 HTML 格式。 使用display函数将以其常规的易于阅读的格式生成数据帧。

在步骤 2 的列表中没有探索几种有用的方法。例如nth方法，当给定一个整数列表时，该方法从每个组中选择那些特定的行。 例如，以下操作从每个组中选择第一行和最后一行：

在第 4 章，“选择数据子集”中，我们在过滤掉False行之前将每一行标记为True或False。 以类似的方式，可以在过滤掉False组之前将整个数据组标记为True或False。 为此，我们首先使用groupby方法形成组，然后应用filter方法。filter方法接受必须返回True或False来指示是否保留组的函数。

在调用groupby方法之后应用的filter方法，与第 2 章“基本数据帧操作”中的数据帧filter方法完全不同。

在此秘籍中，我们使用大学数据集查找非白人大学生比白人多的所有州。 由于这是来自美国的数据集，因此白人占多数，因此，我们正在寻找少数居多的州。

此秘籍以州为单位查看所有机构的总人口。 目标是保留所有州中总体上占少数的所有行。 这要求我们按状态对数据进行分组，这是在步骤 1 中完成的。我们发现有 59 个独立的组。

filter分组方法将所有行保留在一个组中或将其过滤掉。 它不会更改列数。filter分组方法通过用户定义的函数（例如此秘籍中的check_minority）执行此关守。 要过滤的一个非常重要的方面是它将特定组的整个数据帧传递给用户定义的函数，并为每个组返回一个布尔值。

在check_minority函数内部，首先计算每个机构的非白人学生的百分比和总数，然后找到所有学生的总数。 最后，根据给定的阈值检查整个州的非白人学生百分比，这会产生布尔值。

最终结果是一个数据帧，其列与原始列相同，但过滤掉了不符合阈值的状态中的行。 由于过滤后的数据帧的标题可能与原始标题相同，因此您需要进行一些检查以确保操作成功完成。 我们通过检查行数和唯一状态数来验证这一点。

我们的函数check_minority是灵活的，并接受参数以降低或提高少数群体阈值的百分比。 让我们检查几个其他阈值的唯一状态的形状和数量：

增加减肥动机的一种方法是与他人打赌。 此秘籍中的方案将跟踪四个月内两个人的减肥情况，并确定获胜者。

在此秘籍中，我们使用来自两个人的模拟数据来跟踪四个月内减肥的百分比。 在每个月底，将根据当月体重百分比最高的个人宣布获胜者。 要跟踪减肥，我们将数据按月和人分组，然后调用transform方法以查找从月初起每周每周的减肥百分比。

您应该忽略最后一个输出中的索引值。 0、2、4 和 6 只是引用数据帧的原始行标签，与星期无关。

在整个秘籍中，query方法用于过滤数据，而不是布尔索引。 有关更多信息，请参阅第 5 章，“布尔索引”的“查询方法”秘籍，以提高布尔索引的可读性。

我们的目标是找到每个人每个月的减肥百分比。 一种完成此任务的方法是计算相对于每个月初的每周减肥。 此特定任务非常适合transform分组方法。transform方法接受一个函数作为其必需的参数。 该函数隐式地传递给每个非分组列（或仅使用在索引运算符中指定的列，如在此秘籍中使用Weight所做的那样）。 它必须返回与传递的组长度相同的值序列，否则将引发异常。 本质上，原始数据帧中的所有值都在转换。 没有聚集或过滤发生。

第 2 步创建一个函数，该函数从其所有值中减去传递的序列的第一个值，然后将该结果除以第一个值。 这将计算相对于第一个值的百分比损失（或收益）。 在第 3 步中，我们在一个月内对一个人测试了此函数。

在步骤 4 中，我们在人和周的每个组合上以相同的方式使用此函数。 从字面上看，我们正在将Weight列转换为当前一周的体重损失百分比。 为每个人输出第一个月的数据。 Pandas 将新数据作为序列返回。 该序列本身并没有什么用处，并且更有意义地作为新列附加到原始数据帧中。 我们在步骤 5 中完成此操作。

要确定获胜者，只需每月的第 4 周。 我们可以在这里停下来，手动确定获胜者，但 Pandas 提供了自动执行此功能的函数。 第 7 步中的pivot函数通过将一列的唯一值转换为新的列名称来重塑我们的数据集。index参数用于您不想旋转的列。 传递给values参数的列将平铺在index和columns参数中列的每个唯一组合上。

只有在index和columns参数中的列的每种唯一组合仅出现一次时，pivot方法才有效。 如果唯一的组合不止一个，则会引发异常。 在这种情况下，您可以使用pivot_table方法，该方法允许您将多个值聚合在一起。

枢纽化之后，我们利用高效且快速的 NumPy where函数，该函数的第一个参数是产生布尔序列的条件。True值映射到Amy，False值映射到Bob。我们突出显示每个月的获胜者，并使用value_counts方法统计最终得分。

看一下第 7 步中的数据帧输出。您是否注意到月份是按字母顺序而不是按时间顺序排列的？ 不幸的是，至少在这种情况下，Pandas 按字母顺序为我们排序了几个月。 我们可以通过将Month的数据类型更改为分类变量来解决此问题。 分类变量将每列的所有值映射为一个整数。 我们可以选择此映射为月份的正常时间顺序。 Pandas 在pivot方法期间使用此基础整数映射按时间顺序排列月份：

要转换Month列，请使用Categorical构造器。 将原始列作为序列传递，并将所有类别的唯一序列按所需顺序传递给categories参数。 由于Month列已经按时间顺序排列，因此我们可以简单地使用unique方法，该方法保留了获取所需数组的顺序。 通常，要按字母顺序以外的其他方式对对象数据类型的列进行排序，请将其转换为类别。

分组对象具有四个接受一个或多个函数以对每个组执行计算的方法。 这四种方法是agg，filter，transform和apply。 这些方法的前三个方法中的每个方法都有一个非常特定的输出，函数必须返回该输出。agg必须返回标量值，filter必须返回布尔值，transform必须返回与传递的组长度相同的序列。 但是，apply方法可能返回标量值，序列或什至任何形状的数据帧，因此使其非常灵活。 每个组也仅将其称为 ，这与对每个非分组列调用一次的transform和agg形成对比。apply方法能够同时对多个列进行操作时返回单个对象的能力，使得此秘籍中的计算成为可能。

在此秘籍中，我们从大学数据集中计算每个州的数学和口头 SAT 分数的加权平均值。 我们根据每个学校的本科生人数对分数进行加权。

为了正确完成此秘籍，我们需要首先过滤没有UGDS，SATMTMID和SATVRMID值缺失的机构。 默认情况下，dropna方法删除具有一个或多个缺失值的行。 我们必须使用subset参数来限制其查找缺少值的列。

在第 2 步中，我们定义一个仅计算SATMTMID列的加权平均值的函数。 加权平均值与算术平均值的不同之处在于，每个值都乘以一定的权重。 然后将这个数量相加并除以权重之和。 在这种情况下，我们的体重就是在校学生人数。

在第 3 步中，我们将此函数传递给apply方法。 我们的函数weighted_math_average传递了每个组所有原始列的数据帧。 它返回单个标量值，即SATMTMID的加权平均值。 此时，您可能认为可以使用agg方法进行此计算。 用agg直接替换apply不起作用，因为agg返回其每个聚合列的值。

实际上，可以通过预先计算UGDS和SATMTMID的乘法来间接使用agg。

步骤 6 确实显示了apply的多功能性。 我们构建了一个新函数，该函数计算两个 SAT 列的加权平均值和算术平均值以及每个组的行数。 为了使apply创建多个列，您必须返回一个序列。 索引值用作结果数据帧中的列名。 您可以使用此方法返回任意多个值。

请注意，OrderedDict类是从collections模块导入的，该模块是标准库的一部分。 该有序字典用于存储数据。 普通的 Python 字典不能用来存储数据，因为它不保留插入顺序。

构造器pd.Series确实具有一个索引参数，您可以使用它来指定顺序，但是使用OrderedDict会更干净。

在此秘籍中，我们为每个组返回一行作为序列。 通过返回数据帧，可以为每个组返回任意数量的行和列。 除了查找算术和加权均值之外，我们还查找两个 SAT 列的几何和谐波均值，然后将结果作为数据帧返回，其中数据行是均值类型的名称，列是 SAT 类型。 为了减轻我们的负担，我们使用 NumPy 函数average来计算加权平均值，并使用 SciPy 函数gmean和hmean来计算几何和调和平均值：

在对 Pandas 进行分组时，通常使用具有离散重复值的列。 如果没有重复的值，则分组将毫无意义，因为每个组只有一行。 连续数字列通常具有很少的重复值，并且通常不用于形成组。 但是，如果我们可以将具有连续值的列转换为离散列，方法是将每个值放入一个桶中，四舍五入或使用其他映射，则将它们分组是有意义的。

在此秘籍中，我们探索航班数据集以发现不同旅行距离的航空公司分布。 例如，这使我们能够找到在 500 到 1,000 英里之间飞行最多的航空公司。 为此，我们使用 Pandascut函数离散化每次飞行的距离。

在步骤 2 中，cut函数将DIST列的每个值放入五个仓位之一。 箱由定义边缘的六个数字序列创建。 您总是需要比容器数多一个边缘。 您可以为bins参数传递一个整数，该整数将自动创建该数目的等宽槽。 NumPy 中提供了负无穷大对象和正无穷大对象，并确保将所有值放置在桶中。 如果您的值在箱边缘之外，则将使它们丢失并且不会放置在箱中。

cuts变量现在是五个有序类别的序列。 它具有所有常规的序列方法，在步骤 3 中，使用value_counts方法来了解其分布。

非常有趣的是，pandas 允许您将groupby方法传递给任何对象。 这意味着您可以从与当前数据帧完全无关的内容中形成组。 在这里，我们将cuts变量中的值分组。 对于每个分组，我们通过将normalize设置为True，以value_counts查找每个航空公司的航班百分比。

从这个结果可以得出一些有趣的见解。 从全部结果来看，SkyWest 是领先的航空公司，飞行距离不到 200 英里，但没有超过 2,000 英里的航班。 相比之下，美国航空公司在 200 英里以下的航班中排名第五，但到目前为止，在 1,000 到 2,000 英里之间的航班最多。

当按cuts变量分组时，我们可以找到更多结果。 例如，我们可以为每个距离分组找到第 25、50 和 75% 的通话时间。 由于通话时间以分钟为单位，因此我们可以除以 60 得到小时：

当使用cut函数时，我们可以使用此信息来创建内容丰富的字符串标签。 这些标签代替了间隔符号。 我们还可以链接unstack方法，该方法将内部索引级别转换为列名称：

在航班数据集中，我们具有始发地和目的地机场的数据。 例如，计算从休斯敦出发并降落在亚特兰大的航班数量是微不足道的。 更困难的是计算两个城市之间的航班总数，而不管始发地或目的地是哪一个。

在此秘籍中，我们计算两个城市之间的航班总数，而不管始发地或目的地是哪个。 为此，我们按字母顺序对始发和目的地机场进行排序，以使机场的每种组合始终以相同的顺序出现。 然后，我们可以使用这种新的列安排来形成组，然后进行计数。

在第 1 步中，我们按起点和目的地机场列形成分组，然后将size方法应用于分组对象，该对象仅返回每个组的总行数。 请注意，我们可以将字符串size传递给agg方法以获得相同的结果。 在步骤 2 中，选择了亚特兰大和休斯顿之间每个方向的航班总数。 序列flights_count具有两个级别的多重索引。 从多重索引中选择行的一种方法是将loc索引运算符传递给精确级别值的元组。 在这里，我们实际上选择了两个不同的行('ATL', 'HOU')和('HOU', 'ATL')。 我们使用元组列表来正确执行此操作。

步骤 3 是秘籍中最相关的步骤。 对于亚特兰大和休斯顿之间的所有航班，我们只希望有一个标签，到目前为止，我们有两个标签。 如果我们按字母顺序对出发地和目的地机场的每种组合进行排序，那么我们将为机场之间的航班使用一个标签。 为此，我们使用数据帧的apply方法。 这与分组的apply方法不同。 在步骤 3 中没有形成组。

必须向数据帧的apply方法传递一个函数。 在这种情况下，它是内置的sorted函数。 默认情况下，此函数作为序列应用于每个列。 我们可以使用axis=1（或axis='index'）来改变计算方向。sorted函数将每行数据隐式地作为序列传递给它。 它返回已排序的机场代码的列表。 这是将第一行作为序列传递给排序函数的示例：

apply方法以这种确切的方式使用sorted遍历所有行。 完成此操作后，将对每一行进行独立排序。 列名现在已无意义。 我们在下一步中对列名称进行重命名，然后执行与步骤 2 中相同的分组和汇总。这次，亚特兰大和休斯顿之间的所有航班都属于同一标签。

您可能想知道为什么我们不能使用更简单的sort_values序列方法。 此方法不是独立进行排序，而是将行或列保留为单个记录，就像在进行数据分析时所期望的那样。 步骤 3 是非常昂贵的操作，需要几秒钟才能完成。 只有大约 60,000 行，因此该解决方案无法很好地扩展到更大的数据。

步骤 3 是非常昂贵的操作，需要几秒钟才能完成。 只有大约 60,000 行，因此该解决方案无法很好地扩展到更大的数据。 在所有 Pandas 中，用axis=1调用apply方法是性能最低的操作之一。 在内部，Pandas 在每行上循环，不会因 NumPy 提供任何速度提升。 如果可能，请避免将apply与axis=1一起使用。

使用 NumPy sort函数可以大大提高速度。 让我们继续使用此函数并分析其输出。 默认情况下，它将对每一行进行独立排序：

返回二维 NumPy 数组。 NumPy 并不容易进行分组操作，因此让我们使用数据帧构造器创建一个新的数据帧并检查它是否等于步骤 3 中的flights_sorted数据帧：

由于数据帧相同，因此您可以将第 3 步替换为先前的更快排序例程。 我们来计时一下每种不同的排序方法之间的区别：

NumPy 解决方案的速度比对 Pandas 使用apply快 700 倍。

对于航空公司而言，最重要的指标之一是其准时飞行表现。 美国联邦航空管理局认为，航班在比原定抵达时间至少晚 15 分钟后才抵达。 Pandas 有直接的方法来计算每个航空公司的准时航班总数和百分比。 尽管这些基本摘要统计数据是一个重要的指标，但是还有其他一些重要的计算很有趣，例如，找出每个航空公司在其始发机场的连续准点飞行时间。

在此秘籍中，我们找到了每个始发机场的每家航空公司的最长连续航班准点率。 这要求列中的每个值都必须知道紧随其后的值。 为了将条纹应用到每个组之前，我们巧妙地使用了diff和cumsum方法来发现条纹。

在 Pandas 中查找数据中的条纹并不是一项简单的操作，需要先行或后行的方法，例如diff或shift，或记住当前状态的方法，例如cumsum。 前七个步骤的最终结果是序列的长度与原始序列的长度相同，可以跟踪所有连续的序列。 在这些步骤中，我们使用mul和add方法代替它们的等效运算符（*）和（+）。 我认为，这样可以使计算从左到右的过程更加简洁。 您当然可以将它们替换为实际的运算符。

理想情况下，我们希望告诉 Pandas 在每个条纹开始时都应用cumsum方法，并在每个条纹结束后重新设置自身。 要将此信息传达给 Pandas，需要采取许多步骤。 第 2 步将整个序列中的所有结果累积起来。 其余步骤将慢慢清除所有多余的累积。 为了识别这种多余的累积，我们需要找到每个条纹的末尾并从下一个条纹的开始减去该值。

要找到每个条纹的结尾，请通过在步骤 3 中将s1乘以原始零序列和 1 来巧妙地使所有值不属于条纹零。 条纹。 很好，但是同样，我们需要消除多余的累积。 知道条纹结束的地方并不能使我们到达那里。

在第 4 步中，我们使用diff方法来查找此多余部分。diff方法获取当前值与位于距离其一定行数的任何值之间的差。 默认情况下，返回当前值与前一个值之间的差。

在步骤 4 中，只有负值才有意义。那些是连续结束后的值。 这些值需要向下传播，直到后续条纹结束。 为了消除（丢失）所有我们不关心的值，我们使用where方法，该方法采用与调用序列大小相同的条件序列。 默认情况下，所有True值保持不变，而False值丢失。where方法允许您通过将函数作为第一个参数来将调用序列用作条件的一部分。 使用一个匿名函数，该函数隐式传递给调用序列，并检查每个值是否小于零。 第 5 步的结果是一个序列，其中仅保留负值，其余更改为缺失值。

步骤 6 中的ffill方法将缺失值替换为在序列中前进/后退的最后一个非缺失值。 由于前三个值不跟随非缺失值，因此它们仍然丢失。 我们终于有了消除多余积蓄的序列。 我们将累加序列添加到步骤 6 的结果中，以使条纹全部从零开始。add方法允许我们用fill_value参数替换缺少的值。 这样就完成了在数据集中查找条纹的过程。 当执行这样的复杂逻辑时，最好使用一个小的数据集，在此您可以知道最终的输出是什么。 从第 8 步开始并在分组时建立这种寻路逻辑将是非常困难的任务。

在步骤 8 中，我们创建ON_TIME列。 值得注意的一项是，已取消的排期缺少ARR_DELAY的值，该值未通过布尔条件，因此ON_TIME列的值为零。 取消的航班与延迟的航班一样。

第 9 步将我们的逻辑从前七个步骤转变为一个函数，并链接max方法以返回最长的条纹。 由于我们的函数返回单个值，因此它正式是一个聚合函数，可以按照步骤 10 的操作传递给agg方法。为确保我们正在查看实际的连续航班，我们使用sort_values方法按日期和预定的出发时间进行排序。

既然我们找到了准点到达时间最长的条纹，我们可以轻松地找到相反的地方-延迟到达的最长条纹。 以下函数为传递给它的每个组返回两行。 第一行是条纹的起点，最后一行是条纹的终点。 每行包含开始/结束条纹的月份和日期，以及条纹的总长度：

当我们使用分组的apply方法时，每个组的数据帧都传递给max_delay_streak函数。 在此函数内部，删除了数据帧的索引并用RangeIndex代替，以便我们轻松找到条纹的第一行和最后一行。 反转ON_TIME列，然后使用相同的逻辑查找延迟飞行的条纹。 条纹的第一行和最后一行的索引存储为变量。 然后，这些索引用于选择条纹结束的月份和日期。 我们使用数据帧返回结果。 我们标记并命名索引以使最终结果更清晰。

我们的最终结果显示了最长的延迟条纹以及第一和最后一个日期。 让我们进行调查，看看是否可以找出导致这些延迟的原因。 天气恶劣是航班延误或取消的常见原因。 从第一行开始，美国航空（AA）从达拉斯沃思堡（DFW）机场开始拥有连续 38 班延误航班，从 2015 年 2 月 26 日至 2015 年 3 月 1 日。查看 2015 年 2 月 27 日的历史天气数据 ，降雪量为 2 英寸，这是当天的记录。 这是 DFW 的主要天气事件，并给整个城市造成了严重问题。 请注意，DFW 出现了第三次最长的连胜纪录，但这次是几天前，并且是另一家航空公司。

在本章中，我们将介绍以下主题：

前几章中使用的所有数据集都没有做太多或做任何工作来更改其结构。 我们立即开始以原始形状处理数据集。 在开始更详细的分析之前，许多野外的数据集将需要大量的重组。 在某些情况下，整个项目可能只关心格式化数据，以便其他人可以轻松处理它。

有许多术语用于描述数据重组的过程，其中整齐的数据是数据科学家最常用的。 整洁的数据是 Hadley Wickham 创造的一个术语，用于描述使分析变得容易进行的数据形式。 本章将涵盖 Hadley 提出的许多想法以及如何用 Pandas 来实现它们。 要了解有关整理数据的更多信息，请阅读 Hadley 的论文。

什么是整洁的数据？ Hadley 提出了三个简单的指导原则来确定数据集是否整洁：

任何不符合这些准则的数据集都被认为是混乱的。 一旦开始将数据重组为整齐的格式，此定义将变得更有意义，但是现在，我们需要知道什么是变量，观测值和观测单位。

要获得关于变量实际含义的直觉，最好考虑一下变量名称和变量值之间的区别。 变量名称是标签，例如性别，种族，薪水和职位。 变量值是指每次观察都可能发生变化的事物，例如性别中的男性/女性或种族中的白色/黑色。 单个观测值是单个观测单位的所有变量值的集合。 为了帮助了解观察单位可能是什么，请考虑零售商店，该商店具有有关每个交易，员工，客户，物品和商店本身的数据。 这些中的每一个都可以视为观察单位，并且需要自己的表格。 将员工信息（例如，工作时间）与客户信息（例如，花费的金额）组合在同一张表中，将破坏这一整洁的原则。

解决杂乱数据的第一步是在存在杂乱数据时对其进行识别，并且存在无限可能。 Hadley 明确提到了五种最常见的混乱数据类型：

重要的是要了解，整理数据通常不涉及更改数据集的值，填写缺失的值或进行任何类型的分析。 整理数据涉及更改数据的形状或结构以符合整理原则。 整洁的数据类似于将所有工具都放在工具箱中，而不是随机散布在整个房屋中。 在工具箱中正确放置工具可以轻松完成所有其他任务。 数据格式正确后，进行进一步分析变得容易得多。

一旦发现混乱的数据，您将使用 Pandas 工具来重组数据，使数据整洁。 Pandas 提供给您的主要整洁工具是数据帧方法stack，melt，unstack和pivot。 较复杂的整理工作涉及撕裂文本，这需要str访问器。 其他辅助方法，例如rename，rename_axis，reset_index和set_index，将有助于对整洁的数据进行最终处理。

为了帮助理解整洁数据和混乱数据之间的差异，让我们看一下一个简单的表格，该表格可能是也可能不是整齐的：

该表似乎没有任何混乱，并且该信息很容易消耗。 但是，按照整洁的原则，它实际上并不是整洁的。 每个列名称实际上是变量的值。 实际上，数据帧中甚至都没有变量名。 将凌乱的数据集转换为整洁的数据的第一步之一就是识别所有变量。 在此特定数据集中，我们具有州和水果的变量。 在问题的背景下，还没有找到任何数字数据。 我们可以将此变量标记为权重或其他任何明智的名称。

这个特定的混乱数据集包含变量值作为列名。 我们将需要将这些列名称转换为列值。 在本秘籍中，我们使用stack方法将数据帧重组为整齐的形式。

stack方法功能强大，需要花费一些时间才能完全理解和欣赏。 它接受所有列名并转置它们，因此它们成为新的最里面的索引级别。 请注意，每个旧列名称仍如何通过与每个状态配对来标记其原始值。3 x 3数据帧中有 9 个原始值，这些值被转换为具有相同数量值的单个序列。 原始的第一行数据成为结果序列中的前三个值。

在步骤 2 中重置索引后，pandas 将我们的数据帧的列默认设置为level_0，level_1和0。 这是因为调用此方法的序列具有两个未正式命名的索引级别。 Pandas 还从外部从零开始按整数引用索引。

步骤 3 显示了一种重命名列的简单直观的方法。 您可以通过将columns属性设置为等于列表来简单地为整个数据帧设置新列。

或者，可以通过链接rename_axis方法在一个步骤中设置列名称，该方法在将列表作为第一个参数传递时，将这些值用作索引级别名称。 重置索引时，Pandas 使用这些索引级别名称作为新的列名称。 此外，reset_index方法具有一个name参数，该参数对应于序列值的新列名称。

所有序列都有一个name属性，可以直接设置或使用rename方法设置。 当使用reset_index时，这个属性成为列名。

使用stack的关键之一是将所有不希望转换的列都放在索引中。 最初使用索引中的状态读取此秘籍中的数据集。 让我们看一下如果不将状态读入索引，将会发生什么：

由于状态名称不在索引中，因此在此数据帧上使用stack可将所有值整形为一个长值序列：

这个命令将重塑所有列，这次包括状态，而这根本不是我们所需要的。 为了正确地重塑此数据，您需要首先使用set_index方法将所有未重塑的列放入索引中，然后使用stack。 下面的代码与步骤 1 产生相似的结果：

像大多数大型 Python 库一样，Pandas 也有许多不同的方式来完成同一任务-区别通常是可读性和性能。 Pandas 包含一个名为melt的数据帧方法，该的工作原理与先前秘籍中介绍的stack方法相似，但灵活性更高。

在 Pandas 版本 0.20 之前，melt仅作为必须通过pd.melt访问的函数提供。 Pandas 仍然是一个不断发展的库，您需要期待每个新版本的变化。 Pandas 一直在推动将只能在数据帧上运行的所有函数移至方法上，例如它们对melt所做的一样。 这是使用melt的首选方法，也是本秘籍使用它的方式。 查看 Pandas 文档的“新增功能”部分，以了解所有更改的最新信息。

在本秘籍中，我们使用melt方法来整理一个简单的数据帧，以变量值作为列名。

melt方法功能强大，可以显着重塑您的数据帧。 它最多包含五个参数，其中两个参数对于理解如何正确重塑数据至关重要：

id_vars或标识变量保留在同一列中，但对于传递给value_vars的每列重复一次。melt的一个关键方面是它忽略索引中的值，实际上，它默默地删除了您的索引并用默认的RangeIndex代替了它。 这意味着，如果您确实希望保留索引中的值，那么在使用melt之前，需要先重置索引。

将水平列名称转换为垂直列值的某些通用术语是“融化”，“解除堆叠”或“取消旋转”。

melt方法的所有参数都是可选的，并且如果您希望所有值都位于单个列中，而它们的旧列标签位于另一个列中，则可以使用其默认值调用melt：

实际上，您可能有很多需要融合的变量，并且只想指定标识变量。 在这种情况下，以以下方式调用melt会产生与步骤 2 相同的结果。在融化单个列时，实际上甚至不需要列表，只需传递其字符串值即可：

一些数据集包含多组变量作为列名，需要同时堆叠到自己的列中。 以movie数据集为例可以帮助阐明这一点。 首先，选择包含演员姓名及其对应的 Facebook 点赞的所有列：

如果我们将变量定义为电影的标题，演员名称和 Facebook 点赞数，那么我们将需要独立地堆叠两组列，而仅通过一次调用stack或melt。

在本秘籍中，我们将通过同时堆叠演员名称及其与wide_to_long函数相对应的 Facebook 点赞来整理actor数据帧。

wide_to_long函数以相当特定的方式工作。 它的主要参数是stubnames，它是一个字符串列表。 每个字符串代表一个列分组。 以该字符串开头的所有列都将被堆叠到一个列中。 在此秘籍中，有两列列：actor和actor_facebook_likes。 默认情况下，这些列的每个组都需要以数字结尾。 此数字随后将用于标记整形数据。 每个列组都有一个下划线字符，将stubname与结尾数字分开。 为此，必须使用sep参数。

原始列名称与wide_to_long工作所需的模式不匹配。 可以通过使用列表精确指定列名称来手动更改列名称。 这很快就会成为很多类型的输入，因此，我们定义了一个函数，该函数自动将我们的列转换为有效的格式。change_col_name函数从参与者列中删除_name，并重新排列facebook列，以便现在它们都以数字结尾。

要实际完成列重命名，我们在步骤 2 中使用rename方法。它接受许多不同类型的参数，其中之一是函数。 将其传递给函数时，每个列名都会一次隐式传递给它。

现在，我们已经正确地创建了两个独立的列组，即以actor和actor_facebook_likes开头的列，它们将被堆叠。 除此之外，wide_to_long还需要一个唯一列，即参数i，用作不会堆叠的标识变量。 还需要参数j，该参数仅重命名从原始列名的末尾去除的标识数字。 默认情况下，prefix参数包含搜索一个或多个数字的正则表达式，\d+。\d是与数字 0-9 匹配的特殊令牌。 加号+使表达式与这些数字中的一个或多个匹配。

要成为str方法的强大用户，您将需要熟悉正则表达式，这是与某些文本中的特定模式匹配的字符序列。 它们由具有特殊含义的“元字符”和“字面值”字符组成。 要使自己对正则表达式有用，请查看 Regular-Expressions.info 中的简短教程。

当所有变量分组具有相同的数字结尾（如此秘籍中的数字）时，函数wide_to_long起作用。 当您的变量没有相同的结尾或不是以数字结尾时，您仍然可以使用wide_to_long同时进行列堆叠。 例如，让我们看一下以下数据集：

假设我们希望将a1和b1列以及d和e列堆叠在一起。 另外，我们想使用a1和b1作为行的标签。 要完成此任务，我们需要重命名列，以便它们以所需的标签结尾：

然后，我们需要修改后缀参数，该参数通常默认为选择数字的正则表达式。 在这里，我们只是简单地告诉它找到任意数量的字符：

数据帧具有两种相似的方法stack和melt，用于将水平列名称转换为垂直列值。数据帧分别具有分别通过unstack和pivot方法直接反转这两个操作的能力。stack/unstack是更简单的方法，仅允许控制列/行索引，而melt/pivot提供更大的灵活性来选择要重塑的列。

在此秘籍中，我们将stack/melt一个数据集，并立即将unstack/pivot的操作转换回其原始形式。

在步骤 1 中，有多种方法可以完成相同的任务。在这里，我们展示read_csv函数的多功能性。usecols参数接受我们要导入的列的列表或动态确定它们的函数。 我们使用匿名函数来检查列名是否包含UGDS_或等于INSTNM。 该函数以字符串的形式传递给每个列名，并且必须返回一个布尔值。 通过这种方式可以节省大量的内存。

步骤 2 中的stack方法将所有列名称放入最里面的索引级别，并返回一个序列。 在步骤 3 中，unstack方法通过获取最里面的索引级别中的所有值将它们转换为列名来反转此操作。

步骤 3 的结果与步骤 1 不太完全相同。 整行都缺少值，默认情况下，stack方法在步骤 2 中将其删除。 为了保留这些丢失的值并创建精确的副本，请在stack方法中使用dropna=False。

步骤 4 读取与步骤 1 相同的数据集，但没有将机构名称放入索引中，因为melt方法无法访问它。 步骤 5 使用melt方法转置所有Race列。 它通过将value_vars参数保留为其默认值None来执行此操作。 如果未指定，则id_vars参数中不存在的所有列都将转置。

步骤 6 用pivot方法反转了步骤 5 的操作，该方法接受三个参数。 每个参数都将一列作为字符串。index参数引用的列保持垂直并成为新索引。columns参数引用的列的值成为列名。values参数引用的值将平铺以对应于其先前索引和列标签的交集。

要使用pivot进行精确复制，我们需要按照与原始顺序完全相同的顺序对行和列进行排序。 由于机构名称在索引中，因此我们使用.loc索引运算符作为通过其原始索引对数据帧进行排序的方式。

为了帮助进一步理解stack/unstack，让我们将它们用于转置college数据帧。

在这种情况下，我们使用矩阵转置的精确数学定义，其中新行是原始数据矩阵的旧列。

如果您看一下步骤 2 的输出，您会注意到有两个索引级别。 默认情况下，unstack方法使用最里面的索引级别作为新的列值。 索引级别从外部从零开始编号。 Pandas 默认将unstack方法的level参数设置为-1，这是指最里面的索引。 我们可以使用level=0代替unstack最外面的列：

实际上，有一种非常简单的方法可以通过使用transpose方法或T属性来转置不需要stack或unstack的数据帧：

按单个列对数据进行分组并在单个列上执行聚合将返回简单易用的结果，并且易于使用。 当按多个列进行分组时，可能不会以使消耗变得容易的方式来构造结果聚合。 由于默认情况下groupby操作将唯一的分组列放在索引中，因此unstack方法对于重新排列数据非常有用，以便以对解释更有用的方式显示数据。

在此秘籍中，我们使用employee数据集执行聚合，并按多列分组。 然后，我们使用unstack方法将结果重塑为一种格式，以便于比较不同组。

第 1 步使用单个分组列（RACE），单个聚合列（BASE_SALARY）和单个聚合函数（mean）进行最简单的聚合。 此结果易于使用，不需要任何其他处理即可求值。 第 2 步通过将种族和性别分组在一起，稍微增加了复杂性。 生成的多重索引序列在一个维中包含所有值，这使得比较更加困难。 为了使信息更易于使用，我们使用unstack方法将一个（或多个）级别中的值转换为列。

默认情况下，unstack使用最里面的索引级别作为新列。 您可以使用level参数指定要取消堆叠的确切级别，该参数接受级别名称作为字符串或级别整数位置。 最好在整数位置上使用级别名称，以避免产生歧义。 第 3 步和第 4 步将每个级别拆栈，这将导致数据帧具有单级索引。 现在，按性别比较每个种族的薪水要容易得多。

如果有多个分组和聚合列，则直接结果将是数据帧而不是序列。 例如，让我们计算除平均值以外的更多聚合，如步骤 2 所示：

堆叠GENDER列将产生多重索引列。 从这里开始，您可以继续使用unstack和stack方法交换行和列级别，直到获得所需的数据结构为止：

乍一看，pivot_table方法似乎提供了一种独特的数据分析方法。 但是，在进行少量按摩之后，可以使用groupby聚合完全复制其功能。 知道这种等效性可以帮助缩小 Pandas 功能的范围。

在此秘籍中，我们使用flights数据集创建数据透视表，然后使用groupby操作重新创建它。

pivot_table方法非常通用且灵活，但是执行与groupby聚合相当相似的操作，其中步骤 1 显示了一个简单示例。index参数采用一列（或多列），该列将不会被透视，并且其唯一值将放置在索引中。columns参数采用一列（或多列），该列将被透视，并且其唯一值将作为列名称。values参数采用将汇总的一列（或多列）。

还存在一个aggfunc参数，该参数带有一个或多个聚合函数，这些函数确定values参数中的列如何聚合。 它默认为均值，在此示例中，我们将其更改为计算总和。 此外，AIRLINE和ORG_AIR的某些唯一组合不存在。 这些缺失的组合将默认为结果数据帧中的缺失值。 在这里，我们使用fill_value参数将其更改为零。

步骤 2 使用index和columns参数中的所有列作为分组列开始复制过程。 这是使此秘籍生效的关键。 数据透视表只是分组列的所有唯一组合的交集。 步骤 3 通过使用unstack方法将最里面的索引级别转换为列名来完成复制。 就像pivot_table一样，并非AIRLINE和ORG_AIR的所有组合都存在。 我们再次使用fill_value参数将这些缺失的交集强制为零。

可以使用groupby聚合复制更复杂的数据透视表。 例如，从pivot_table中获得以下结果：

要使用groupby聚合复制此代码，只需遵循秘籍中的相同模式，并将index和columns参数中的所有列放入groupby方法中，然后将unstack列中：

有一些区别。 当像agg分组方法那样作为列表传递时，pivot_table方法不接受聚合函数作为字符串。 相反，您必须使用 NumPy 函数。 列级别的顺序也有所不同，其中pivot_table将聚合函数置于values参数中列之前的级别。 这与swaplevel方法相等，在这种情况下，该方法将切换前两个级别的顺序。

截至撰写本书时，将多个列堆叠在一起时存在一个错误，即忽略fill_value参数。 要解决此错误，请将.fillna（0）链接到代码末尾。

当每个轴（索引/列）级别具有名称时，使用stack/unstack方法进行重塑要容易得多。 Pandas 允许用户按整数位置或名称引用每个轴级别。 由于整数位置是隐式的而不是显式的，因此应尽可能考虑使用级别名称。 此建议来自“Python 之禅”，这是 Python 的指导原则的简短列表，一个是“显式优于隐式”。

当用多列进行分组或聚合时，所得的 Pandas 对象将在一个或两个轴上具有多个级别。 在本秘籍中，我们将命名每个轴的每个级别，然后使用stack/unstack方法将数据显着重塑为所需的形式。

groupby聚合的结果通常会产生具有多个轴级别的数据帧或序列。 步骤 1 中groupby操作的结果数据帧每个轴具有多个级别。 列级别未命名，这将要求我们仅按其整数位置引用它们。 为了大大简化我们引用列级别的能力，我们使用rename_axis方法对其进行了重命名。

rename_axis方法有点奇怪，因为它可以根据传递给它的第一个参数的类型来修改级别名称和级别值。 向其传递一个列表（如果只有一个级别，则为标量）会更改级别的名称。 向其传递字典或函数会更改级别的值。 在第 2 步中，我们向rename_axis方法传递一个列表，并返回一个具有所有轴级别命名的数据帧。

一旦所有轴级别都有名称，我们就可以轻松明确地控制数据的结构。 步骤 3 将AGG_FUNCS列堆叠到最里面的索引级别。 步骤 4 中的swaplevel方法接受要交换的级别的名称或位置作为前两个参数。sort_index方法被调用两次，并对每个级别的实际值进行排序。 请注意，列级别的值是列名SATMTMID和UGDS。

通过步骤 6 进行堆叠和拆栈，我们可以得到截然不同的输出。也可以将每个单独的列级别堆叠到索引中以产生一个序列。

如果您希望完全丢弃电平值，可以将它们设置为None。 当需要减少数据帧的可视输出中的混乱情况，或者很明显列级别代表什么并且不进行进一步处理时，可以采取这种措施：

每当列名称本身包含多个不同的变量时，就会出现一种特殊的混乱数据。 当年龄和性别连接在一起时，便会出现这种情况的常见示例。 要整理这样的数据集，我们必须使用 pandas str访问器来操作列，该访问器包含用于字符串处理的其他方法。

在本秘籍中，我们将首先确定所有变量，其中一些变量将被连接在一起作为列名。 然后，我们对数据进行整形并解析文本以提取正确的变量值。

weightlifting数据集与许多数据集一样，具有原始格式的易于消化的信息，但是从技术上讲，它很混乱，因为除一个列名之外，所有其他列都包含性别和年龄信息。 一旦确定了变量，就可以开始整理数据集。 只要列名称包含变量，就需要使用melt（或stack）方法。Weight Category变量已经在正确的位置，因此我们通过将其传递给id_vars参数来将其保留为标识变量。 请注意，我们不需要明确地命名要与value_vars融合的所有列。 默认情况下，id_vars中不存在的所有列都会融化。

sex_age列需要解析，并分为两个变量。 为此，我们转向str访问器提供的额外函数，该函数仅适用于序列（单个数据帧的列）。 在这种情况下，split方法是较常见的方法之一，因为它可以将字符串的不同部分分成各自的列。 默认情况下，它在空白处分割，但是您也可以使用pat参数指定字符串或正则表达式。 当expand参数设置为True时，将为每个独立的分割字符段形成一个新列。 当False时，返回单个列，其中包含所有段的列表。

在第 4 步中重命名列之后，我们需要再次使用str访问器。 有趣的是，索引运算符可用于选择或分割字符串段。 在这里，我们选择第一个字符，这是性别变量。 我们可以更进一步，将年龄分为最小年龄和最大年龄两个单独的列，但是通常以这种方式指代整个年龄组，因此我们将其保持不变。

步骤 6 显示了将所有数据连接在一起的两种不同方法之一。concat函数接受数据帧的集合，并将它们垂直（axis='index'）或水平（axis='columns'）连接。 由于两个数据帧的索引相同，因此可以像第 7 步中那样将一个数据帧的值分配给另一列中的新列。

从步骤 2 开始，完成此秘籍的另一种方法是直接从sex_age列中分配新列，而无需使用split方法。assign方法可用于动态添加以下新列：

以与步骤 5 完全相同的方式找到Sex列。由于我们没有使用split，因此必须以不同的方式提取Age Group列。extract方法使用复杂的正则表达式来提取字符串的非常特定的部分。 为了正确使用extract，您的图案必须包含捕获组。 通过将圆括号括在图案的一部分周围来形成捕获组。 在此示例中，整个表达式是一个大捕获组。 它以\d{2}开头，它精确地搜索两位数，然后是字面的正负号，或者是可选的后两位。 尽管表达式的最后部分(?:\d{2})?被括号括起来，但是?:表示它实际上不是捕获组。 从技术上讲，它是一个非捕获组，用于同时表示两个数字（可选）。 不再需要sex_age列，将其删除。 最后，将两个整洁的数据帧相互比较，发现它们是等效的。

整洁的数据集每个变量必须有一个单独的列。 有时，多个变量名放在一列中，而其对应的值放在另一列中。 这种杂乱数据的一般格式如下：

在此示例中，前三行和后三行表示两个不同的观察值，每个观察值应为行。 需要对数据进行透视，使其最终如下所示：

在此秘籍中，我们确定包含结构错误的变量的列，并将其旋转以创建整洁的数据。

在第 1 步中，我们注意到在Info列中垂直放置了五个变量，在Value列中有相应的值。 因为我们需要将这五个变量中的每一个作为水平列名进行透视，所以pivot方法似乎可以工作。 不幸的是，当有多个非枢轴列时，Pandas 开发人员尚未实现这种特殊情况。 我们被迫使用另一种方法。

unstack方法还枢转垂直数据，但仅适用于索引中的数据。 第 3 步通过使用set_index方法移动将和不会旋转到索引中的两个列来开始此过程。 这些列进入索引后，即可像在步骤 3 中一样操作unstack。

请注意，当我们拆开数据帧时，pandas 会保留原始的列名（在这里，它只是一个列Value），并创建一个以旧列名为上层的多重索引。 数据集现在基本上是整齐的，但是我们继续使用reset_index方法将无枢轴的列设置为普通列。 因为我们有多重索引列，所以我们可以使用col_level参数选择新列名称所属的级别。 默认情况下，名称会插入到最高级别（级别 0）。 我们使用-1表示最底层。

毕竟，我们还有一些多余的数据帧名称和索引需要丢弃。 不幸的是，没有可以删除级别的数据帧方法，因此我们必须进入索引并使用其droplevel方法。 在这里，我们用单级列覆盖了旧的多重索引列。 这些列仍具有无用的名称属性Info，该属性已重命名为None。

通过将步骤 3 中的结果数据帧强制为序列，可以避免清理多重索引列。squeeze方法仅适用于单列数据帧，并将其转换为序列。

实际上，可以使用pivot_table方法，该方法对允许多少个非透视列没有限制。pivot_table方法与pivot不同，它对与index和columns参数中的列之间的交点相对应的所有值执行汇总。 由于此交点中可能存在多个值，因此pivot_table要求用户向其传递一个汇总函数，以便输出单个值。 我们使用first汇总函数，该函数采用组中的第一个值。 在此特定示例中，每个交叉点都只有一个值，因此没有任何要累加的值。 默认的聚合函数是均值，在这里会产生错误，因为某些值是字符串：

表格数据本质上是二维的，因此，可以在单个单元格中显示的信息量有限。 解决方法是，您偶尔会看到在同一单元格中存储了多个值的数据集。 整洁的数据可为每个单元格精确地提供一个值。 为了纠正这些情况，通常需要使用str序列访问器中的方法将字符串数据解析为多列。

在本秘籍中，我们检查一个数据集，该数据集的每个列中都有一个包含多个不同变量的列。 我们使用str访问器将这些字符串解析为单独的列以整理数据。

读取数据后，我们决定数据集中有多少个变量。 在这里，我们选择将Geolocation列分为四个变量，但是我们可以只选择两个作为纬度和经度，并使用负号来区分西/东和南/北。

有几种方法可以使用str访问器中的方法来解析Geolocation列。 最简单的方法是使用split方法。 我们为它传递一个由任何字符（句点）和空格定义的简单正则表达式。 当空格跟随任何字符时，将进行分割，并形成一个新列。 该模式的首次出现在纬度的尽头。 空格紧跟度数字符，并形成分割。 分割字符将被丢弃，而不保留在结果列中。 下一个分割与逗号和空格匹配，紧跟在纬度方向之后。

总共进行了三个拆分，得到了四列。 步骤 2 的第二行为其提供了有意义的名称。 即使所得的latitude和longitude列似乎是浮点数，也并非如此。 它们最初是从对象列进行解析的，因此仍然是对象数据类型。 步骤 3 使用字典将列名称映射到其新类型。

您可以使用函数to_numeric尝试将每一列转换为整数或浮点数，而不是使用字典，如果字典有很多列名，则需要大量输入。 要在每列上迭代应用此函数，请对以下内容使用apply方法：

步骤 4 将城市连接到此新数据帧的前面，以完成整理数据的过程。

split方法在此示例中使用简单的正则表达式非常有效。 对于其他示例，某些列可能会要求您根据几种不同的模式创建拆分。 要搜索多个正则表达式，请使用竖线字符|。 例如，如果我们只想分割度数符号和逗号，并在其后跟一个空格，则可以执行以下操作：

这将从步骤 2 返回相同的数据帧。可以使用管道字符将任意数量的其他拆分模式附加到前面的字符串模式。

extract方法是另一种出色的方法，它允许您提取每个单元格中的特定组。 这些捕获组必须用括号括起来。 结果中不存在任何括号外匹配的内容。 下一行产生与步骤 2 相同的输出：

此正则表达式具有四个捕获组。 第一组和第三组至少搜索一个或多个带小数的连续数字。 第二和第四组搜索单个字符（方向）。 第一个和第三个捕获组由任何字符分隔，后跟一个空格。 第二个捕获组用逗号分隔，然后用空格隔开。

每当变量在列名称中水平存储并且在列值垂直向下存储时，就会出现一种特别难以诊断的混乱数据形式。 通常，您会遇到这种类型的数据集，而不是在数据库中，而是从其他人已经生成的汇总报告中遇到。

在此秘籍中，变量在垂直和水平方向都可以识别，并通过melt和pivot_table方法重新整理为整齐的数据。

一旦在步骤 1 中确定了变量，就可以开始重组。 Pandas 没有同时旋转，列的方法，因此我们必须一次完成这一任务。 我们通过将Property列传递给melt方法中的id_vars参数来保持年份垂直。

现在，结果中还有混乱的数据部分。如前面的秘籍“将多个变量存储为列值时进行整理”秘籍所述，当在index参数中使用多个列时，我们必须使用pivot_table来旋转数据帧。 旋转后，Group和Year变量卡在索引中。 我们将它们以列的形式推出。pivot_table方法将columns参数中使用的列名称保留为列索引的名称。 重置索引后，该名称变得毫无意义，我们使用rename_axis将其删除。

每当涉及melt，pivot_table或pivot的解决方案时，您都可以确定存在使用stack和unstack的替代方法。 诀窍是首先将当前未旋转到索引中的列移动：

当每个表包含来自单个观察单位的信息时，通常更容易维护数据。 另一方面，当所有数据都在单个表中时，更容易发现见解；对于机器学习，所有数据都必须在单个表中。 整洁的数据的重点不是直接进行分析。 相反，它正在对数据进行结构化处理，以便更轻松地进行分析，并且在一个表中有多个观察单位时，可能需要将其分成各自的表。

在本秘籍中，我们使用movie数据集来识别三个观察单位（电影，演员和导演），并分别为每个观察单位创建表格。 制定此秘籍的关键之一是了解演员和导演的 Facebook 点赞与电影无关。 每个演员和导演都映射到一个表示他们的 Facebook 点赞数的单一值。 由于这种独立性，我们可以将电影，导演和演员的数据分离到各自的表中。 数据库人员将此过程标准化，这可以提高数据完整性并减少冗余。

导入数据并识别这三个实体后，我们必须为每个观察创建一个唯一的标识符，以便在将电影，演员和导演分成不同的表格后，可以将它们链接在一起。 在第 2 步中，我们只需将 ID 列设置为从零开始的行号。 在第 3 步中，我们使用wide_to_long函数同时melt，actor和director列。 它使用列的整数后缀垂直对齐数据，并将此整数后缀放置在索引中。 参数j用于控制其名称。 重复stubnames列表中不在列中的值以与已熔化的列对齐。

在第 4 步中，我们创建三个新表，并在每个表中保留id列。 我们还保留num列以标识确切的director/actor列。 步骤 5 通过删除重复项和缺失值来压缩每个表。

在第 5 步之后，这三个观测单位在各自的表中，但它们仍然包含与原始相同的数据量（还有更多），如步骤 6 所示。要返回memory_usage方法从object数据类型列中获得正确的字节数，必须将deep参数设置为True。

每个演员/导演在其各自的表中仅需要一个条目。 我们不能简单地列出演员姓名和 Facebook 点赞的表格，因为无法将演员链接回原始电影。 电影和演员之间的关系称为多对多关系。 每个电影与多个演员相关联，每个演员可以出现在多个电影中。 为了解决此关系，创建了一个中间表或关联表，该表包含电影和演员的唯一标识符（主键）。

要创建关联表，我们必须唯一地标识每个演员/导演。 一种技巧是使用pd.Categorical从每个演员/导演姓名中创建一个分类数据类型。 分类数据类型具有从每个值到整数的内部映射。 在codes属性中可以找到该整数，该属性用作唯一 ID。 要设置关联表的创建，我们将此唯一 ID 添加到actor/director表中。

步骤 8 和步骤 9 通过选择两个唯一标识符来创建关联表。 现在，我们可以将actor和director表简化为唯一的名称和 Facebook 点赞的名称。 这种新的表安排使用的内存比原始表少 20% 。 正式的关系数据库具有实体关系图以可视化表格。 在第 10 步中，我们使用简单的 ERDPlus 工具进行可视化，这大大简化了对表之间关系的理解。

通过将所有表重新结合在一起，可以重新创建原始的movie表。 首先，将关联表连接到actor/director表。 然后旋转num列，并向后添加列前缀：

这些表现在可以与movie_table结合在一起：

在本章中，我们将介绍以下主题：

可以使用多种选项将两个或多个数据帧或序列组合在一起。append方法最不灵活，仅允许将新行附加到数据帧。concat方法非常通用，可以在任一轴上组合任意数量的数据帧或序列。join方法通过将一个数据帧的列与其他数据帧的索引对齐来提供快速查找。merge方法提供了类似 SQL 的功能，可以将两个数据帧结合在一起。

在执行数据分析时，创建新列比创建新行更为常见。 这是因为新的数据行通常代表新的观察结果，而作为分析人员，连续捕获新数据通常不是您的工作。 数据捕获通常留给其他平台，如关系数据库管理系统。 但是，这是一个必不可少的功能，因为它会不时出现。

在本秘籍中，我们将首先使用.loc索引器将行追加到小型数据集，然后过渡到使用append方法。

.loc索引运算符用于根据行和列标签选择和分配数据。 传递给它的第一个值表示行标签。 在步骤 2 中，names.loc[4]引用带有等于整数 4 的标签的行。此标签当前在数据帧中不存在。 赋值语句使用列表提供的数据创建新行。 如秘籍中所述，此操作将修改names数据帧本身。 如果以前存在标签等于整数 4 的行，则该命令将覆盖该行。 与append方法相比，就地进行此修改使此索引运算符的使用风险更高，该方法从未修改原始调用数据帧。

任何有效的标签都可以与.loc索引运算符一起使用，如步骤 3 所示。不管实际的新标签值是多少，新行始终将附加在最后。 即使使用列表分配也可以，但为清楚起见，最好使用字典，以便我们准确地知道与每个值关联的列，如步骤 4 所示。

步骤 5 显示了一个小技巧，可以动态地将新标签设置为数据帧中的当前行数。 只要索引标签与列名匹配，存储在序列中的数据也将得到正确分配。

其余步骤使用append方法，这是一种仅将新行追加到数据帧的简单方法。 大多数数据帧方法都允许通过axis参数进行行和列操作。append是一个例外，它只能将行追加到数据帧。

如步骤 6 中的错误消息所示，使用映射到值的列名字典不足以进行追加操作，如步骤 6 中的错误消息所示。要正确地追加没有行名的字典，您必须将ignore_index参数设置为True。 步骤 10 向您展示如何通过简单地将字典转换为序列来保持旧索引。 确保使用name参数，该参数随后将用作新的索引标签。 通过将序列列表作为第一个参数传递，可以用append方法添加任意数量的行。

当想要以更大的数据帧以这种方式附加行时，可以通过使用to_dict方法将单行转换为字典，然后使用字典推导式和一些默认值来清除所有旧值，从而避免大量键入和错误。

将单行添加到数据帧是相当昂贵的操作，如果您发现自己编写了将单行数据附加到数据帧的循环，那么您做错了。 让我们首先创建 1,000 行新数据作为序列列表：

让我们花时间遍历每个项目一次添加一个附件需要花费多长时间：

仅花了 1,000 排就花了将近五秒钟。 如果我们改为通过整个序列列表，则速度会大大提高：

通过传递序列列表，时间已减少到十分之一秒以下。 在内部，pandas 将序列列表转换为单个数据帧，然后进行追加。

通用的concat函数可将两个或多个数据帧（或序列）垂直和水平连接在一起。 通常，当同时处理多个 Pandas 对象时，连接并不是偶然发生的，而是通过它们的索引对齐每个对象。

在此秘籍中，我们将水平和垂直方向的数据帧与concat函数结合在一起，然后更改参数值以产生不同的结果。

第一个参数是concat函数所需的唯一参数，它必须是 Pandas 对象的列表，通常是数据帧或序列的列表或字典。 默认情况下，所有这些对象将垂直堆叠在另一个之上。 在此秘籍中，仅连接了两个数据帧，但是任何数量的 Pandas 对象都可以工作。 当我们垂直连接时，数据帧通过其列名称对齐。

在此数据集中，所有列名称均相同，因此 2017 年数据中的每个列均在 2016 年数据中的同一列名称下精确对齐。 但是，如步骤 4 所示，将它们水平连接时，只有两个年份的索引标签相匹配 - AAPL和TSLA。 因此，这些股票代号在任何一年中都没有缺失值。 可以使用concat进行两种对齐方式，join参数引用的outer（默认）和inner。

append方法是concat的精简版本，只能将新行附加到数据帧。 在内部，append仅调用concat函数。 例如，此秘籍中的第 2 步可以复制以下内容：

现任美国总统的公众支持是一个经常成为新闻头条的话题，并通过民意测验进行正式衡量。 近年来，这些民意调查的频率迅速增加，并且每周都有大量新的数据发布。 有许多不同的民意测验者都有各自的问题和方法来捕获其数据，因此，数据之间存在相当多的可变性。 来自加利福尼亚大学圣塔芭芭拉分校的美国总统职位项目每天提供的总批准评级低至单个数据点。

与本书中的大多数秘籍不同，该数据在 CSV 文件中不易获得。 通常，作为数据分析师，您将需要在 Web 上查找数据，并使用可以将其抓取为可通过本地工作站解析的格式的工具。

在本秘籍中，我们将使用read_html函数，该函数功能强大，可以在线从表中抓取数据并将其转换为数据帧。 您还将学习如何检查网页以查找某些元素的基础 HTML。 我使用 Google Chrome 浏览器作为浏览器，建议您将其或 Firefox 用于基于 Web 的步骤。

通常在到达所需的一个或多个表之前多次调用read_html。 您可以使用两个主要参数来指定表match和attrs。 提供给match的字符串用于查找表中实际文本的精确匹配。 这是将显示在网页本身上的文本。 另一方面，attrs参数搜索在表标记>> pres_rm = pres_41_45.groupby('President', sort=False) \ .rolling('90D', on='End Date')['Approving'] \ .mean() >>> pres_rm.head() President End Date George Bush 1989-01-26 51.000000 1989-02-27 55.500000 1989-03-02 57.666667 1989-03-10 58.750000 1989-03-13 58.200000 Name: Approving, dtype: float64

在这里，我们可以使用unstack方法重新构造数据，使其看起来与步骤 23 的输出类似，然后进行绘制：

merge和join数据帧（而不是序列）方法以及concat函数都提供了非常相似的功能，可以将多个 Pandas 对象组合在一起。 由于它们是如此相似，并且它们在某些情况下可以相互复制，因此何时以及如何正确使用它们会变得非常混乱。 为了帮助弄清它们之间的差异，请查看以下概述：

join方法的第一个参数是other，它可以是单个数据帧/序列，也可以是任意数量的数据帧/序列的列表。

在此秘籍中，我们将执行组合数据帧所需的。 第一种情况使用concat更简单，而第二种情况使用merge更简单。

要重现步骤 6 的答案，请使用以下 SQL 查询：

在本章中，我们将介绍以下主题：

Pandas 的根源在于分析金融时间序列数据。 作者 Wes McKinney 当时对可用的 Python 工具并不满意，因此决定在他工作的对冲基金中建立 Pandas 来满足自己的需求。 从广义上讲，时间序列只是随时间推移收集的数据点。 最典型地，时间在每个数据点之间平均间隔。 Pandas 在处理日期，在不同时间段内进行汇总，对不同时间段进行采样等方面具有出色的功能。

在介绍 Pandas 之前，了解并了解 Python 核心的日期和时间功能可能会有所帮助。datetime模块提供了三种不同的数据类型，date，time和datetime。 正式而言，date是一个由年，月和日组成的时刻。 例如，2013 年 6 月 7 日为日期。time由小时，分钟，秒和微秒（百万分之一秒）组成，并且未附加到任何日期。 时间的示例是 12 小时 30 分钟。datetime由日期和时间这两个元素共同组成。

另一方面，Pandas 有一个封装日期和时间的对象，称为Timestamp。 它具有纳秒级（十亿分之一秒）的精度，并且源自 NumPy 的datetime64数据类型。 Python 和 Pandas 都具有timedelta对象，在进行日期加/减时很有用。

在本秘籍中，我们将首先探索 Python 的datetime模块，然后转向 Pandas 中相应的高级日期工具。

datetime模块是 Python 标准库的一部分，非常流行并且被广泛使用。 因此，最好对它有所了解，因为您可能会跨过它。datetime模块实际上非常简单，总共只有六种类型的对象：date，time，datetime和timedelta以及时区上的其他两个对象。 Pandas Timestamp和Timedelta对象具有datetime模块对应物的所有功能以及更多功能。 在处理时间序列时，将有可能完全保留在 Pandas 中。

步骤 1 显示了如何使用datetime模块创建日期时间，日期，时间和时间增量。 只有整数可以用作日期或时间的每个组成部分，并作为单独的参数传递。 将此与第 5 步进行比较，在第 5 步中，pandas Timestamp构造器可以接受与参数相同的组件，以及各种日期字符串。 除了整数部分和字符串，第 6 步还显示了如何将单个数字标量用作日期。 此标量的单位默认为纳秒（ns），但在第二条语句中将其更改为天（D），其他选项为小时（h），分钟（m），秒（s），毫秒（ms）和微秒（µs）。

步骤 2 详细说明了datetime模块的timedelta对象及其所有参数的构造。 再次，将其与步骤 9 中显示的 pandas Timedelta构造器进行比较，该构造器接受这些相同的参数以及字符串和标量数字。

除了仅能创建单个对象的Timestamp和Timedelta构造器之外，to_datetime和to_timedelta函数还可以将整数或字符串的整个序列转换为所需的类型 。 这些函数还提供了构造器不可用的其他几个参数。 这些参数之一是errors，默认为字符串值raise，但也可以设置为ignore或coerce。 每当无法转换字符串日期时，errors参数都会确定要采取的措施。 当设置为raise时，引发异常并且程序执行停止。 当设置为ignore时，将返回原始序列，就像进入函数之前一样。 当设置为coerce时，NaT（不是时间）对象用于表示新值。 步骤 8 的第二条语句将所有值正确转换为Timestamp，最后一个被强制变为NaT。

仅可用于to_datetime的这些参数中的另一个参数是format，当字符串包含 Pandas 无法自动识别的特定日期模式时，该参数特别有用。 在步骤 7 的第三条语句中，我们在其他一些字符中嵌入了日期时间。 我们用它们各自的格式指令替换字符串的日期和时间。

日期格式指令以单个百分号%开头，后跟单个字符。 每个指令都指定日期或时间的某些部分。 有关所有指令的表格，请参见 Python 官方文档。

当将大量字符串转换为时间戳时，日期格式指令实际上可以产生很大的不同。 每当 Pandas 使用to_datetime将字符串序列转换为时间戳时，它都会搜索代表日期的大量不同字符串组合。 即使所有字符串都具有相同的格式，也是如此。 通过format参数，我们可以指定确切的日期格式，这样 Pandas 不必每次都搜索正确的日期格式。 让我们创建一个日期列表作为字符串，并使用和不使用格式指令将它们转换为时间戳的时间：

提供格式化指令可使性能提高 40 倍。

在第 4 章，“选择数据子集”中，彻底介绍了数据帧的选择和切片。 当数据帧具有DatetimeIndex时，将出现更多选择和切片的机会。

在本秘籍中，我们将使用部分日期匹配来选择和切片带有DatetimeIndex的数据帧。

hdf5文件的许多不错的功能之一是它们保留每一列的数据类型的能力，从而大大减少了所需的内存。 在这种情况下，这些列中的三列存储为 pandas 类别而不是对象。 将它们存储为对象将导致内存使用量增加四倍：

为了使用索引运算符按日期智能地选择和切片行，索引必须包含日期值。 在步骤 2 中，我们将REPORTED_DATE列移到索引中，并正式创建DatetimeIndex作为新索引：

使用DatetimeIndex时，可以使用.loc索引器使用多种字符串选择行。 实际上，所有可以发送到 pandas Timestamp构造器的字符串都将在这里工作。 出乎意料的是，对于该秘籍中的任何选择或切片，实际上都没有必要使用.loc索引器。 索引运算符本身将以完全相同的方式工作。 例如，步骤 6 的第二条语句可以写为crime['21st October 2014 05']。 索引运算符通常为列保留，但只要存在DatetimeIndex，就可以灵活地使用时间戳。

就个人而言，我更喜欢在选择行时使用.loc索引器，并且始终将其本身用于索引运算符。.loc索引器是显式的，传递给它的第一个值始终用于选择行。

步骤 8 和 9 显示切片的工作方式与从先前步骤中选择的相同。 结果中将包括与片段的开始或结束值部分匹配的任何日期。

我们原始的犯罪数据帧未排序，并且切片仍按预期工作。 对索引进行排序将导致性能大幅提高。 让我们看一下与第 8 步完成的切片的区别：

排序后的数据帧与原始数据相比，性能提高了 50 倍。

有许多仅适用于日期时间索引的数据帧/序列方法。 如果索引为任何其他类型，则这些方法将失败。

在本秘籍中，我们将首先使用方法按照时间成分选择数据行。 然后，我们将学习功能强大的日期偏移对象及其别名。

一旦确保索引为日期时间索引，就可以利用本秘籍中的所有方法。 使用.loc索引器无法仅根据Timestamp的时间成分进行选择或切片。 要按时间范围选择所有日期，必须使用between_time方法，或者要选择确切的时间，请使用at_time。 确保为开始时间和结束时间传递的字符串至少包含小时和分钟。 也可以使用datetime模块中的time对象。 例如，以下命令将产生与步骤 2 相同的结果：

在第 4 步中，我们开始使用简单的first方法，但使用复杂的参数offset。 它必须是日期偏移对象，也可以是字符串的偏移别名。 为了帮助理解日期偏移对象，最好查看它们对单个Timestamp的作用。 例如，让我们采用索引的第一个元素，并以两种不同的方式为其添加六个月的时间：

MonthBegin和MonthEnd偏移量都不会增加或减少确切的时间量，而是有效地向上舍入到下个月的下一个月初或下个月，而不管它是在哪一天。 在内部，first方法使用数据帧的第一个索引元素，并添加传递给它的日期偏移。 然后切成片直到这个新日期。 例如，步骤 4 等效于以下内容：

步骤 5 至 7 直接从前面的等效操作开始。 在步骤 8 中，偏移别名使引用 DateOffsets 的方法更加紧凑。

与first方法相对应的是last方法，该方法从给定日期偏移的数据帧中选择最后n个时间段。分组对象具有两个名称完全相同但功能完全不同的方法。 它们返回每个组的第一个或最后一个元素，与拥有日期时间索引无关。

当可用的那些不能完全满足您的需求时，可以构建一个自定义的日期偏移：

请注意，此自定义日期偏移使Timestamp精确增加了一个月。 让我们再看一个使用更多日期和时间组件的示例：

原始的丹佛犯罪数据集非常庞大，有 460,000 多行标记有报告日期。 计算每周犯罪的数量是可以通过根据一段时间进行分组来回答的许多查询之一。resample方法提供了一个简单的接口，可以按任何可能的时间跨度进行分组。

在本秘籍中，我们将同时使用resample和groupby方法来计算每周犯罪的数量。

默认情况下，resample方法与日期时间索引隐式工作，这就是为什么我们在步骤 1 中将其设置为REPORTED_DATE的原因。在步骤 2 中，我们创建了一个中间对象，可帮助我们了解如何在数据内形成组。resample的第一个参数是rule，用于确定如何对索引中的时间戳进行分组。 在这种情况下，我们使用偏移别名W来形成长度为一周的组，该组在周日结束。 默认的结束日期是星期日，但可以通过在星期几的前面加上破折号和前三个字母来更改锚定的偏移量。

一旦我们与resample组成了小组，我们就必须链接一个方法以对每个小组采取行动。 在第 3 步中，我们使用size方法来计算每周的犯罪数量。 您可能想知道调用resample之后可以使用哪些所有可能的属性和方法。 下面检查resample对象并输出它们：

步骤 4 通过按周手动切片数据并计算行数来验证步骤 3 中计数的准确性。 实际上，甚至不需要按Timestamp分组resample方法，因为该功能可以直接从groupby方法本身获得。 但是，必须使用freq参数将偏移量pd.Grouper的实例传递给groupby方法，如步骤 6 所示。

一个非常类似的名为pd.TimeGrouper的对象能够按照与pd.Grouper完全相同的方式按时间进行分组，但是从熊猫 0.21 版本开始，它已被弃用，不应使用。 不幸的是，在线上有很多使用pd.TimeGrouper的例子，但不要让它们诱惑您。

即使索引不包含Timestamp，也可以使用resample。 您可以使用on参数选择带有时间戳的列，这些列将用于形成组：

同样，通过选择key参数的Timestamp列，可以将groupby与pd.Grouper结合使用：

通过调用每周犯罪序列中的plot方法，我们还可以轻松地绘制丹佛所有犯罪（包括交通事故）的线图：

丹佛犯罪数据集将所有犯罪和交通事故汇总在一个表格中，并通过二进制列IS_CRIME和IS_TRAFFIC将它们分开。resample方法允许您按一段时间分组并分别汇总特定的列。

在本秘籍中，我们将使用resample方法对一年中的每个季度进行分组，然后分别汇总犯罪和交通事故的数量。

在第 1 步中读取并准备好数据后，我们在第 2 步中开始分组和聚合。调用resample方法后，我们可以通过链接方法或选择一组要聚合的列来继续进行操作。 我们选择选择IS_CRIME和IS_TRAFFIC列进行汇总。 如果我们不只是选择这两个，那么所有数字列的总和将具有以下结果：

默认情况下，偏移别名Q在技术上使用 12 月 31 日作为一年的最后一天。 代表一个季度的日期范围全部使用此结束日期计算。 汇总结果使用该季度的最后一天作为标签。 步骤 3 使用偏移别名QS，默认情况下，它使用 1 月 1 日作为一年的第一天来计算季度。

大多数公共企业都报告季度收入，但是从一月开始，它们都没有相同的日历年。 例如，如果我们希望季度开始于 3 月 1 日，则可以使用QS-MAR来锚定偏移别名：

与前面的秘籍一样，我们通过手动切片来验证结果，并使用pd.Grouper使用groupby方法复制结果以设置组长。 在第 6 步中，我们仅调用数据帧的plot方法。 默认情况下，为每列数据绘制一条线。 该图清楚地表明，在今年的前三个季度，报告的犯罪数量急剧增加。 犯罪和贩运似乎都是季节性因素，在较冷的月份数字较低，在较暖的月份数字较高。

为了获得不同的视觉角度，我们可以绘制犯罪和交通增加百分比，而不是原始计数。 让我们将所有数据除以第一行并再次绘图：

通过按工作日和按年衡量犯罪的同时，必须具有直接从时间戳中提取此信息的函数。 值得庆幸的是，此函数内置于任何包含dt访问器的时间戳组成的列中。

在本秘籍中，我们将使用dt访问器为我们提供每个犯罪的工作日名称和年份（序列）。 我们通过使用这两个序列的小组来计算所有犯罪。 最后，我们在创建犯罪总量热图之前，调整数据以考虑部分年份和人口。

所有包含时间戳的数据帧的列都可以使用dt访问器访问许多其他属性和方法。 实际上，从dt访问器可用的所有这些方法和属性也可以直接从单个时间戳对象获得。

在第 2 步中，我们使用仅适用于序列的dt访问器来提取工作日名称并简单地计算发生次数。 在执行步骤 3 之前，我们使用reindex方法手动重新排列索引的顺序，在最基本的使用情况下，该方法接受包含所需顺序的列表。 也可以使用.loc索引器完成此任务，如下所示：

与.loc相比，reindex方法实际上性能更高，并且在更多情况下具有许多参数。 然后，我们使用dt访问器的weekday_name属性检索一周中每一天的名称，并在制作水平条形图之前对出现的次数进行计数。

在第 4 步中，我们执行一个非常相似的过程，并再次使用dt访问器检索年份，然后使用value_counts方法对发生次数进行计数。 在这种情况下，我们使用sort_index而不是reindex，因为年份自然会按所需顺序排序。

秘籍的目标是将工作日和年份进行分组，因此这正是我们在第 5 步中所做的。groupby方法非常灵活，可以通过多种方式进行分组。 在此秘籍中，我们将两个序列year和weekday传递给它们，所有唯一的组合从中组成一个组。 然后，我们将size方法链接到该方法，该方法返回单个值，即每个组的长度。

在第 5 步之后，我们的序列很长，只有一列数据，这使得很难按年和工作日进行比较。 为了简化可读性，我们将工作日级别使用unstack旋转为水平列名称。

在步骤 7 中，我们使用布尔索引来仅选择 2017 年的犯罪，然后再次使用dt访问器中的dayofyear查找从年初开始经过的总天数。 该序列的最大值应告诉我们 2017 年有多少天的数据。

步骤 8 非常复杂。 我们首先通过使用crime['REPORTED_DATE'].dt.dayofyear.le(272)测试每个犯罪是否在每年的第 272 天或之前犯下来创建布尔值序列。 从这里开始，我们再次使用灵活的groupby方法按照先前计算的year序列来分组，然后使用mean方法来查找每年第 272 天或之前的犯罪百分比。

.loc索引器在步骤 9 中选择整个 2017 年数据行。我们用该行除以在步骤 8 中找到的中位数百分比来调整该行。

许多犯罪的可视化都是通过热图完成的，其中一个步骤是在第 10 步借助seaborn可视化库完成的。cmap参数采用几十个可用 matplotlib 调色板的字符串名称。

在第 12 步中，我们将100k居民的犯罪率除以该年的人口。 这实际上是一个相当棘手的操作。 通常，将一个数据帧除以另一个时，它们在其列和索引上对齐。 但是，在此步骤中，crime_table没有公用的denver_pop列，因此，如果我们尝试对它们进行划分，则没有值会对齐。 要解决此问题，我们使用squeeze方法创建了den_100k序列。 我们仍然不能简单地划分这两个对象，因为默认情况下，数据帧和序列之间的划分会将数据帧的列与序列的索引对齐，如下所示：

我们需要数据帧的索引与序列的索引对齐，并且为此，我们使用div方法，该方法允许我们使用axis参数更改对齐方向。 在步骤 13 中绘制已调整犯罪率的heatmap。

让我们通过编写一个函数来一次完成此秘籍的所有步骤并添加选择特定类型犯罪的功能来完成此分析的完成：

将数据帧与DatetimeIndex一起使用将为许多新的和不同的操作打开一扇门，如本章中的几个秘籍所示。

在本秘籍中，我们将展示对具有DatetimeIndex的数据帧使用groupby方法的多功能性。

在第 1 步中，我们读入数据并将一列时间戳放入索引中以创建日期时间索引。 在第 2 步中，我们看到日期时间索引具有许多与单个时间戳对象相同的函数。 在第 3 步中，我们直接使用日期时间索引的这些额外函数提取工作日名称。

在步骤 4 中，我们利用groupby方法的特殊功能来接受通过日期时间索引传递的函数。 匿名函数中的x实际上是日期时间索引，我们使用它来检索工作日名称。 可以传递groupby任意数量的自定义函数的列表，如步骤 5 所示。这里，第一个函数使用日期时间索引的round方法将每个值四舍五入到最接近的第二小时。 第二个函数检索年份。 在分组和汇总之后，我们将unstack年作为列。 然后，我们突出显示每列的最大值。 犯罪率最高的报告时间是下午 3 点至 5 点。 大多数交通事故发生在下午 5 点之间。 晚上 7 点

此秘籍的最终结果是带有多重索引列的数据帧。 使用此数据帧，可以仅选择犯罪或交通事故。xs方法允许您从任何索引级别中选择一个值。 让我们看一个示例，其中我们仅选择处理流量的数据部分：

这称为在 Pandas 中截取的横截面。 我们必须使用axis和level参数专门表示我们的值所在的位置。 让我们再次使用xs仅选择 2016 年中处于不同级别的数据：

resample方法本身无法按时间段进行分组。 但是，groupby方法可以按时间段和其他列进行分组。

在此秘籍中，我们将展示两种非常相似但不同的方法来按时间戳分组，并在另一列中进行。

步骤 1 中的read_csv函数允许将列都转换为时间戳，并同时将它们放入索引中，以创建日期时间索引。 第 2 步使用单个分组列GENDER执行简单的groupby操作。 步骤 3 使用resample方法和偏移别名10AS以 10 年的时间增量形成组。A是年份的别名，S通知我们该时期的开始用作标签。 例如，标签1988-01-01的数据跨越该日期，直到 1997 年 12 月 31 日为止。

有趣的是，从对groupby方法的调用返回的对象具有其自己的resample方法，但反之则不成立：

在第 4 步中，根据最早雇用的员工，计算出男女的 10 年完全不同的开始日期。 步骤 6 验证每种性别最早雇用的雇员的年份与步骤 4 的输出相匹配。步骤 5 显示了当我们尝试将女性的工资与男性的工资进行比较时，这如何导致不一致。 他们没有相同的 10 年期限。

要缓解此问题，我们必须将“性别”和“时间戳”归为一组。resample方法仅能按单个时间戳分组。 我们只能使用groupby方法完成此操作。 使用pd.Grouper，我们可以复制resample的功能。 我们只需将偏移别名传递给freq参数，然后将对象与我们希望分组的所有其他列一起放在列表中，如步骤 7 所示。由于现在男性和女性的开始日期都相同 10 年期间，步骤 8 中的重塑数据将针对每种性别进行调整，从而使比较变得更加容易。 看起来，随着工作时间的延长，男性的工资往往会更高，尽管在 10 年以下的工作中，男性和女性的平均工资相同。

从局外人的角度来看，步骤 8 中输出的行代表 10 年的间隔并不明显。 改善索引标签的一种方法是显示每个时间间隔的开始和结束。 我们可以通过将当前索引年份与自身添加的 9 连接来实现此目的：

实际上，有一种完全不同的方法来制作此秘籍。 我们可以使用cut函数根据每位员工的受聘年限并从中形成组来创建等宽间隔：

很多时候，我们想知道上一次发生什么事情的时间。 例如，我们可能对上一次失业率低于 5% 或上一次股市连续五天上涨或上一次睡眠八个小时感兴趣。merge_asof函数为这些类型的问题提供答案。

在此秘籍中，我们将找到每种犯罪类别当月的犯罪总数，然后找到上次发生率降低 20% 的时间。

读完我们的数据后，我们决定不包括 2017 年 9 月的数据，因为它不是一个完整的月份。 我们使用部分日期字符串对直至 2017 年 8 月的所有犯罪进行分割，在第 4 步中，我们统计每月每个犯罪类别的所有犯罪，在第 5 步中，我们按此总数进行排序，这对于merge_asof是必需的。

在第 6 步中，我们将最新数据选择到单独的数据帧中。 我们将以 8 月的这个月为基准，并创建Total_Goal列，该列比当前少 20% 。 在第 7 步中，我们使用merge_asof查找上一次每月犯罪计数少于Total_Goal列的时间。

除了时间戳和时间增量数据类型外，pandas 还提供了时间段类型来表示确切的时间段。 例如，2012-05代表 2012 年 5 月的整个月份。您可以通过以下方式手动构建时间段：

该对象表示 2012 年 5 月 17 日下午 2:20 的整个分钟。 可以在步骤 4 中使用这些期间，而不用pd.Grouper按日期分组。 具有日期时间索引的数据帧具有to_period方法，可以将时间戳转换为期间。 它接受偏移别名来确定时间段的确切长度。

让我们验证此数据帧的最后两列是否等效于步骤 5 中的all_data：

现在，可以使用以下代码以几乎完全相同的方式复制步骤 6 和 7：

在本章中，我们将介绍以下主题：

可视化是探索性数据分析以及演示和应用中的关键组成部分。 在探索性数据分析过程中，您通常是一个人或成小组工作，需要快速创建绘图以帮助您更好地理解数据。 它可以帮助您识别异常值和丢失的数据，也可以引发其他令人感兴趣的问题，这些问题将导致进一步的分析和更直观的显示。 通常不会在考虑最终用户的情况下完成这种类型的可视化。 严格来说是为了帮助您更好地了解当前情况。 绘图不一定是完美的。

在为报表或应用准备可视化文件时，必须使用其他方法。 注意小细节。 此外，通常您必须将所有可能的可视化范围缩小到仅最能代表您数据的少数几个。 良好的数据可视化使观看者享受提取信息的体验。 就像使观众迷失的电影一样，好的可视化效果将包含大量真正引起人们兴趣的信息。

Python 中主要的数据可视化库是 matplotlib，该项目始于 2000 年代初期，旨在模仿 Matlab 的绘图函数。 Matplotlib 具有极大的能力来绘制您可以想象的大多数事物，它为用户提供了强大的功能来控制绘制表面的各个方面。 也就是说，对于初学者来说，它并不是最友好的库。 值得庆幸的是，Pandas 使我们对数据的可视化变得非常容易，并且通常只需单击plot方法即可绘制出我们想要的内容。 Pandas 实际上并没有独自策划。 它在内部调用 matplotlib 函数来创建图。 我认为，Pandas 还添加了自己的样式，该样式比 matplotlib 中的默认样式好一些。

Seaborn 还是一个可视化库，它在内部调用 matplotlib 函数，并且自身不进行任何实际绘制。 Seaborn 可以轻松轻松地制作漂亮的绘图，并允许创建许多新类型的绘图，而这些新绘图无法直接从 matplotlib 或 Pandas 获得。 Seaborn 处理整洁（长）数据，而 Pandas 处理汇总（宽）数据效果最佳。 Seaborn 在其绘图函数中还接受了 Pandas 数据帧对象。

尽管可以在不直接运行任何 matplotlib 代码的情况下创建图，但有时仍需要使用它来手动调整更精细的图细节。 因此，前两个秘籍将介绍 matplotlib 的一些基础知识，如果您需要直接使用它，将非常有用。 除了前两个秘籍外，所有绘图示例都将使用 Pandas 或海生豆。

Python 中的可视化不一定必须依赖于 matplotlib。 Bokeh 迅速成为针对 Web 的非常流行的交互式可视化库。 它完全独立于 matplotlib，并且能够生成整个应用。

对于许多数据科学家而言，他们绝大部分的绘图命令将直接来自 Pandas 或海生动物，它们都完全依赖于 matplotlib 进行实际的绘图。 但是，pandas 和 seaborn 都不提供 matplotlib 的完整替代品，有时您需要直接使用它。 因此，本秘籍将简要介绍 matplotlib 的最关键方面。

让我们从下图中的 matplotlib 图的解剖开始我们的介绍：

Matplotlib 使用对象层次结构在输出中显示其所有绘图项。 该层次结构是了解有关 matplotlib 的一切的关键。 图形和轴对象是层次结构的两个主要组成部分。 图形对象位于层次结构的顶部。 它是将要绘制的所有内容的容器。 图中包含一个或多个轴对象。 轴是使用 matplotlib 时将与之交互的主要对象，通常可以将其视为实际的绘图表面。 轴包含 x/y 轴，点，线，标记，标签，图例以及其他任何绘制的有用项目。

2017 年初，matplotlib 在发布版本 2.0 时进行了重大更改。 许多默认的绘图参数已更改。 解剖图实际上来自版本 1 的文档，但与版本 2 中更新的解剖图相比，在区分图形和轴方面做得更好。

需要在轴对象和轴之间进行非常明显的区分。 它们是完全独立的对象。 使用 matplotlib 术语的轴域对象不是轴的复数，而是如前所述，该对象创建并控制了大多数有用的绘图元素。 轴仅指图的 x 或 y （甚至 z）轴。

不幸的是，matplotlib 选择使用轴域（Axes，即单词轴的复数）来指代完全不同的对象，但是它对于库来说是至关重要的，因此目前不太可能更改。

由轴域对象创建的所有这些有用的绘图元素都称为艺术家。 甚至图形和轴域对象本身也是艺术家。 对艺术家的这种区分对本秘籍而言并不重要，但在进行更高级的 matplotlib 绘图时，尤其是在阅读文档时，将很有用。

Matplotlib 为用户提供了两个不同的接口来进行绘图。 有状态接口直接通过pyplot模块进行所有调用。 此接口称为有状态，因为 matplotlib 隐式跟踪绘图环境的当前状态。 每当在有状态接口中创建图时，matplotlib 都会找到当前图形或当前轴并对其进行更改。 这种方法可以快速绘制一些东西，但是当处理多个图形和轴时可能变得笨拙。

Matplotlib 还提供了无状态或面向对象的接口，您可以在其中显式使用引用特定绘图对象的变量。 然后可以使用每个变量来更改绘图的某些属性。 面向对象的方法是显式的，您始终清楚地知道要修改的对象。

不幸的是，同时使用这两个选项会导致很多混乱，并且 matplotlib 以难以学习而著称。 该文档提供了使用这两种方法的示例。 教程，博客文章， Stack Overflow 文章在网络上比比皆是，这使这种混乱永久化。 本秘籍仅专注于面向对象的方法，因为它具有更多的 Python 风格，并且与我们与 Pandas 互动的方式更加相似。

如果您不熟悉 matplotlib，则可能不知道如何识别每种方法之间的差异。 通过有状态接口，所有命令将直接从pyplot发出，通常是别名plt。 制作简单的线图并在每个轴上添加一些标签如下所示：

面向对象的方法仍然使用pyplot，但是通常，它只是在第一步中创建图形和轴域对象。 创建后，将直接调用这些对象的方法来更改绘图。 以下代码使用面向对象的方法对上一个图进行精确复制：

在这个简单的示例中，我们仅直接使用两个对象，即图形和轴，但是通常，图可以包含数百个对象； 可以使用每一种都以非常精细的方式进行修改，而使用状态接口则不容易做到。 在本章中，我们将构建一个空图并使用面向对象的接口修改其一些基本属性。

面向对象方法要掌握的关键思想之一是每个绘图元素都具有获取器和设置器方法。 获取器方法均以get_开头，并检索特定属性或检索其他绘图对象。 例如，ax.get_yscale()检索绘制 y 轴以字符串形式绘制的比例类型（默认为linear），而ax.get_xticklabels()检索 matplotlib 文本对象列表，每个都有自己的获取器和设置器方法。 设置方法修改特定的属性或整个对象组。 许多 matplotlib 归结为锁存到特定的绘图元素上，然后通过获取器和设置器方法进行检查和修改。

把 matplotlib 层次结构类比为家可能是有用的。 家及其所有内容将是图形。 每个房间都是轴域，房间的内容是艺术家。

开始使用面向对象接口的最简单方法是使用pyplot模块，该模块通常是步骤 1 中的别名plt和。步骤 2 显示了面向对象的方法，是最常见的启动方法之一。plt.subplots函数创建一个图形，以及一个轴域对象网格。 前两个参数nrows和ncols和定义了统一的轴对象网格。 例如，plt.subplots(2,4)在一个图形中创建了八个相同大小的轴对象。

plt.subplots函数有点奇怪，因为它返回一个两个项的元组。 第一个元素是图形，第二个元素是轴域对象。 该元组被解压缩为两个不同的变量fig和ax。 如果您不习惯于拆开元组，则可能会看到步骤 2 如下所示：

如果使用plt.subplots和创建多个轴，则元组中的第二项是包含所有轴的 NumPy 数组。 让我们在这里演示一下：

plot_objects变量是一个元组，其中包含一个数字作为其第一个元素，并包含一个 Numpy 数组作为其第二个元素：

步骤 3 验证我们确实有适当变量引用的图形和轴域对象。 在第 4 步中，我们遇到了获取器和设置器方法的第一个示例。 Matplotlib 将所有图形的默认宽度设置为 6 英寸乘以 4 英寸高，这不是屏幕上的实际大小，但是如果将图形保存到文件中，则将是确切大小。

步骤 5 显示，除了获取器方法之外，有时您还可以通过其属性直接访问另一个绘图对象。 通常，同时存在属性和获取方法来检索同一对象。 例如，查看以下示例：

许多美术师都具有facecolor属性，可以将其设置为覆盖一种特定颜色的整个表面，如步骤 7 所示。在步骤 8 中，可以使用get_children方法更好地了解对象层次。 返回轴正下方所有对象的列表。 可以从此列表中选择所有对象，然后开始使用设置器方法来修改属性，但这不是惯例。 通常，我们通常直接从属性或获取器方法中收集对象。

通常，在检索绘图对象时，它们会在列表或字典之类的容器中返回。 这就是在步骤 9 中收集刺时发生的情况。您必须从它们各自的容器中选择单个对象，以便在它们上使用获取器或设置器方法，如在步骤 10 中所做的那样。通常也使用for循环一次迭代一个。

步骤 11 以特殊方式添加网格线。 我们期望有get_grid和set_grid方法，但是，只有grid方法，该方法接受布尔值作为打开/关闭网格线的第一个参数。 每个轴都有主刻度和次刻度，但默认情况下，副刻度是关闭的。which参数用于选择带有网格线的刻度线类型。

请注意，步骤 11 的前三行选择xaxis属性并从中调用方法，而后三行直接从轴域对象本身调用等效方法。 第二组方法是 matplotlib 提供的一种方便方式，可以节省一些击键。 通常，大多数对象只能设置自己的属性，而不能设置其子级的属性。 无法通过轴设置许多轴级属性，但是在此步骤中，可以设置一些属性。 两种方法都可以接受。

在步骤 11 中将网格线与第一行添加在一起时，我们设置属性linewidth，color，，和linestyle。 这些都是 matplotlib 线（正式为Line2D对象）的所有属性。 您可以在此处查看所有可用属性。set_ticks方法接受一个浮点序列，并仅在那些位置绘制刻度线。 使用空列表将完全删除所有刻度。

每个轴可能都标有一些文本，为此 matplotlib 正式使用了Text对象。 所有可用文本属性中仅更改了几个。set_yticklabels轴方法接收一个字符串列表，用作每个刻度的标签。 您可以设置任意数量的文本属性。

为了帮助找到每个绘图对象的所有可能的属性，只需调用properties方法，该方法会将所有它们显示为字典。 让我们看一下轴对象的属性的精选列表：

Matplotlib 有几十种绘图方法，几乎​​可以想象任何一种绘图。 线，条，直方图，散点图，方格，小提琴，轮廓，饼图以及许多其他图都可以从“轴”对象中用作方法。 只有在 1.5 版（2015 年发布）中，matplotlib 才开始接受来自 Pandas 数据帧的数据。 在此之前，必须将数据从 NumPy 数组或 Python 列表传递给它。

在本秘籍中，我们将通过将 Pandas 数据帧中的数据减少到 NumPy 数组来可视化电影预算随时间的趋势，然后将其传递给 matplotlib 绘图函数。

在第 1 步中，我们开始寻求分析电影预算的方法，方法是找出每年的预算中位数（百万美元）。 找到每年的预算中位数后，我们决定对其进行平滑处理，因为每年之间会有很大的差异。 我们选择对数据进行平滑处理是因为我们正在寻找一个总体趋势，而不必对任何一年的确切值感兴趣。

在此步骤中，我们使用rolling方法根据最近五年数据的平均值来计算每年的新值。 例如，将 2011 年至 2015 年的预算中位数进行分组并取平均值。 结果是 2015 年的新值。rolling方法唯一需要的参数是窗口的大小，默认情况下，窗口的大小将在当年结束。

rolling方法返回一个类似分组的对象，该对象必须使其组与另一个函数共同作用才能产生结果。 让我们手动验证rolling方法是否能像往年一样工作：

这些值与步骤 1 的输出相同。在步骤 2 中，通过将数据放入 NumPy 数组中，我们准备使用 matplotlib。 在第 3 步中，我们创建图形和轴以设置面向对象的接口。plt.subplots方法支持大量输入。 请参阅此文档以查看此函数和figure函数的所有可能参数。

plot方法中的前两个参数表示折线图的 x 和 y 值。 所有行属性都可以在plot的调用中进行更改。轴域的set_title方法提供标题，并可以在其调用内设置所有可用的文本属性。set_ylablel方法也是如此。 如果要为许多对象设置相同的属性，则可以将它们打包在一起作为字典，然后将该字典作为参数之一传递，如**text_kwargs一样。

在第 4 步中，我们注意到 2000 年左右开始的预算中值出现意外下降的趋势，并怀疑每年收集的电影数量可能起到解释作用。 我们选择通过从 1970 年开始每隔五年创建一个条形图来向图表添加此维度。我们对 NumPy 数据数组使用布尔选择的方式与在步骤 5 中对 Pandas 序列的处理方式相同。

bar方法将 x 值的高度和条形的宽度作为其前三个参数，并将条形的中心直接放在每个 x 值处。 条形高度是从电影计数中得出的，电影计数首先被缩小到零到一之间，然后乘以最大中位数预算。 这些钢筋高度存储在变量ct_norm_5中。 为了正确标记每个条形图，我们首先将条形图中心，其高度和实际影片数压缩在一起。 然后，我们遍历此压缩对象，并使用text方法将计数放在小节之前，该方法接受 x 值，y 值和字符串。 我们将 y 值略微向上调整，并使用水平对齐参数ha将文本居中。

回顾步骤 3，您会注意到label参数等于All Movies的plot方法。 这是为绘图创建图例时 matplotlib 使用的值。 调用legend Axes 方法会将所有带有指定标签的图放置在图例中。

为了调查预算中位数的意外下降，我们可以仅关注每年预算最高的 10 部电影。 在按年份分组后，第 6 步使用自定义聚合函数，然后以与以前相同的方式对结果进行平滑处理。 这些结果可以直接绘制在同一张图上，但是由于值要大得多，因此我们选择创建一个带有两个轴的全新图形。

我们通过在两个两行一列的网格中创建具有两个子图的图形来开始执行步骤 7。 请记住，当创建多个子图时，所有轴都存储在 NumPy 数组中。 步骤 5 的最终结果将在顶部轴中重新创建。 我们在底部的轴上绘制预算最高的 10 部电影。 请注意，年份与底部和顶部轴都对齐，因为在图形创建中sharex参数设置为True。 共享轴时，matplotlib 会删除所有刻度线的标签，但会保留每个刻度线的细小垂直线。 要删除这些刻度线，我们使用pyplot的setp函数。 尽管这不是直接面向对象的，但是当我们要为整个绘制对象序列设置属性时，它是显式的并且非常有用。 通过此有用的函数，我们将所有刻度线设置为不可见。

最后，我们然后多次调用图形方法。 这与我们通常调用的轴域方法不同。tight_layout方法通过删除多余的空间并确保不同的轴不会重叠来将子图调整为更好的外观。suptitle方法为整个图形创建标题，而set_title轴方法则为单个轴创建标题。 它接受 x 和 y 位置来表示图形坐标系中的位置，其中(0, 0)表示左下，而(1, 1)表示右上。 默认情况下，y 值为 0.98，但我们将其上移了几个点至 1.02。

每个轴域还具有一个坐标系，其中(0, 0)用于左下角，而(1, 1)用于右上角。 除了那些坐标系之外，每个轴还具有一个数据坐标系，这对于大多数人来说更自然，并表示 x 和 y 轴的边界。 这些界限可以分别通过ax.get_xlim()和ax.get_ylim()获取。 在此之前的所有绘图均使用数据坐标系。 请参阅“变换教程”以了解有关坐标系的更多信息。

由于两个轴的 y 轴使用相同的单位，因此我们使用图形的text方法使用图形坐标系将自定义 y 轴标签直接放置在每个轴之间。 最后，我们将图形保存到桌面。 路径中的波浪符号~代表主目录，但是savefig方法无法理解这意味着什么。 您必须使用os库中的expanduser函数来创建完整路径。 例如，path变量在我的机器上变为：

savefig方法现在可以在正确的位置创建文件。 默认情况下，savefig将仅保存在图形坐标系的(0, 0))至(1, 1)中绘制的内容。 由于我们的标题略微超出该区域，因此其中一些将被裁剪。 将bbox_inches参数设置为yight，matplotlib 将包含扩展到该区域之外的所有标题或标签。

在 1.5 版发布之后，Matplotlib 开始接受其所有绘图函数的 pandas 数据帧。数据帧通过data参数传递给绘图方法。 这样做使您可以引用具有字符串名称的列。 以下脚本创建了从 2000 年开始随机选择的 100 部电影的 IMDB 分数与年份的散点图。 每个点的大小与预算成比例：

创建散点图后，最高得分的电影和最低得分的电影都用annotate方法标记。xy参数是我们要注释的点的元组。xytext参数是文本位置的另一个元组坐标。 由于ha设置为center，因此文本居中。

Pandas 通过自动执行许多步骤使绘制过程变得非常容易。 所有 Pandas 绘图均由 matplotlib 内部处理，并通过数据帧或序列的plot方法公开访问。 我们说 Pandasplot方法是围绕 matplotlib 的包装器。 在 Pandas 中创建图时，将返回 matplotlib 轴或图。 您可以使用 matplotlib 的全部函数来修改该对象，直到获得所需的结果。

Pandas 仅能生成 matplotlib 可用的一小部分图，例如线图，条形图，方框图和散点图，以及核密度估计值（KDE）和直方图。 Pandas 通过使过程变得非常简单和高效而擅长于其创建的绘图，通常只需要一行代码，从而节省了探索数据的大量时间。

了解 Pandas 绘图的关键之一就是要知道绘图方法是否需要一个或两个变量来进行绘图。 例如，线图和散点图需要两个变量来绘制每个点。 对于条形图也是如此，后者需要一些 x 坐标来定位条形，并需要另一个变量来设置条形的高度。 箱线图，直方图和 KDE 仅使用一个变量进行绘制。

默认情况下，两变量线图和散点图使用索引作为 x 轴，将列的值用作 y 轴。 单变量图忽略索引，并对每个变量应用转换或聚合以制作其图。 在本秘籍中，我们将考察 Pandas 中两变量和一变量绘图之间的差异。

第 1 步创建了一个小的样本数据帧，它将帮助我们说明使用 Pandas 进行的两个变量绘制和一变量绘制之间的差异。 默认情况下，Pandas 将使用数据帧的每个数字列制作一组新的条形，线形，KDE，盒形图或直方图，并在将其作为两变量图时将索引用作 x 值。 散点图是例外之一，必须明确为 x 和 y 值指定一列。

pandas plot方法非常通用，并具有大量参数，可让您根据自己的喜好自定义结果。 例如，您可以设置图形大小，打开和关闭网格线，设置 x 和 y 轴的范围，为图形着色，旋转刻度线，以及更多。

您还可以使用特定 matplotlib 绘图方法可用的任何参数。 多余的参数将由plot方法的**kwds参数收集，并正确传递给基础的 matplotlib 函数。 例如，在第 2 步中，我们创建一个条形图。 这意味着我们可以使用 matplotlib bar函数中可用的所有参数，以及 Pandas plot方法中可用的参数。

在第 3 步中，我们创建一个单变量 KDE 图，该图将为数据帧中的每个数字列创建一个密度估计。 步骤 4 将所有两个变量图放置在同一图中。 同样，第 5 步将所有一变量图放置在一起。 第 4 步和第 5 步中的每个步骤都会创建一个具有三个轴对象的图形。 命令plt.subplots(1, 3)创建一个图形，该图形具有分布在一行和三列上的三个轴。 它返回一个由图和包含轴的一维 NumPy 数组组成的两元组。 元组的第一项被解包到变量fig中。 元组的第二个项目被解包为另外三个变量，每个变量一个。 Pandasplot方法方便地带有ax参数，使我们可以将绘图结果放入图中的特定轴中。

除散点图外，所有图均未指定要使用的列。 Pandas 默认使用每一个数字列，并且在使用双变量图的情况下默认使用索引。 当然，您可以指定要用于每个 x 或 y 值的确切列：

探索性数据分析主要由可视化指导，而 Pandas 为快速，轻松地创建它们提供了一个很好的接口。 开始可视化任何数据集时的一种简单策略是仅关注单变量图。 最受欢迎的单变量图往往是用于分类数据（通常是字符串）的条形图，以及用于连续数据（总是数字）的直方图，箱形图或 KDE。 直接在项目开始时尝试同时分析多个变量可能会很困难。

在本秘籍中，我们通过直接用 Pandas 创建单变量和多变量图来对航班数据集进行一些基本的探索性数据分析。