UCB Data100：数据科学的原理和技巧：第一章到第五章

一、引言

原文：Introduction

译者：飞龙

协议：CC BY-NC-SA 4.0

学习成果

• 了解 Data 100 的总体目标

• 了解数据科学生命周期的阶段

数据科学是一个跨学科领域，具有各种应用，并且在解决具有挑战性的社会问题方面具有巨大潜力。通过建立数据科学技能，您可以赋予自己参与和引领塑造您的生活和整个社会对话的能力，无论是与气候变化作斗争、推出多样性倡议，还是其他方面。

这个领域正在迅速发展；现代数据科学中许多关键技术基础在 21 世纪初得到了普及。

它基本上是以人为中心的，并通过定量平衡权衡来促进决策。为了可靠地量化事物，我们必须适当地使用和分析数据，对每一步都要进行批判性思考和怀疑，并考虑我们的决定如何影响他人。

最终，数据科学是将以数据为中心的、计算性的和推理性的思维应用于：

• 了解世界（科学）。

• 解决问题（工程）。

对数据科学的真正掌握需要深刻的理论理解和对领域专业知识的牢固掌握。本课程将帮助您建立在前者基础上的技术知识，使您能够获取数据并对世界上最具挑战性和模糊的问题产生有用的见解。

课程目标

• 为您准备伯克利高级课程，包括数据管理、机器学习和统计学

• 使您能够在数据科学领域开展职业生涯

• 使您能够通过计算和推理思维解决现实世界的问题

我们将涵盖的一些主题

• Pandas 和 NumPy

• 探索性数据分析

• 正则表达式

• 可视化

• 抽样

• 模型设计和损失公式

• 线性回归

• 梯度下降

• 逻辑回归

• 还有更多！

为了让您成功，我们将 Data 100 中的概念组织成了数据科学生命周期：一个迭代过程，涵盖了数据科学的各种统计和计算构建模块。

1.1 数据科学生命周期

数据科学生命周期是对数据科学工作流程的高级概述。这是一个数据科学家在对数据驱动的问题进行彻底分析时应该探索的阶段循环。

数据科学生命周期中存在许多关键思想的变体。在 Data 100 中，我们使用流程图来可视化生命周期的各个阶段。请注意，有两个入口点。

1.1.1 提出问题

无论是出于好奇还是出于必要，数据科学家不断提出问题。例如，在商业世界中，数据科学家可能对预测某项投资产生的利润感兴趣。在医学领域，他们可能会问一些患者是否比其他人更有可能从治疗中受益。

提出问题是数据科学生命周期开始的主要方式之一。它有助于充分定义问题。在构建问题之前，以下是一些您应该问自己的事情。

• 我们想要知道什么？

  • 一个过于模糊的问题可能会导致混乱。

• 我们试图解决什么问题？

  • 问一个问题的目标应该是清晰的，以便为利益相关者的努力提供合理的理由。

• 我们想要测试的假设是什么？

  • 这为我们提供了一个清晰的视角，以分析最终结果。

• 我们的成功指标是什么？

  • 这为我们建立了一个明确的观点，知道何时结束项目。

1.1.2 获取数据

生命周期的第二个入口是通过获取数据。对任何问题的仔细分析都需要使用数据。数据可能对我们而言是 readily available，或者我们可能不得不着手收集数据。在这样做时，至关重要的是要问以下问题：

• 我们有什么数据，我们需要什么数据？

  • 定义数据的单位（人、城市、时间点等）和要测量的特征。

• 我们如何取样更多的数据？

  • 抓取网页，手动收集，进行实验等。

• 我们的数据是否代表我们想研究的人群？

  • 如果我们的数据不代表我们感兴趣的人群，那么我们可能得出错误的结论。

关键程序：数据获取，数据清洗

1.1.3 理解数据

原始数据本身并不具有固有的用处。如果不仔细调查，就不可能辨别出所有变量之间的模式和关系。因此，将纯数据转化为可操作的见解是数据科学家的一项关键工作。例如，我们可以选择问：

• 我们的数据是如何组织的，它包含了什么？

  • 了解数据对世界有何影响有助于我们更好地理解世界。

• 我们有相关的数据吗？

  • 如果我们收集的数据对于手头的问题没有用处，那么我们必须收集更多的数据。

• 数据中存在什么偏见、异常或其他问题？

  • 如果忽视这些问题，可能会导致许多错误的结论，因此数据科学家必须始终注意这些问题。

• 我们如何转换数据以进行有效分析？

  • 数据并不总是一眼就容易解释的，因此数据科学家应该努力揭示隐藏的见解。

关键程序：探索性数据分析，数据可视化。

1.1.4 理解世界

在观察了数据中的模式之后，我们可以开始回答我们的问题。这可能需要我们预测一个数量（机器学习），或者衡量某种处理的效果（推断）。

从这里，我们可以选择报告我们的结果，或者可能进行更多的分析。我们可能对我们的发现不满意，或者我们的初步探索可能提出了需要新数据的新问题。

• 数据对世界有何影响？

  • 根据我们的模型，数据将引导我们对真实世界的某些结论。

• 它是否回答了我们的问题或准确解决了问题？

  • 如果我们的模型和数据不能实现我们的目标，那么我们必须改革我们的问题、模型，或者两者兼而有之。

• 我们的结论有多可靠，我们能相信这些预测吗？

  • 不准确的模型可能导致错误的结论。

关键程序：模型创建，预测，推断。

1.2 结论

数据科学生命周期旨在成为一组一般性指导方针，而不是一套硬性要求。在探索生命周期的过程中，我们将涵盖数据科学中使用的基本理论和技术。在课程结束时，我们希望您开始把自己看作是一名数据科学家。

因此，我们将首先介绍探索性数据分析中最重要的工具之一：pandas。

二、Pandas I

原文：Pandas I

译者：飞龙

协议：CC BY-NC-SA 4.0

学习成果

• 建立对pandas和pandas语法的熟悉度。

• 学习关键数据结构：DataFrame、Series和Index。

• 了解提取数据的方法：.loc、.iloc和[]。

在这一系列讲座中，我们将让您直接探索和操纵真实世界的数据。我们将首先介绍pandas，这是一个流行的 Python 库，用于与表格数据交互。

2.1 表格数据

数据科学家使用各种格式存储的数据。本课程的主要重点是理解表格数据——存储在表格中的数据。

表格数据是数据科学家用来组织数据的最常见系统之一。这在很大程度上是因为表格的简单性和灵活性。表格允许我们将每个观察，或者从个体收集数据的实例，表示为其自己的行。我们可以将每个观察的不同特征，或者特征，记录在单独的列中。

为了看到这一点，我们将探索elections数据集，该数据集存储了以前年份竞选美国总统的政治候选人的信息。

代码

import pandas as pd
pd.read_csv("data/elections.csv")

182 行×6 列

在elections数据集中，每一行代表一个候选人在特定年份竞选总统的一个实例。例如，第一行代表安德鲁·杰克逊在 1824 年竞选总统。每一列代表每个总统候选人的一个特征信息。例如，名为“结果”的列存储候选人是否赢得选举。

你在 Data 8 中的工作帮助你非常熟悉使用和解释以表格格式存储的数据。那时，你使用了datascience库的Table类，这是专门为 Data 8 学生创建的特殊编程库。

在 Data 100 中，我们将使用编程库pandas，这在数据科学界被普遍接受为操纵表格数据的行业和学术标准工具（也是我们熊猫吉祥物 Petey 的灵感来源）。

使用pandas，我们可以

• 以表格格式排列数据。

• 提取由特定条件过滤的有用信息。

• 对数据进行操作以获得新的见解。

• 将NumPy函数应用于我们的数据（我们来自 Data 8 的朋友）。

• 执行矢量化计算以加快我们的分析速度（实验室 1）。

2.2 Series、DataFrame和索引

要开始我们在pandas中的工作，我们必须首先将库导入到我们的 Python 环境中。这将允许我们在我们的代码中使用pandas数据结构和方法。

# `pd` is the conventional alias for Pandas, as `np` is for NumPy
import pandas as pd

pandas中有三种基本数据结构：

1. Series：1D 带标签的数组数据；最好将其视为列数据。

2. DataFrame：带有行和列的 2D 表格数据。

3. 索引：一系列行/列标签。

DataFrame，Series和索引可以在以下图表中以可视化方式表示，该图表考虑了elections数据集的前几行。

注意DataFrame是一个二维对象——它包含行和列。上面的Series是这个DataFrame的一个单独的列，即Result列。两者都包含一个索引，或者共享的行标签列表（从 0 到 4 的整数，包括 0）。

2.2.1 系列

Series 表示DataFrame的一列；更一般地，它可以是任何 1 维类似数组的对象。它包含：

• 相同类型的值序列。

• 索引称为数据标签的序列。

在下面的单元格中，我们创建了一个名为s的Series。

s = pd.Series(["welcome", "to", "data 100"])
s

0     welcome
1          to
2    data 100
dtype: object

s.values # Data values contained within the Series

array(['welcome', 'to', 'data 100'], dtype=object)

s.index # The Index of the Series

RangeIndex(start=0, stop=3, step=1)

默认情况下，Series 的索引是从 0 开始的整数的顺序列表。可以将所需索引的手动指定列表传递给index参数。

s = pd.Series([-1, 10, 2], index = ["a", "b", "c"])
s

a    -1
b    10
c     2
dtype: int64

s.index

Index(['a', 'b', 'c'], dtype='object')

初始化后也可以更改索引。

s.index = ["first", "second", "third"]
s

first     -1
second    10
third      2
dtype: int64

s.index

Index(['first', 'second', 'third'], dtype='object')

2.2.1.1 Series中的选择

就像在使用NumPy数组时一样，我们可以从Series中选择单个值或一组值。为此，有三种主要方法：

1. 单个标签。

2. 标签列表。

3. 过滤条件。

为了证明这一点，让我们定义ser系列。

ser = pd.Series([4, -2, 0, 6], index = ["a", "b", "c", "d"])
ser

a    4
b   -2
c    0
d    6
dtype: int64

2.2.1.1.1 单个标签

ser["a"] # We return the value stored at the Index label "a"

4

2.2.1.1.2 标签列表

ser[["a", "c"]] # We return a *Series* of the values stored at the Index labels "a" and "c"

a    4
c    0
dtype: int64

2.2.1.1.3 过滤条件

也许从Series中选择数据的最有趣（和有用）的方法是使用过滤条件。

首先，我们对Series应用布尔运算。这将创建一个新的布尔值系列。

ser > 0 # Filter condition: select all elements greater than 0

a     True
b    False
c    False
d     True
dtype: bool

然后，我们使用这个布尔条件来索引我们原始的Series。pandas将只选择原始Series中满足条件的条目。

ser[ser > 0] 

a    4
d    6
dtype: int64

2.2.2 数据框

通常，我们将使用Series的角度来处理它们，认为它们是DataFrame中的列。我们可以将DataFrame视为所有共享相同索引的Series的集合。

在 Data 8 中，您遇到了datascience库的Table类，它表示表格数据。在 Data 100 中，我们将使用pandas库的DataFrame类。

2.2.2.1 创建DataFrame

有许多创建DataFrame的方法。在这里，我们将介绍最流行的方法：

1. 从 CSV 文件中。

2. 使用列名和列表。

3. 从字典中。

4. 从Series中。

更一般地，创建DataFrame的语法是：pandas.DataFrame(data, index, columns)。

2.2.2.1.1 从 CSV 文件中

在 Data 100 中，我们的数据通常以 CSV（逗号分隔值）文件格式存储。我们可以通过将数据路径作为参数传递给以下pandas函数来将 CSV 文件导入DataFrame。

pd.read_csv("filename.csv")

现在，我们可以认识到pandas DataFrame 表示的是elections数据集。

elections = pd.read_csv("data/elections.csv")
elections

182 行×6 列

这段代码将我们的“DataFrame”对象存储在“选举”变量中。经过检查，我们的“选举”DataFrame 有 182 行和 6 列（“年份”，“候选人”，“党派”，“普选票”，“结果”，“%”）。每一行代表一条记录——在我们的例子中，是某一年的总统候选人。每一列代表记录的一个属性或特征。

2.2.2.1.2 使用列表和列名

我们现在将探讨如何使用我们自己的数据创建“DataFrame”。

考虑以下例子。第一个代码单元创建了一个只有一个列“Numbers”的“DataFrame”。第二个创建了一个有“Numbers”和“Description”两列的“DataFrame”。请注意，需要一个二维值列表来初始化第二个“DataFrame”——每个嵌套列表代表一行数据。

df_list = pd.DataFrame([1, 2, 3], columns=["Numbers"])
df_list

df_list = pd.DataFrame([[1, "one"], [2, "two"]], columns = ["Number", "Description"])
df_list

2.2.2.1.3 从字典

第三种（更常见的）创建“DataFrame”的方法是使用字典。字典的键代表列名，字典的值代表列的值。

以下是实现这种方法的两种方式。第一种是基于指定“DataFrame”的列，而第二种是基于指定“DataFrame”的行。

df_dict = pd.DataFrame({"Fruit": ["Strawberry", "Orange"], "Price": [5.49, 3.99]})
df_dict

df_dict = pd.DataFrame([{"Fruit":"Strawberry", "Price":5.49}, {"Fruit": "Orange", "Price":3.99}])
df_dict

2.2.2.1.4 从“Series”

早些时候，我们解释了“Series”与“DataFrame”中的列是同义词。因此，“DataFrame”相当于共享相同索引的“Series”集合。

事实上，我们可以通过合并两个或更多的“Series”来初始化“DataFrame”。

# Notice how our indices, or row labels, are the same

s_a = pd.Series(["a1", "a2", "a3"], index = ["r1", "r2", "r3"])
s_b = pd.Series(["b1", "b2", "b3"], index = ["r1", "r2", "r3"])

pd.DataFrame({"A-column": s_a, "B-column": s_b})

pd.DataFrame(s_a)

s_a.to_frame()

2.2.3 索引

在技术上，索引不一定是整数，也不一定是唯一的。例如，我们可以将“选举”DataFrame 的索引设置为总统候选人的名字。

# Creating a DataFrame from a CSV file and specifying the Index column
elections = pd.read_csv("data/elections.csv", index_col = "Candidate")
elections

182 行×5 列

我们还可以选择一个新的列，并将其设置为 DataFrame 的索引。例如，我们可以将“选举”DataFrame 的索引设置为候选人的党派。

elections.reset_index(inplace = True) # Resetting the index so we can set the Index again
# This sets the index to the "Party" column
elections.set_index("Party")

182 行×5 列

如果需要，我们可以将索引恢复为默认的整数列表。

# This resets the index to be the default list of integer
elections.reset_index(inplace=True) 
elections.index

RangeIndex(start=0, stop=182, step=1)

还需要注意的是，构成索引的行标签不一定是唯一的。虽然索引值可以是唯一的和数字的，充当行号，但它们也可以是命名的和非唯一的。

这里我们看到唯一和数字的索引值。

然而，这里的索引值是非唯一的。

2.3 DataFrame属性：索引、列和形状

另一方面，DataFrame中的列名几乎总是唯一的。回顾elections数据集，有两列命名为“Candidate”是没有意义的。

有时，您可能希望提取这些不同的值，特别是行和列标签的列表。

对于索引/行标签，请使用DataFrame.index：

elections.set_index("Party", inplace = True)
elections.index

Index(['Democratic-Republican', 'Democratic-Republican', 'Democratic',
       'National Republican', 'Democratic', 'National Republican',
       'Anti-Masonic', 'Whig', 'Democratic', 'Whig',
       ...
       'Constitution', 'Republican', 'Independent', 'Libertarian',
       'Democratic', 'Green', 'Democratic', 'Republican', 'Libertarian',
       'Green'],
      dtype='object', name='Party', length=182)

对于列标签，请使用DataFrame.columns：

elections.columns

Index(['index', 'Candidate', 'Year', 'Popular vote', 'Result', '%'], dtype='object')

对于 DataFrame 的形状，我们可以使用DataFrame.shape：

elections.shape

(182, 6)

2.4 DataFrame中的切片

现在我们已经更多地了解了DataFrame，让我们深入了解它们的功能。

DataFrame类的 API（应用程序编程接口）是庞大的。在本节中，我们将讨论DataFrame API 的几种方法，这些方法允许我们提取数据子集。

操作DataFrame最简单的方法是提取行和列的子集，称为切片。

我们可能希望提取数据的常见方式包括：

• DataFrame中的第一行或最后一行。

• 具有特定标签的数据。

• 特定位置的数据。

我们将使用 DataFrame 类的四种主要方法：

1. .head和.tail

2. .loc

3. .iloc

4. []

2.4.1 使用.head和.tail提取数据

我们希望提取数据的最简单的情况是当我们只想选择DataFrame的前几行或最后几行时。

要提取 DataFrame df的前n行，我们使用语法df.head(n)。

elections = pd.read_csv("data/elections.csv")

# Extract the first 5 rows of the DataFrame
elections.head(5)

类似地，调用df.tail(n)允许我们提取 DataFrame 的最后n行。

# Extract the last 5 rows of the DataFrame
elections.tail(5)

2.4.2 基于标签的提取：使用.loc进行索引

对于使用特定列或索引标签提取数据的更复杂任务，我们可以使用.loc。.loc访问器允许我们指定我们希望提取的行和列的标签。标签（通常称为索引）是 DataFrame 最左边的粗体文本，而列标签是 DataFrame 顶部的列名。

使用.loc获取数据时，我们必须指定数据所在的行和列标签。行标签是.loc函数的第一个参数；列标签是第二个参数。

.loc的参数可以是：

• 一个单一的值。

• 一个切片。

• 一个列表。

例如，要选择单个值，我们可以从elections DataFrame中选择标记为0的行和标记为Candidate的列。

elections.loc[0, 'Candidate']

'Andrew Jackson'

请记住，只传入一个参数作为单个值将产生一个Series。下面，我们提取了"Popular vote"列的子集作为Series。

elections.loc[[87, 25, 179], "Popular vote"]

87     15761254
25       848019
179    74216154
Name: Popular vote, dtype: int64

要选择多个行和列，我们可以使用 Python 切片表示法。在这里，我们选择从标签0到3的行和从标签"Year"到"Popular vote"的列。

elections.loc[0:3, 'Year':'Popular vote']

假设相反，我们想要提取elections DataFrame 中前四行的所有列值。这时，缩写:就很有用。

elections.loc[0:3, :]

我们可以使用相同的缩写来提取所有行。

elections.loc[:, ["Year", "Candidate", "Result"]]

182 行×3 列

有几件事情我们应该注意。首先，与传统的 Python 不同，pandas允许我们切片字符串值（在我们的例子中，是列标签）。其次，使用.loc进行切片是包含的。请注意，我们的结果DataFrame包括我们指定的切片标签之间和包括这些标签的每一行和列。

同样，我们可以使用列表在elections DataFrame 中获取多行和多列。

elections.loc[[0, 1, 2, 3], ['Year', 'Candidate', 'Party', 'Popular vote']]

最后，我们可以互换列表和切片表示法。

elections.loc[[0, 1, 2, 3], :]

2.4.3 基于整数的提取：使用.iloc进行索引

使用.iloc进行切片与.loc类似。但是，.iloc使用的是行和列的索引位置，而不是标签（想一想：loc 使用labels；iloc 使用indices）。.iloc函数的参数也类似地行为 —— 允许单个值、列表、索引和这些的任意组合。

让我们开始重现上面的结果。我们将从我们的elections DataFrame 中选择第一个总统候选人开始：

# elections.loc[0, "Candidate"] - Previous approach
elections.iloc[0, 1]

'Andrew Jackson'

请注意，.loc和.iloc的第一个参数是相同的。这是因为标签为 0 的行恰好在elections DataFrame 的$0^{th}$（或者说第一个位置）上。通常情况下，任何 DataFrame 中的行标签都是从 0 开始递增的，这一点是正确的。

并且，就像以前一样，如果我们只传入一个单一的值参数，我们的结果将是一个Series。

elections.iloc[[1,2,3],1]

1    John Quincy Adams
2       Andrew Jackson
3    John Quincy Adams
Name: Candidate, dtype: object

然而，当我们使用.iloc选择前四行和列时，我们注意到了一些东西。

# elections.loc[0:3, 'Year':'Popular vote'] - Previous approach
elections.iloc[0:4, 0:4]

切片在.iloc中不再是包容的——它是排他的。换句话说，使用.iloc时，切片的右端点不包括在内。这是pandas语法的微妙之处之一；通过练习你会习惯的。

列表行为与预期的一样。

#elections.loc[[0, 1, 2, 3], ['Year', 'Candidate', 'Party', 'Popular vote']] - Previous Approach
elections.iloc[[0, 1, 2, 3], [0, 1, 2, 3]]

就像使用.loc一样，我们可以使用冒号与.iloc一起提取所有行或列。

elections.iloc[:, 0:3]

182 行×3 列

这个讨论引出了一个问题：我们什么时候应该使用.loc和.iloc？在大多数情况下，.loc通常更安全。你可以想象，当应用于数据集的顺序可能会改变时，.iloc可能会返回不正确的值。然而，.iloc仍然是有用的——例如，如果你正在查看一个排序好的电影收入的DataFrame，并且想要得到给定年份的收入中位数，你可以使用.iloc来索引到中间。

总的来说，重要的是要记住：

• .loc执行label-based 提取。

• .iloc执行integer-based 提取。

2.4.4 上下文相关的提取：使用[]进行索引

[]选择运算符是最令人困惑的，但也是最常用的。它只接受一个参数，可以是以下之一：

1. 一系列行号。

2. 一系列列标签。

3. 单列标签。

也就是说，[]是上下文相关的。让我们看一些例子。

2.4.4.1 一系列行号

假设我们想要我们的elections DataFrame 的前四行。

elections[0:4]

2.4.4.2 一系列列标签

假设我们现在想要前四列。

elections[["Year", "Candidate", "Party", "Popular vote"]]

182 行×4 列

2.4.4.3 单列标签

最后，[]允许我们仅提取Candidate列。

elections["Candidate"]

0         Andrew Jackson
1      John Quincy Adams
2         Andrew Jackson
3      John Quincy Adams
4         Andrew Jackson
             ...        
177           Jill Stein
178         Joseph Biden
179         Donald Trump
180         Jo Jorgensen
181       Howard Hawkins
Name: Candidate, Length: 182, dtype: object

输出是一个Series！在本课程中，我们将非常熟悉[]，特别是用于选择列。在实践中，[]比.loc更常见，特别是因为它更加简洁。

2.5 结语

pandas库非常庞大，包含许多有用的函数。这是一个指向文档的链接。我们当然不指望您记住库中的每一个方法。

入门级的 Data 100 pandas 讲座将提供对关键数据结构和方法的高层次视图，这些将构成您pandas知识的基础。本课程的目标是帮助您建立对真实世界编程实践的熟悉度……谷歌搜索！您的问题的答案可以在文档、Stack Overflow 等地方找到。能够搜索、阅读和实施文档是任何数据科学家的重要生活技能。

有了这个，我们将继续学习 Pandas II。

三、Pandas II

原文：Pandas II

译者：飞龙

协议：CC BY-NC-SA 4.0

学习成果

• 继续熟悉pandas语法。

• 使用条件选择从DataFrame中提取数据。

• 识别聚合有用的情况，并确定执行聚合的正确技术。

上次，我们介绍了pandas库作为处理数据的工具包。我们学习了DataFrame和Series数据结构，熟悉了操作表格数据的基本语法，并开始编写我们的第一行pandas代码。

在本讲座中，我们将开始深入了解一些高级的pandas语法。当我们逐步学习这些新的代码片段时，您可能会发现跟着自己的笔记本会很有帮助。

我们将开始加载babynames数据集。

代码

# This code pulls census data and loads it into a DataFrame
# We won't cover it explicitly in this class, but you are welcome to explore it on your own
import pandas as pd
import numpy as np
import urllib.request
import os.path
import zipfile

data_url = "https://www.ssa.gov/oact/babynames/state/namesbystate.zip"
local_filename = "data/babynamesbystate.zip"
if not os.path.exists(local_filename): # If the data exists don't download again
 with urllib.request.urlopen(data_url) as resp, open(local_filename, 'wb') as f:
 f.write(resp.read())

zf = zipfile.ZipFile(local_filename, 'r')

ca_name = 'STATE.CA.TXT'
field_names = ['State', 'Sex', 'Year', 'Name', 'Count']
with zf.open(ca_name) as fh:
 babynames = pd.read_csv(fh, header=None, names=field_names)

babynames.head()

3.1 条件选择

条件选择允许我们选择满足某些指定条件的DataFrame中的行的子集。

要了解如何使用条件选择，我们必须看一下.loc和[]方法的另一个可能的输入 - 布尔数组，它只是一个数组或Series，其中每个元素都是True或False。这个布尔数组的长度必须等于DataFrame中的行数。它将返回数组中对应True值的所有行。我们在上一堂课中从Series中执行条件提取时使用了非常类似的技术。

为了看到这一点，让我们选择我们DataFrame的前 10 行中的所有偶数索引行。

# Ask yourself: why is :9 is the correct slice to select the first 10 rows?
babynames_first_10_rows = babynames.loc[:9, :]

# Notice how we have exactly 10 elements in our boolean array argument
babynames_first_10_rows[[True, False, True, False, True, False, True, False, True, False]]

我们可以使用.loc执行类似的操作。

babynames_first_10_rows.loc[[True, False, True, False, True, False, True, False, True, False], :]

这些技术在这个例子中运行良好，但是你可以想象在更大的DataFrame中为每一行列出True和False可能会有多么乏味。为了简化事情，我们可以提供一个逻辑条件作为.loc或[]的输入，返回一个具有必要长度的布尔数组。

例如，要返回与F性别相关的所有名称：

# First, use a logical condition to generate a boolean array
logical_operator = (babynames["Sex"] == "F")

# Then, use this boolean array to filter the DataFrame
babynames[logical_operator].head()

从上一讲中回忆，.head()将只返回DataFrame中的前几行。实际上，babynames[logical operator]包含与原始babynames DataFrame中性别为"F"的条目一样多的行。

在这里，logical_operator评估为长度为 407428 的布尔值Series。

代码

print("There are a total of {} values in 'logical_operator'".format(len(logical_operator)))

There are a total of 407428 values in 'logical_operator'

从第 0 行开始到第 239536 行的行评估为True，因此在DataFrame中返回。从第 239537 行开始的行评估为False，因此在输出中被省略。

代码

print("The 0th item in this 'logical_operator' is: {}".format(logical_operator.iloc[0]))
print("The 239536th item in this 'logical_operator' is: {}".format(logical_operator.iloc[239536]))
print("The 239537th item in this 'logical_operator' is: {}".format(logical_operator.iloc[239537]))

The 0th item in this 'logical_operator' is: True
The 239536th item in this 'logical_operator' is: True
The 239537th item in this 'logical_operator' is: False

将Series作为babynames[]的参数传递与使用布尔数组具有相同的效果。实际上，[]选择运算符可以将布尔Series、数组和列表作为参数。在整个课程中，这三种方法可以互换使用。

我们也可以使用.loc来实现类似的结果。

babynames.loc[babynames["Sex"] == "F"].head()

布尔条件可以使用各种位运算符进行组合，从而可以根据多个条件过滤结果。在下表中，p 和 q 是布尔数组或Series。

当使用逻辑运算符结合多个条件时，我们用一组括号()括起每个单独的条件。这样可以对pandas评估您的逻辑施加操作顺序，并可以避免代码错误。

例如，如果我们想要返回所有性别为“F”，出生在 2000 年之前的名字数据，我们可以写成：

babynames[(babynames["Sex"] == "F") & (babynames["Year"] < 2000)].head()

如果我们想要返回所有性别为“F”或出生在 2000 年之前的所有名字数据，我们可以写成：

babynames[(babynames["Sex"] == "F") | (babynames["Year"] < 2000)].head()

布尔数组选择是一个有用的工具，但对于复杂条件可能导致代码过于冗长。在下面的示例中，我们的布尔条件足够长，以至于需要多行代码来编写。

# Note: The parentheses surrounding the code make it possible to break the code on to multiple lines for readability
(
 babynames[(babynames["Name"] == "Bella") | 
 (babynames["Name"] == "Alex") |
 (babynames["Name"] == "Ani") |
 (babynames["Name"] == "Lisa")]
).head()

幸运的是，pandas提供了许多构建布尔过滤器的替代方法。

.isin函数就是一个例子。该方法评估Series中的值是否包含在不同序列（列表、数组或Series）的值中。在下面的单元格中，我们用更简洁的代码实现了与上面的DataFrame等效的结果。

names = ["Bella", "Alex", "Narges", "Lisa"]
babynames["Name"].isin(names).head()

0    False
1    False
2    False
3    False
4    False
Name: Name, dtype: bool

babynames[babynames["Name"].isin(names)].head()

函数str.startswith可用于基于Series对象中的字符串值定义过滤器。它检查Series中的字符串值是否以特定字符开头。

# Identify whether names begin with the letter "N"
babynames["Name"].str.startswith("N").head()

0    False
1    False
2    False
3    False
4    False
Name: Name, dtype: bool

# Extracting names that begin with the letter "N"
babynames[babynames["Name"].str.startswith("N")].head()

3.2 添加、删除和修改列

在许多数据科学任务中，我们可能需要以某种方式更改DataFrame中包含的列。幸运的是，这样做的语法非常简单。

要向DataFrame添加新列，我们使用的语法与访问现有列时类似。通过写入df["column"]来指定新列的名称，然后将其分配给包含将填充此列的值的Series或数组。

# Create a Series of the length of each name. 
babyname_lengths = babynames["Name"].str.len()

# Add a column named "name_lengths" that includes the length of each name
babynames["name_lengths"] = babyname_lengths
babynames.head(5)

如果我们需要稍后修改现有列，可以通过再次引用该列的语法df["column"]，然后将其重新分配给适当长度的新Series或数组来实现。

# Modify the “name_lengths” column to be one less than its original value
babynames["name_lengths"] = babynames["name_lengths"] - 1
babynames.head()

我们可以使用.rename()方法重命名列。.rename()接受一个将旧列名映射到新列名的字典。

# Rename “name_lengths” to “Length”
babynames = babynames.rename(columns={"name_lengths":"Length"})
babynames.head()

如果我们想要删除DataFrame的列或行，我们可以调用.drop方法。使用axis参数来指定是应该删除列还是行。除非另有说明，否则pandas将默认假定我们要删除一行。

# Drop our new "Length" column from the DataFrame
babynames = babynames.drop("Length", axis="columns")
babynames.head(5)

请注意，我们重新分配了babynames到babynames.drop(...)的结果。这是一个微妙但重要的观点：pandas表操作不会发生在原地。调用df.drop(...)将输出一个删除感兴趣的行/列的副本df，而不会修改原始的df表。

换句话说，如果我们简单地调用：

# This creates a copy of `babynames` and removes the column "Name"...
babynames.drop("Name", axis="columns")

# ...but the original `babynames` is unchanged! 
# Notice that the "Name" column is still present
babynames.head(5)

3.3 实用程序函数

pandas包含大量的函数库，可以帮助缩短设置和从其数据结构中获取信息的过程。在接下来的部分中，我们将概述每个主要实用程序函数，这些函数将帮助我们在 Data 100 中使用。

讨论pandas提供的所有功能可能需要一个学期的时间！我们将带领您了解最常用的功能，并鼓励您自行探索和实验。

• NumPy和内置函数支持

• .shape

• .size

• .describe()

• .sample()

• .value_counts()

• .unique()

• .sort_values()

pandas 文档将是 Data 100 及以后的宝贵资源。

3.3.1 NumPy

pandas旨在与您在Data 8中遇到的数组计算框架NumPy良好配合。几乎任何NumPy函数都可以应用于pandas的DataFrame和Series。

# Pull out the number of babies named Yash each year
yash_count = babynames[babynames["Name"] == "Yash"]["Count"]
yash_count.head()

331824     8
334114     9
336390    11
338773    12
341387    10
Name: Count, dtype: int64

# Average number of babies named Yash each year
np.mean(yash_count)

17.142857142857142

# Max number of babies named Yash born in any one year
np.max(yash_count)

29

3.3.2 .shape 和 .size

.shape和.size是Series和DataFrame的属性，用于测量结构中存储的数据的“数量”。调用.shape返回一个元组，其中包含DataFrame或Series中存在的行数和列数。.size用于找到结构中元素的总数，相当于行数乘以列数。

许多函数严格要求参数沿着某些轴的维度匹配。调用这些维度查找函数比手动计算所有项目要快得多。

# Return the shape of the DataFrame, in the format (num_rows, num_columns)
babynames.shape

(407428, 5)

# Return the size of the DataFrame, equal to num_rows * num_columns
babynames.size

2037140

3.3.3 .describe()

如果需要从DataFrame中获取许多统计信息（最小值，最大值，平均值等），则可以使用.describe() 一次计算所有这些统计信息。

babynames.describe()

如果在Series上调用.describe()，将报告一组不同的统计信息。

babynames["Sex"].describe()

count     407428
unique         2
top            F
freq      239537
Name: Sex, dtype: object

3.3.4 .sample()

正如我们将在本学期后面看到的，随机过程是许多数据科学技术的核心（例如，训练-测试拆分，自助法和交叉验证）。.sample() 让我们快速选择随机条目（如果从DataFrame调用，则是一行，如果从Series调用，则是一个值）。

默认情况下，.sample() 选择不替换的条目。传入参数 replace=True 以进行替换采样。

# Sample a single row
babynames.sample()

当然，这可以与其他方法和运算符（iloc等）链接在一起。

# Sample 5 random rows, and select all columns after column 2
babynames.sample(5).iloc[:, 2:]

# Randomly sample 4 names from the year 2000, with replacement, and select all columns after column 2
babynames[babynames["Year"] == 2000].sample(4, replace = True).iloc[:, 2:]

3.3.5 .value_counts()

Series.value_counts() 方法计算Series中每个唯一值的出现次数。换句话说，它计算每个唯一值出现的次数。这通常对于确定Series中最常见或最不常见的条目很有用。

在下面的示例中，我们可以通过计算每个名称在babynames的"Name"列中出现的次数来确定至少有一个人在该名称下使用了最多年份的名称。请注意，返回值也是一个Series。

babynames["Name"].value_counts().head()

Jean         223
Francis      221
Guadalupe    218
Jessie       217
Marion       214
Name: Name, dtype: int64

3.3.6 .unique()

如果我们有一个具有许多重复值的Series，那么.unique() 可以用于仅识别唯一值。在这里，我们返回babynames中所有名称的数组。

babynames["Name"].unique()

array(['Mary', 'Helen', 'Dorothy', ..., 'Zae', 'Zai', 'Zayvier'],
      dtype=object)

3.3.7 .sort_values()

对DataFrame进行排序可以用于隔离极端值。例如，按降序排序的行的前 5 个条目（即从最高到最低）是最大的 5 个值。.sort_values 允许我们按指定列对DataFrame或Series进行排序。我们可以选择按升序（默认）或降序的顺序接收行。

# Sort the "Count" column from highest to lowest
babynames.sort_values(by="Count", ascending=False).head()

与在DataFrame上调用.value_counts()不同，当在Series上调用.value_counts()时，我们不需要显式指定用于排序的列。我们仍然可以指定排序范式 - 即值是按升序还是降序排序。

# Sort the "Name" Series alphabetically
babynames["Name"].sort_values(ascending=True).head()

366001      Aadan
384005      Aadan
369120      Aadan
398211    Aadarsh
370306      Aaden
Name: Name, dtype: object

3.4 自定义排序

现在让我们尝试应用我们刚刚学到的知识来解决一个排序问题，使用不同的方法。假设我们想要找到最长的婴儿名字，并相应地对我们的数据进行排序。

3.4.1 方法 1：创建一个临时列

其中一种方法是首先创建一个包含名字长度的列。

# Create a Series of the length of each name
babyname_lengths = babynames["Name"].str.len()

# Add a column named "name_lengths" that includes the length of each name
babynames["name_lengths"] = babyname_lengths
babynames.head(5)

然后，我们可以使用.sort_values()按该列对DataFrame进行排序：

# Sort by the temporary column
babynames = babynames.sort_values(by="name_lengths", ascending=False)
babynames.head(5)

最后，我们可以从babynames中删除name_length列，以防止我们的表变得混乱。

# Drop the 'name_length' column
babynames = babynames.drop("name_lengths", axis='columns')
babynames.head(5)

3.4.2 方法 2：使用key参数进行排序

另一种方法是使用.sort_values()的key参数。在这里，我们可以指定我们想要按长度对"Name"值进行排序。

babynames.sort_values("Name", key=lambda x: x.str.len(), ascending=False).head()

3.4.3 方法 3：使用map函数进行排序

我们还可以在Series上使用map函数来解决这个问题。假设我们想要按每个“名字”中的“dr”和“ea”的数量对babynames表进行排序。我们将定义函数dr_ea_count来帮助我们。

# First, define a function to count the number of times "dr" or "ea" appear in each name
def dr_ea_count(string):
 return string.count('dr') + string.count('ea')

# Then, use `map` to apply `dr_ea_count` to each name in the "Name" column
babynames["dr_ea_count"] = babynames["Name"].map(dr_ea_count)

# Sort the DataFrame by the new "dr_ea_count" column so we can see our handiwork
babynames = babynames.sort_values(by="dr_ea_count", ascending=False)
babynames.head()

我们可以在使用完dr_ea_count后删除它，以保持一个整洁的表格。

# Drop the `dr_ea_count` column
babynames = babynames.drop("dr_ea_count", axis = 'columns')
babynames.head(5)

3.5 使用.groupby聚合数据

直到这一点，我们一直在处理DataFrame的单个行。作为数据科学家，我们经常希望调查我们数据的更大子集中的趋势。例如，我们可能希望计算我们DataFrame中一组行的一些摘要统计（均值、中位数、总和等）。为此，我们将使用pandas的GroupBy对象。

假设我们想要聚合babynames中给定年份的所有行。

babynames.groupby("Year")

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x117197460>

这个奇怪的输出是什么意思？调用.groupby生成了一个GroupBy对象。你可以把它想象成一组“迷你”子数据框，其中每个子框包含与特定年份对应的babynames的所有行。

下面的图表显示了babynames的简化视图，以帮助说明这个想法。

创建一个 GroupBy 对象

我们不能直接使用GroupBy对象——这就是为什么你之前看到了奇怪的输出，而不是DataFrame的标准视图。要实际操作这些“迷你”DataFrame 中的值，我们需要调用聚合方法。这是一种告诉pandas如何聚合GroupBy对象中的值的方法。一旦应用了聚合，pandas将返回一个正常的（现在是分组的）DataFrame。

我们将考虑的第一种聚合方法是.agg。.agg方法将函数作为其参数；然后将该函数应用于“迷你”分组的每一列 DataFrame。我们最终得到一个新的DataFrame，每个子框架都有一行聚合。

babynames[["Year", "Count"]].groupby("Year").agg(sum).head(5)

我们可以将这一点与我们之前使用的图表联系起来。请记住，图表使用了“babynames”的简化版本，这就是为什么我们看到总计数的值较小。

执行聚合

调用.agg已将每个子框架压缩为单个行。这给了我们最终的输出：一个现在由“Year”索引的DataFrame，原始babynamesDataFrame 中每个唯一年份都有一行。

也许你会想："State"、"Sex"和"Name"列去哪了？从逻辑上讲，对这些列中的字符串数据进行sum是没有意义的（我们怎么将“Mary”+“Ann”相加呢？）。因此，在对DataFrame进行聚合时，我们需要省略这些列。

# Same result, but now we explicitly tell pandas to only consider the "Count" column when summing
babynames.groupby("Year")[["Count"]].agg(sum).head(5)

有许多不同的聚合可以应用于分组数据。主要要求是聚合函数必须：

• 接收一系列数据（分组子框架的单个列）。

• 返回一个聚合了这个Series的单个值。

由于这个相当广泛的要求，pandas提供了许多计算聚合的方法。

内置的 Python 操作——如sum、max和min——会被pandas自动识别。

# What is the minimum count for each name in any year?
babynames.groupby("Name")[["Count"]].agg(min).head()

# What is the largest single-year count of each name?
babynames.groupby("Name")[["Count"]].agg(max).head()

如前所述，NumPy库中的函数，如np.mean、np.max、np.min和np.sum，也是pandas中的合理选择。

# What is the average count for each name across all years?
babynames.groupby("Name")[["Count"]].agg(np.mean).head()

pandas还提供了许多内置函数。pandas本地的函数可以在调用.agg时使用它们的字符串名称进行引用。一些例子包括：

• .agg("sum")

• .agg("max")

• .agg("min")

• .agg("mean")

• .agg("first")

• .agg("last")

列表中的后两个条目——“first”和“last”——是“pandas”独有的。它们返回子框架列中的第一个或最后一个条目。为什么这可能有用呢？考虑一个情况，即组中的多个列共享相同的信息。为了在分组输出中表示这些信息，我们可以简单地获取第一个或最后一个条目，我们知道它将与所有其他条目相同。

让我们举个例子来说明这一点。假设我们向“babynames”添加一个新列，其中包含每个名字的第一个字母。

# Imagine we had an additional column, "First Letter". We'll explain this code next week
babynames["First Letter"] = babynames["Name"].str[0]

# We construct a simplified DataFrame containing just a subset of columns
babynames_new = babynames[["Name", "First Letter", "Year"]]
babynames_new.head()

如果我们为数据集中的每个名称形成分组，“首字母”将对该组的所有成员都相同。这意味着如果我们只是选择组中“首字母”的第一个条目，我们将代表该组中的所有数据。

我们可以使用字典在分组期间对每列应用不同的聚合函数。

使用“first”进行聚合

babynames_new.groupby("Name").agg({"First Letter":"first", "Year":"max"}).head()

一些聚合函数非常常见，以至于pandas允许直接调用它们，而无需显式使用.agg。

babynames.groupby("Name")[["Count"]].mean().head()

我们还可以定义自己的聚合函数！这可以使用def或lambda语句来完成。同样，自定义聚合函数的条件是它必须接受一个Series并输出单个标量值。

babynames = babynames.sort_values(by="Year", ascending=True)
def ratio_to_peak(series):
 return series.iloc[-1]/max(series)

babynames.groupby("Name")[["Year", "Count"]].agg(ratio_to_peak)

20437 行×2 列

# Alternatively, using lambda
babynames.groupby("Name")[["Year", "Count"]].agg(lambda s: s.iloc[-1]/max(s))

20437 行×2 列

3.6 结语

操纵DataFrames不是一天就能掌握的技能。由于pandas的灵活性，有许多不同的方法可以从 A 点到 B 点。我们建议尝试多种不同的方法来解决同一个问题，以获得更多的练习并更快地达到精通的水平。

接下来，我们将开始深入挖掘数据分组背后的机制。**

四、Pandas III

原文：Pandas III

译者：飞龙

协议：CC BY-NC-SA 4.0

学习成果

• 使用.groupby()执行高级聚合

• 使用pd.pivot_table方法构建一个数据透视表

• 使用pd.merge()在 DataFrame 之间执行简单的合并

上次，我们介绍了数据聚合的概念 - 我们熟悉了GroupBy对象，并将它们用作汇总和总结 DataFrame 的工具。在本讲座中，我们将探讨使用不同的聚合函数以及深入研究一些高级的.groupby方法，以展示它们在理解我们的数据方面有多么强大。我们还将介绍其他数据聚合技术，以提供在如何操作我们的表格方面的灵活性。

4.1 重新审视.agg()函数

我们将从加载babynames数据集开始。请注意，此数据集已经被过滤，只包含来自加利福尼亚州的数据。

代码

# This code pulls census data and loads it into a DataFrame
# We won't cover it explicitly in this class, but you are welcome to explore it on your own
import pandas as pd
import numpy as np
import urllib.request
import os.path
import zipfile

data_url = "https://www.ssa.gov/oact/babynames/state/namesbystate.zip"
local_filename = "data/babynamesbystate.zip"
if not os.path.exists(local_filename): # If the data exists don't download again
 with urllib.request.urlopen(data_url) as resp, open(local_filename, 'wb') as f:
 f.write(resp.read())

zf = zipfile.ZipFile(local_filename, 'r')

ca_name = 'STATE.CA.TXT'
field_names = ['State', 'Sex', 'Year', 'Name', 'Count']
with zf.open(ca_name) as fh:
 babynames = pd.read_csv(fh, header=None, names=field_names)

babynames.tail(10)

让我们首先使用.agg来找出每年出生的婴儿总数。回想一下，使用.agg和.groupby()的格式是：df.groupby(column_name).agg(aggregation_function)。下面的代码行给出了每年出生的婴儿总数。

babynames.groupby("Year")[["Count"]].agg(sum).head(5)

这里有一个过程的示例：

现在让我们深入研究groupby。正如我们在上一堂课中学到的，groupby操作涉及将 DataFrame 拆分为分组的子框架，应用函数，并组合结果的某种组合。

对于下面的任意 DataFrame df，代码df.groupby("year").agg(sum)执行以下操作：

• 将DataFrame拆分为属于同一年份的子DataFrame。

• 将sum函数应用到每个子DataFrame的每一列。

• 将sum的结果组合成一个由year索引的单个DataFrame。

4.1.1 聚合函数

可以应用许多不同的聚合函数到分组的数据上。.agg()可以接受任何将多个值聚合为一个摘要值的函数。

因为这个相当广泛的要求，pandas提供了许多计算聚合的方法。

pandas会自动识别内置的 Python 操作。例如：

• .agg(sum)

• .agg(max)

• .agg(min)

pandas中也可以使用**NumPy**函数：

• .agg(np.sum)

• .agg(np.max)

• .agg(np.min)

• .agg("mean")

pandas还提供了许多内置函数，包括：

• .agg("sum")

• .agg("max")

• .agg("min")

• .agg("mean")

• .agg("first")

• .agg("last")

一些常用的聚合函数甚至可以直接调用，而不需要显式使用.agg()。例如，我们可以在.groupby()上调用.mean()：

babynames.groupby("Year").mean().head()

现在我们可以将所有这些付诸实践。假设我们想要找出在加利福尼亚州最不受欢迎的“F”性别的婴儿名字。为了计算这个，我们可以首先创建一个指标：“峰值比”（RTP）。RTP 是 2022 年出生具有给定名字的婴儿与任何年份出生具有该名字的最大数量之比。

让我们从计算一个名为“Jennifer”的婴儿开始。

# We filter by babies with sex "F" and sort by "Year"
f_babynames = babynames[babynames["Sex"] == "F"]
f_babynames = f_babynames.sort_values(["Year"])

# Determine how many Jennifers were born in CA per year
jenn_counts_series = f_babynames[f_babynames["Name"] == "Jennifer"]["Count"]

# Determine the max number of Jennifers born in a year and the number born in 2022 
# to calculate RTP
max_jenn = max(f_babynames[f_babynames["Name"] == "Jennifer"]["Count"])
curr_jenn = f_babynames[f_babynames["Name"] == "Jennifer"]["Count"].iloc[-1]
rtp = curr_jenn / max_jenn
rtp

0.018796372629843364

通过创建一个计算 RTP 并将其应用到我们的DataFrame的函数，我们可以一次轻松计算所有名字的 RTP！

def ratio_to_peak(series):
 return series.iloc[-1] / max(series)

#Using .groupby() to apply the function
rtp_table = f_babynames.groupby("Name")[["Year", "Count"]].agg(ratio_to_peak)
rtp_table.head()

在上面显示的行中，我们可以看到每一行都有一个年值为1.0。

这是你在 Data 8 中看到的逻辑的“pandas-ification”。你在 Data 8 中学到的许多逻辑在 Data 100 中也会对你有所帮助。

4.1.2 烦人的列

请注意，你必须小心选择哪些列应用.agg()函数。如果我们尝试通过f_babynames.groupby("Name").agg(ratio_to_peak)对整个表应用我们的函数，执行.agg()调用将导致TypeError。

我们可以通过在调用.agg()之前显式选择要应用聚合函数的列来避免这个问题（并防止无意中丢失数据），

4.1.3 分组后重命名列

默认情况下，.groupby不会重命名任何聚合列。正如我们在上表中看到的，聚合列仍然被命名为Count，即使它现在代表 RTP。为了更好地可读性，我们可以将Count重命名为Count RTP

rtp_table = rtp_table.rename(columns = {"Count": "Count RTP"})
rtp_table

13782 行×2 列

4.1.4 一些数据科学回报

通过对rtp_table进行排序，我们可以看到受欢迎程度下降最多的名字。

rtp_table = rtp_table.rename(columns = {"Count": "Count RTP"})
rtp_table.sort_values("Count RTP").head()

要可视化上述Dataframe，让我们看看下面的折线图：

代码

import plotly.express as px
px.line(f_babynames[f_babynames["Name"] == "Debra"], x = "Year", y = "Count")

我们可以得到前 10 个名字的列表，然后用以下代码绘制受欢迎程度：

top10 = rtp_table.sort_values("Count RTP").head(10).index
px.line(
 f_babynames[f_babynames["Name"].isin(top10)], 
 x = "Year", 
 y = "Count", 
 color = "Name"
)

作为一个快速练习，考虑一下什么样的代码可以计算每个名字的婴儿总数。

代码

babynames.groupby("Name")[["Count"]].agg(sum).head()
# alternative solution: 
# babynames.groupby("Name")[["Count"]].sum()

现在，让我们考虑计算每年出生的婴儿总数的代码。你会看到有多种方法可以实现这一点，其中一些列在下面列出。

代码

babynames.groupby("Year")[["Count"]].agg(sum).head()
# Alternative 1
# babynames.groupby("Year")[["Count"]].sum()
# Alternative 2
# babynames.groupby("Year").sum(numeric_only=True)

对于第二种选择，注意我们如何通过向groupby传递numeric_only=True参数来避免我们之前在聚合非数字列时遇到的错误。

4.1.5 绘制出生计数

绘制Dataframe后，我们得到了一个有趣的故事。

代码

import plotly.express as px
puzzle2 = babynames.groupby("Year")[["Count"]].agg(sum)
px.line(puzzle2, y = "Count")

警告: 当我们决定使用这个数据集来估计出生率时，我们做出了一个巨大的假设。根据来自立法分析办公室的这篇文章，2020 年加利福尼亚州出生的婴儿实际数量为 421,275。然而，我们的图表显示 362,882 个婴儿 - 发生了什么？

4.2 GroupBy()，继续

我们将再次使用elections DataFrame。

代码

import pandas as pd
import numpy as np

elections = pd.read_csv("data/elections.csv")
elections.head(5)

4.2.1 原始GroupBy对象

应用于DataFrame的groupby的结果是一个DataFrameGroupBy对象，而不是一个DataFrame。

grouped_by_year = elections.groupby("Year")
type(grouped_by_year)

pandas.core.groupby.generic.DataFrameGroupBy

有几种方法可以查看DataFrameGroupBy对象：

grouped_by_party = elections.groupby("Party")
grouped_by_party.groups

{'American': [22, 126], 'American Independent': [115, 119, 124], 'Anti-Masonic': [6], 'Anti-Monopoly': [38], 'Citizens': [127], 'Communist': [89], 'Constitution': [160, 164, 172], 'Constitutional Union': [24], 'Democratic': [2, 4, 8, 10, 13, 14, 17, 20, 28, 29, 34, 37, 39, 45, 47, 52, 55, 57, 64, 70, 74, 77, 81, 83, 86, 91, 94, 97, 100, 105, 108, 111, 114, 116, 118, 123, 129, 134, 137, 140, 144, 151, 158, 162, 168, 176, 178], 'Democratic-Republican': [0, 1], 'Dixiecrat': [103], 'Farmer–Labor': [78], 'Free Soil': [15, 18], 'Green': [149, 155, 156, 165, 170, 177, 181], 'Greenback': [35], 'Independent': [121, 130, 143, 161, 167, 174], 'Liberal Republican': [31], 'Libertarian': [125, 128, 132, 138, 139, 146, 153, 159, 163, 169, 175, 180], 'National Democratic': [50], 'National Republican': [3, 5], 'National Union': [27], 'Natural Law': [148], 'New Alliance': [136], 'Northern Democratic': [26], 'Populist': [48, 61, 141], 'Progressive': [68, 82, 101, 107], 'Prohibition': [41, 44, 49, 51, 54, 59, 63, 67, 73, 75, 99], 'Reform': [150, 154], 'Republican': [21, 23, 30, 32, 33, 36, 40, 43, 46, 53, 56, 60, 65, 69, 72, 79, 80, 84, 87, 90, 96, 98, 104, 106, 109, 112, 113, 117, 120, 122, 131, 133, 135, 142, 145, 152, 157, 166, 171, 173, 179], 'Socialist': [58, 62, 66, 71, 76, 85, 88, 92, 95, 102], 'Southern Democratic': [25], 'States' Rights': [110], 'Taxpayers': [147], 'Union': [93], 'Union Labor': [42], 'Whig': [7, 9, 11, 12, 16, 19]}

grouped_by_party.get_group("Socialist")

4.2.2 其他GroupBy方法

有许多聚合方法可以使用.agg。一些有用的选项是：

• .mean：创建一个新的DataFrame，其中包含每个组的平均值

• .sum：创建一个新的DataFrame，其中包含每个组的总和

• .max和.min：创建一个新的DataFrame，其中包含每个组的最大/最小值

• .first和.last：创建一个新的DataFrame，其中包含每个组的第一行/最后一行

• .size：创建一个新的Series，其中包含每个组的条目数

• .count：创建一个新的DataFrame，其中包含条目数，不包括缺失值。

让我们通过创建一个名为df的DataFrame来举例说明一些例子。

df = pd.DataFrame({'letter':['A','A','B','C','C','C'], 
 'num':[1,2,3,4,np.NaN,4], 
 'state':[np.NaN, 'tx', 'fl', 'hi', np.NaN, 'ak']})
df

请注意.size()和.count()之间的细微差别：虽然.size()返回一个Series并计算包括缺失值在内的条目数，.count()返回一个DataFrame并计算每列中不包括缺失值的条目数。

df.groupby("letter").size()

letter
A    2
B    1
C    3
dtype: int64

df.groupby("letter").count()

您可能还记得前一个笔记中的value_counts()函数做了类似的事情。原来value_counts()和groupby.size()是一样的，只是value_counts()会自动按降序排序结果Series。

df["letter"].value_counts()

C    3
A    2
B    1
Name: letter, dtype: int64

这些（和其他）聚合函数是如此常见，以至于 pandas 允许使用简写。我们可以直接在 GroupBy 对象上调用函数，而不是明确地声明使用 .agg。

例如，以下是等价的：

• elections.groupby("Candidate").agg(mean)

• elections.groupby("Candidate").mean()

pandas 还支持许多其他方法。您可以在pandas文档中查看它们。

4.2.3 按组进行过滤

GroupBy 对象的另一个常见用途是按组过滤数据。

groupby.filter 接受一个参数 func，其中 func 是一个函数，它：

• 以 DataFrame 对象作为输入

• 返回每个子 DataFrame 的单个 True 或 False

返回对应于 True 的子 DataFrame，而具有 False 值的则不返回。重要的是，groupby.filter 与 groupby.agg 不同，因为最终的 DataFrame 中返回的是整个子 DataFrame，而不仅仅是单行。因此，groupby.filter 保留了原始索引。

为了说明这是如何发生的，让我们回到 elections 数据集。假设我们想要识别“紧张”的选举年份 - 也就是说，我们想要找到所有对应于那一年的行，其中所有候选人在那一年赢得了相似比例的总票数。具体来说，让我们找到所有对应于没有候选人赢得超过总票数 45%的年份的行。

换句话说，我们想要：

• 找到最大 % 小于 45% 的年份

• 返回对应于这些年份的所有 DataFrame 行

对于每一年，我们需要找到该年所有行中的最大 %。如果这个最大 % 小于 45%，我们将告诉 pandas 保留该年对应的所有行。

elections.groupby("Year").filter(lambda sf: sf["%"].max() < 45).head(9)

这里发生了什么？在这个例子中，我们将我们的过滤函数 func 定义为 lambda sf: sf["%"].max() < 45。这个过滤函数将在分组的子 DataFrame 中的所有条目中找到最大的 "%" 值，我们称之为 sf。如果最大值小于 45，则过滤函数将返回 True，并且该分组的所有行将出现在最终的输出 DataFrame 中。

检查上面的 DataFrame。请注意，在这个前 9 行的预览中，所有来自 1860 年和 1912 年的条目都出现了。这意味着在 1860 年和 1912 年，那一年没有候选人赢得超过总票数 45%。

你可能会问：groupby.filter 过程与我们之前看到的布尔过滤有何不同？布尔过滤在应用布尔条件时考虑单个行。例如，代码 elections[elections["%"] < 45] 将检查 elections 中每一行的 "%" 值；如果小于 45，则该行将保留在输出中。相比之下，groupby.filter 在整个组的所有行上应用布尔条件。如果该组中并非所有行都满足过滤器指定的条件，则整个组将在输出中被丢弃。

4.2.4 使用 lambda 函数进行聚合

如果我们希望使用非标准函数（例如我们自己设计的函数）对我们的DataFrame进行聚合，我们可以通过将.agg与lambda表达式结合使用来实现。

让我们首先考虑一个谜题来唤起我们的记忆。我们将尝试找到每个Party中获得最高%选票的Candidate。

一个天真的方法可能是按Party列分组并按最大值聚合。

elections.groupby("Party").agg(max).head(10)

这种方法显然是错误的-DataFrame声称伍德罗·威尔逊在 2020 年赢得了总统大选。

为什么会发生这种情况？这里，max聚合函数是独立地应用于每一列。在民主党人中，max正在计算：

• 民主党候选人竞选总统的最近年份（2020）

• 具有字母顺序“最大”名称（“伍德罗·威尔逊”）的Candidate

• 具有字母顺序“最大”结果（“赢”）的Result

相反，让我们尝试一种不同的方法。我们将：

1. 对数据框进行排序，使行按%的降序排列

2. 按Party分组并选择每个子数据框的第一行

虽然这可能看起来不直观，但按%的降序对elections进行排序非常有帮助。然后，如果我们按Party分组，每个 groupby 对象的第一行将包含有关具有最高选民%的Candidate的信息。

elections_sorted_by_percent = elections.sort_values("%", ascending=False)
elections_sorted_by_percent.head(5)

elections_sorted_by_percent.groupby("Party").agg(lambda x : x.iloc[0]).head(10)

# Equivalent to the below code
# elections_sorted_by_percent.groupby("Party").agg('first').head(10)

以下是该过程的示例：

请注意，我们的代码正确确定了来自民主党的林登·约翰逊拥有最高的选民%。

更一般地，lambda函数用于设计 Python 中未预定义的自定义聚合函数。lambda函数的输入参数x是一个GroupBy对象。因此，lambda x : x.iloc[0]选择每个 groupby 对象中的第一行应该是有意义的。

事实上，解决这个问题有几种不同的方法。每种方法在可读性、性能、内存消耗、复杂性等方面都有不同的权衡。我们在下面给出了一些示例。

注意：不需要理解这些替代解决方案。它们是为了展示pandas中众多问题解决方法的多样性。

# Using the idxmax function
best_per_party = elections.loc[elections.groupby('Party')['%'].idxmax()]
best_per_party.head(5)

# Using the .drop_duplicates function
best_per_party2 = elections.sort_values('%').drop_duplicates(['Party'], keep='last')
best_per_party2.head(5)

4.3 使用数据透视表聚合数据

我们现在知道.groupby让我们能够在 DataFrame 中对数据进行分组和聚合。上面的示例使用 DataFrame 中的一列形成了分组。通过传递一个列名的列表给.groupby，可以一次按多列进行分组。

让我们再次考虑babynames数据集。在这个问题中，我们将找到与每个年份和性别相关联的婴儿名字的总数。为此，我们将同时按"年份"和"性别"列进行分组。

babynames.head()

# Find the total number of baby names associated with each sex for each 
# year in the data
babynames.groupby(["Year", "Sex"])[["Count"]].agg(sum).head(6)

请注意，"年份"和"性别"都作为 DataFrame 的索引（它们都以粗体呈现）。我们创建了一个多索引DataFrame，其中使用两个不同的索引值，年份和性别，来唯一标识每一行。

这不是表示这些数据的最直观的方式 - 而且，因为多索引的 DataFrame 在其索引中有多个维度，它们通常很难使用。

另一种跨两列进行聚合的策略是创建一个数据透视表。你在Data 8中看到过这些。一组值用于创建数据透视表的索引；另一组用于定义列名。表中每个单元格中包含的值对应于每个索引-列对的聚合数据。

这是一个过程的示例：

理解数据透视表的最佳方法是看它的实际应用。让我们回到我们最初的目标，即对每个年份和性别组合的名字总数进行求和。我们将调用pandas的.pivot_table方法来创建一个新表。

# The `pivot_table` method is used to generate a Pandas pivot table
import numpy as np
babynames.pivot_table(
 index = "Year", 
 columns = "Sex", 
 values = "Count", 
 aggfunc = np.sum,
).head(5)

看起来好多了！现在，我们的 DataFrame 结构清晰，具有清晰的索引列组合。数据透视表中的每个条目表示给定“Year”和“Sex”组合的名称总数。

让我们更仔细地看一下上面实施的代码。

• index = "Year" 指定应用于数据透视表的原始“DataFrame”中用作索引的列名

• columns = "Sex" 指定应用于生成数据透视表的列的原始“DataFrame”中的列名

• values = "Count" 指示应用于填充每个索引列组合的条目的原始“DataFrame”中的哪些值

• aggfunc = np.sum 告诉“pandas”在聚合由“values”指定的数据时使用什么函数。在这里，我们正在对每对“Year”和“Sex”的名称计数求和

我们甚至可以在数据透视表的索引或列中包含多个值。

babynames_pivot = babynames.pivot_table(
 index="Year",     # the rows (turned into index)
 columns="Sex",    # the column values
 values=["Count", "Name"], 
 aggfunc=max,   # group operation
)
babynames_pivot.head(6)