pandas简介 🐼

  • pandas 是一个强大的 Python 库，用于数据分析和处理。
  • 它类似于电子表格程序，但功能更强大、更灵活。
  • 它建立在 NumPy 之上，NumPy 是 Python 中另一个重要的数值计算库。

pandas 标志

Note

可以把 pandas 看作是打了兴奋剂的 Excel！💪

为什么选择 pandas？🤔

  • 数据结构： 提供直观的数据结构，如 Series（一维）和 DataFrame（二维），以高效处理数据。

为什么选择 pandas？🤔 (续)

  • 数据清洗： 提供处理缺失数据、过滤和转换数据的工具。

为什么选择 pandas？🤔 (续)

  • 数据分析： 强大的分组、聚合和统计分析功能。

为什么选择 pandas？🤔 (续)

  • 集成： 与 NumPy、SciPy、scikit-learn 和 matplotlib 等其他 Python 库无缝协作。

核心概念：数据分析 🔎

数据分析是对数据进行检查、清理、转换和建模的过程，目的是发现有用信息、得出结论并支持决策。它涉及几个关键步骤：

核心概念：数据分析 🔎 (续)

  1. 数据收集： 从各种来源收集数据。
  2. 数据清理： 处理缺失值、纠正错误并确保数据一致性。
  3. 数据转换： 将数据转换为适合分析的格式（例如，缩放、规范化）。

核心概念：数据分析 🔎 (续)

  1. 数据探索： 使用描述性统计和可视化来了解数据的模式和特征。
  2. 数据建模： 应用统计或机器学习技术来提取见解或进行预测。
  3. 解释和报告： 以清晰简洁的方式传达结果。

核心概念：机器学习 🤖

机器学习是人工智能 (AI) 的一个子领域，专注于使计算机能够从数据中学习，而无需显式编程。关键概念包括：

核心概念：机器学习 🤖 (续)

  • 训练数据： 用于训练机器学习模型的数据集。
  • 特征： 数据的各个可测量属性或特征（例如，表中的列）。
  • 模型： 从训练数据中学习模式的数学表示。

核心概念：机器学习 🤖 (续)

  • 预测： 使用训练好的模型对新的、未见过的数据进行预测。
  • 监督学习： 从标记数据（已知正确输出）中学习。示例：分类、回归。
  • 无监督学习： 从未标记数据（未知正确输出）中学习。示例：聚类、降维。

核心概念：Python 🐍

Python 是一种通用的高级编程语言，以其可读性和广泛的库而闻名。数据分析的关键特性：

  • 易于学习： 清晰的语法使其对初学者友好。

核心概念：Python 🐍 (续)

  • 庞大的社区： 广泛的在线资源和支持。
  • 丰富的库生态系统： NumPy（数值计算）、pandas（数据处理）、scikit-learn（机器学习）、matplotlib/seaborn（可视化）。

核心概念：Python 🐍 (续)

  • 解释型语言： 代码逐行执行，便于测试和调试。
  • 动态类型： 无需显式声明变量类型。

导入 pandas

import pandas as pd  # 导入 pandas，并将其别名为 'pd'
import numpy as np   # 导入 NumPy，并将其别名为 'np'
  • 我们使用别名 pd 导入 pandas（标准惯例）。
  • 我们也导入 NumPy，别名为 np。 pandas 构建在 NumPy 之上。

pandas 数据结构：Series

  • Series 是一个一维带标签的数组。它类似于电子表格中的一列。
  • 它可以保存任何类型的数据（整数、浮点数、字符串等）。
  • 它有一个 索引，用于标记每个元素。
obj = pd.Series([4, 7, -5, 3]) # 从列表创建一个 Series
obj

Series：索引和值

print(obj.array)  # 访问底层数据 (PandasArray)
print(obj.index)  # 访问索引（默认为：0, 1, 2, ...）

Note

obj.array 返回数据。 obj.index 返回索引。

带有自定义索引的 Series

obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c']) # 创建一个带有自定义索引的 Series
obj2

Series：自定义索引 (续)

obj2.index # 访问自定义索引

Note

现在索引是 [‘d’, ‘b’, ‘a’, ‘c’]。我们可以使用这些索引来访问数据。

访问 Series 元素

obj2['a']  # 通过索引标签 'a' 访问元素

访问 Series 元素 (续)

obj2['d'] = 6  # 修改索引标签 'd' 处的元素

访问 Series 元素 (续)

obj2[['c', 'a', 'd']]  # 使用标签列表访问多个元素

Note

我们可以使用索引标签列表来选择子集。

过滤 Series

obj2[obj2 > 0]  # 选择大于 0 的元素（布尔索引）

过滤 Series (续)

obj2 * 2 # 将每个元素乘以 2

过滤 Series (续)

np.exp(obj2) # 逐元素应用指数函数（来自 NumPy）

Note

在这些操作期间，索引-值的链接关系会保留。

Series 作为固定长度的有序字典

'b' in obj2  # 检查 'b' 是否在索引中（类似于检查字典中的键）

Series 作为固定长度的有序字典 (续)

'e' in obj2  # 检查 'e' 是否在索引中

Note

Series 类似于字典：键是索引标签，值是数据。

从字典创建 Series

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj3 = pd.Series(sdata) # 从字典创建一个 Series
obj3

从字典创建 Series (续)

obj3.to_dict() #转换回字典

Series：处理缺失数据

states = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = pd.Series(sdata, index=states)  # 使用指定的索引创建一个 Series
obj4

Note

‘California’ 是 NaN（Not a Number）- 它在索引中，但不在 sdata 中。‘Utah’ 被排除 - 它在 sdata 中，但不在索引中。

检测缺失数据

pd.isna(obj4)  # 检查缺失值 (NaN) - 返回一个布尔 Series

检测缺失数据 (续)

pd.notna(obj4) # 检查非缺失值 - 返回一个布尔 Series

Note

isna() 和 notna() 检测缺失值。

Series：自动对齐

obj3

Series：自动对齐 (续)

obj4

Series：自动对齐 (续)

obj3 + obj4  # 将两个 Series 相加；值按索引标签对齐

Note

数据对齐是自动的。在标签不匹配的地方引入 NaN。

Series：name 属性

obj4.name = 'population'  # 设置 Series 的名称
obj4.index.name = 'state'  # 设置索引的名称
obj4

Note

Series 及其索引可以有名称。

就地更改 Series 索引

obj

就地更改 Series 索引 (续)

obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']  # 就地修改索引
obj

Note

可以通过赋值更改索引。

pandas 数据结构：DataFrame

  • DataFrame 是一个二维带标签的数据结构。类似于电子表格。
  • 有行和列。
  • 每列可以有不同的类型。
  • 有行索引和列索引。

创建 DataFrame

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data) # 从字典（值为列表）创建一个 DataFrame
frame

Note

创建 DataFrame 的常用方法：字典，其值为列表。

DataFrame：head() 和 tail()

frame.head()  # 显示前 5 行

DataFrame：head() 和 tail() (续)

frame.tail() # 显示最后 5 行

DataFrame：指定列顺序

pd.DataFrame(data, columns=['year', 'state', 'pop']) # 指定列顺序

Note

可以指定列的顺序。

DataFrame：缺失数据

frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt']) # 'debt' 是一个新列
frame2

DataFrame：缺失数据 (续)

frame2.columns  # 显示列名

Note

‘debt’ 列有缺失值 (NaN)，因为它不在原始数据中。

检索列

frame2['state']  # 检索 'state' 列（类似字典的表示法）

检索列 (续)

frame2.year  # 检索 'year' 列（类似属性的访问）

Note

两种方法都返回一个 Series。属性访问仅适用于有效的 Python 变量名（无空格等）。

检索行

frame2.loc[1]  # 按标签访问行（索引 '1'）

检索行 (续)

frame2.iloc[2]  # 按整数位置访问行（索引 2）

Note

loc 基于标签。iloc 基于整数位置。这是至关重要的区别。

修改列

frame2['debt'] = 16.5  # 将标量值赋给 'debt' 列
frame2

修改列 (续)

frame2['debt'] = np.arange(6.)  # 将 NumPy 数组赋给 'debt' 列
frame2

赋值 Series

val = pd.Series([-1.2, -1.5, -1.7], index=[2, 4, 5])  # 创建带有自定义索引的 Series
frame2['debt'] = val  # 将 Series 赋给 'debt' 列
frame2

Note

标签已对齐！val 中的值被分配给 frame2 中相应的索引。在索引不匹配的地方填充缺失值 (NaN)。

创建新列

frame2['eastern'] = frame2['state'] == 'Ohio'  # 创建一个新列 'eastern'
frame2

Note

赋值给不存在的列会创建一个新列。

删除列

del frame2['eastern']  # 删除 'eastern' 列
frame2.columns

Note

del 关键字删除列。

从嵌套字典创建 DataFrame

populations = {'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6},
               'Nevada': {2001: 2.4, 2002: 2.9}}
frame3 = pd.DataFrame(populations) # 从嵌套字典创建 DataFrame
frame3

Note

外层键成为列，内层键成为行索引。

转置 DataFrame

frame3.T  # 转置 DataFrame（交换行和列）

Note

交换行和列。

DataFrame：index.name 和 columns.name

frame3.index.name = 'year'    # 设置行索引的名称
frame3.columns.name = 'state' # 设置列索引的名称
frame3

DataFrame：to_numpy()

frame3.to_numpy()  # 将 DataFrame 转换为 NumPy 数组

Note

将数据作为二维 NumPy 数组返回。如果存在混合类型，dtype 将适应所有列，通常为 object。

索引对象

obj = pd.Series(np.arange(3), index=['a', 'b', 'c'])
index = obj.index  # 获取 Index 对象
index

索引对象 (续)

index[1:]  # 对 Index 对象进行切片（类似于列表）

Note

索引对象存储轴标签和元数据。它们是不可变的。

索引的不可变性

index[1] = 'd'  # TypeError: Index does not support mutable operations

Note

索引对象在创建后不能更改。

索引作为固定大小的集合

frame3

索引作为固定大小的集合 (续)

'Ohio' in frame3.columns  # 检查列成员资格

索引作为固定大小的集合 (续)

2003 in frame3.index  # 检查行索引成员资格

重新索引

  • reindex 创建一个新对象；数据会根据新索引进行调整。
obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
obj

重新索引 (续)

obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])  # 重新索引 Series
obj2

Note

reindex 创建新的 Series。为缺失的索引引入 NaN。

重新索引：插值的 method

obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
obj3

重新索引：插值的 method (续)

obj3.reindex(np.arange(6), method='ffill')  # 前向填充缺失值

Note

ffill（前向填充）将最后一个有效值向前传播。

使用 DataFrame 重新索引

frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
                     index=['a', 'c', 'd'],
                     columns=['Ohio', 'Texas', 'California'])
frame

使用 DataFrame 重新索引 (续)

frame2 = frame.reindex(index=['a', 'b', 'c', 'd']) # 重新索引行
frame2

Note

DataFrame 上的 reindex 可以更改行索引、列或两者。

重新索引列

states = ['Texas', 'Utah', 'California']
frame.reindex(columns=states)  # 重新索引列

删除条目

obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
obj

删除条目 (续)

new_obj = obj.drop('c')  # 删除条目 'c'（创建一个新的 Series）
new_obj

删除条目 (续)

obj.drop(['d', 'c'])  # 删除多个条目

从 DataFrame 中删除

data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                    index=['Ohio', 'Colorado', 'Utah', 'New York'],
                    columns=['one', 'two', 'three', 'four'])
data

从 DataFrame 中删除 (续)

data.drop(index=['Colorado', 'Ohio'])  # 按索引标签删除行

从 DataFrame 中删除 (续)

data.drop(columns=['two']) # 按列名删除列

从 DataFrame 中删除 (续)

data.drop('two', axis=1) # 使用 axis=1 删除列（与上述相同）

索引、选择和过滤

obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
obj

索引、选择和过滤 (续)

obj['b']  # 按标签选择

索引、选择和过滤 (续)

obj[1]  # 按整数位置选择

索引、选择和过滤 (续)

obj[2:4]  # 切片

索引、选择和过滤 (续)

obj[['b', 'a', 'd']]  # 选择多个标签

索引、选择和过滤 (续)

obj[[1, 3]]  # 选择多个整数位置

索引、选择和过滤 (续)

obj[obj < 2]  # 布尔索引

使用 loc 和 iloc 进行索引

  • loc：按标签选择。
  • iloc：按整数位置选择。
obj.loc[['b', 'a', 'd']] # 使用 loc 按标签选择

使用 loc 和 iloc 进行索引(续)

obj1 = pd.Series([1, 2, 3], index=[2, 0, 1])
obj2 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

使用 loc 和 iloc 进行索引(续)

obj1[[0,1,2]] #如果Series的索引是整数,则默认按标签选择

使用 loc 和 iloc 进行索引(续)

obj2.loc[[0, 1]] # 索引是字符串，0和1不是obj2的标签时，会出错

使用 loc 和 iloc 进行索引 (续)

obj1.iloc[[0, 1, 2]] # iloc 使用整数位置

使用 loc 和 iloc 进行索引 (续)

obj2.iloc[[0, 1, 2]] # iloc 使用整数位置

Note

使用 loc 和 iloc 可以避免歧义，尤其是在使用整数索引时。

使用标签切片（包含）

obj2.loc['b':'c']  # 包括端点 ('c')！

使用标签切片（包含）(续)

obj2.loc['b':'c'] = 5  # 使用基于标签的切片赋值
obj2

Note

使用 loc 进行标签切片包括端点。

索引到 DataFrame 中

data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                    index=['Ohio', 'Colorado', 'Utah', 'New York'],
                    columns=['one', 'two', 'three', 'four'])
data

索引到 DataFrame 中 (续)

data['two']  # 选择列 'two'

索引到 DataFrame 中 (续)

data[['three', 'one']]  # 选择多列

DataFrame：索引的特殊情况

data[:2]  # 切片行（选择第 0 行和第 1 行）

DataFrame：索引的特殊情况 (续)

data[data['three'] > 5]  # 布尔索引（选择 'three' > 5 的行）

DataFrame：布尔索引

data < 5  # 逐元素比较（返回一个布尔 DataFrame）

DataFrame：布尔索引 (续)

data[data < 5] = 0  # 将小于 5 的值设置为 0
data

使用 loc 和 iloc 在 DataFrame 上进行选择

data.loc['Colorado'] # 按标签选择一行

使用 loc 和 iloc 在 DataFrame 上进行选择 (续)

data.loc[['Colorado', 'New York']] # 按标签选择多行

使用 loc 和 iloc 在 DataFrame 上进行选择 (续)

data.loc['Colorado', ['two', 'three']]  # 按标签选择行和列

使用 loc 和 iloc 在 DataFrame 上进行选择 (续)

data.iloc[2] # 按位置选择一行

使用 loc 和 iloc 在 DataFrame 上进行选择 (续)

data.iloc[[2, 1]] # 按位置选择多行

使用 loc 和 iloc 在 DataFrame 上进行选择 (续)

data.iloc[2, [3, 0, 1]] # 按位置选择行和列

使用 loc 和 iloc 在 DataFrame 上进行选择 (续)

data.iloc[[1, 2], [3, 0, 1]] # 按位置选择行和列

算术和数据对齐

  • 执行算术运算时，数据按索引标签对齐。
  • 在标签不重叠的地方使用 NaN。
s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])
s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1], index=['a', 'c', 'e', 'f', 'g'])

算术和数据对齐 (续)

s1
s2

算术和数据对齐 (续)

s1 + s2  # Series 相加；按索引标签对齐

DataFrame 的算术运算

df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),
                   index=['Ohio', 'Texas', 'Colorado'])
df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
                   index=['Utah', 'Ohio', 'Texas', 'Oregon'])

DataFrame 的算术运算 (续)

df1

DataFrame 的算术运算 (续)

df2

DataFrame 的算术运算 (续)

df1 + df2  # DataFrame 相加；按行和列标签对齐

具有填充值的算术方法

df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)),
                   columns=list('abcd'))
df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)),
                   columns=list('abcde'))
df2.loc[1, 'b'] = np.nan  # 引入一个缺失值

具有填充值的算术方法 (续)

df1

具有填充值的算术方法 (续)

df2

具有填充值的算术方法 (续)

df1 + df2  # 相加，可能产生 NaN

Note

NaN 表示缺失值。

使用 add 和 fill_value

df1.add(df2, fill_value=0)  # 相加，在相加*之前*用 0 填充缺失值

Note

fill_value 在运算之前替换缺失值。

灵活的算术方法

方法 描述
add, radd 加法 (+)
sub, rsub 减法 (-)
div, rdiv 除法 (/)
mul, rmul 乘法 (*)

Note

r 方法：反转参数（例如，1 / df1 等价于 df1.rdiv(1)）。

DataFrame 和 Series 之间的运算

frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
                     columns=list('bde'),
                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series = frame.iloc[0] # 获取第一行

DataFrame 和 Series 之间的运算 (续)

frame

DataFrame 和 Series 之间的运算 (续)

series

DataFrame 和 Series 之间的运算 (续)

frame - series  # 从 DataFrame 中减去 Series（广播）

Note

DataFrame 和 Series 之间的算术运算默认沿行广播。

跨列广播

series3 = frame['d']  # 获取 'd' 列
series3

跨列广播 (续)

frame.sub(series3, axis='index')  # 匹配索引（行），跨列广播

Note

axis='index'（或 axis=0）跨列广播。

函数应用和映射

frame = pd.DataFrame(np.random.standard_normal((4, 3)),
                     columns=list('bde'),
                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])
frame

函数应用和映射 (续)

np.abs(frame)  # 逐元素应用 NumPy 的绝对值函数 (ufunc)

使用 apply 应用函数

def f1(x):
    return x.max() - x.min() # 定义一个对 Series 进行操作的函数

frame.apply(f1)  # 沿列应用函数（默认轴是 'index'）

使用 apply 应用函数 (续)

frame.apply(f1, axis='columns')  # 沿行应用函数 (axis='columns')

应用返回 Series 的函数

def f2(x):
    # 定义一个返回带有 'min' 和 'max' 的 Series 的函数
    return pd.Series([x.min(), x.max()], index=['min', 'max'])

frame.apply(f2)

使用 applymap 进行逐元素格式化

def my_format(x):
    return f"{x:.2f}"  # 定义一个格式化函数

frame.applymap(my_format) # 对 DataFrame 逐元素应用

Note

applymap 用于 DataFrame 的逐元素操作；map 用于 Series 的逐元素操作。

排序

obj = pd.Series(np.arange(4), index=['d', 'a', 'b', 'c'])
obj.sort_index()  # 按索引标签排序

排序 (续)

frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
                     index=['three', 'one'],
                     columns=['d', 'a', 'b', 'c'])
frame.sort_index() # 按行索引排序

排序 (续)

frame.sort_index(axis='columns') # 按列索引排序

排序 (续)

frame.sort_index(axis='columns', ascending=False) # 降序排序

按值排序

obj = pd.Series([4, 7, -3, 2])
obj.sort_values()  # 按值排序

按值排序 (续)

obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
obj.sort_values()  # 缺失值 (NaN) 默认排序到末尾

按列对 DataFrame 排序

frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
frame

按列对 DataFrame 排序 (续)

frame.sort_values('b')  # 按 'b' 列排序

按列对 DataFrame 排序 (续)

frame.sort_values(['a', 'b'])  # 按多列排序（先 'a'，再 'b'）

排名

obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
obj.rank()  # 分配排名（平局使用平均排名）

Note

排名：分配从 1 到有效数据点数量的排名。

排名方法

方法 描述
average 默认：平局使用平均排名
min 使用最小排名
max 使用最大排名
first 按值出现的顺序排名

具有重复标签的轴索引

obj = pd.Series(np.arange(5), index=['a', 'a', 'b', 'b', 'c'])
obj

具有重复标签的轴索引 (续)

obj.index.is_unique  # 检查索引标签是否唯一

具有重复标签的轴索引 (续)

obj['a']  # 返回一个 Series（因为 'a' 重复）

具有重复标签的轴索引 (续)

obj['c']  # 返回一个标量（因为 'c' 唯一）

汇总和计算描述性统计

df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
                   [np.nan, np.nan], [0.75, -1.3]],
                  index=['a', 'b', 'c', 'd'],
                  columns=['one', 'two'])
df

汇总和计算描述性统计 (续)

df.sum()  # 计算列总和

汇总和计算描述性统计 (续)

df.sum(axis='columns')  # 计算行总和

处理归约中的缺失值

df.sum(axis='index', skipna=False) # 在计算中包含 NaN

处理归约中的缺失值 (续)

df.mean(axis='columns') # 计算平均值，排除 NaN（默认）

描述性统计：归约方法的选项

方法 描述
axis 轴 (‘index’ 表示行, ‘columns’ 表示列)
skipna 排除缺失值 (默认为 True)

间接统计

df.idxmax()  # 最大值的索引标签（对于每列）

间接统计 (续)

df.cumsum()  # 累积和（对于每列）

describe() 方法

df.describe()  # 生成描述性统计

describe() 方法 (续)

obj = pd.Series(['a', 'a', 'b', 'c'] * 4)
obj.describe() # 非数值数据的描述性统计

描述性和汇总统计

方法 描述
count 非 NA 值的数量
describe 计算一组汇总统计
min, max 计算最小值和最大值
idxmin, idxmax 计算达到最小值/最大值的索引标签
quantile 计算样本分位数 (0 到 1)
sum 求和
mean 平均值
median 中位数 (50% 分位数)
… …

相关性和协方差

首先加载数据

price = pd.read_pickle('examples/yahoo_price.pkl')
volume = pd.read_pickle('examples/yahoo_volume.pkl')

相关性和协方差 (续)

returns = price.pct_change() # 变化百分比
returns.tail()

相关性和协方差 (续)

returns['MSFT'].corr(returns['IBM']) # MSFT 和 IBM 收益率之间的相关性

相关性和协方差 (续)

returns['MSFT'].cov(returns['IBM'])  # MSFT 和 IBM 收益率之间的协方差

Note

corr：相关性。cov：协方差。

DataFrame 上的 corr 和 cov

returns.corr()  # 相关矩阵

corr 和 cov on DataFrame (续)

returns.cov()  # 协方差矩阵

corrwith 方法

returns.corrwith(returns['IBM'])  # 与 IBM 收益率的成对相关性

corrwith 方法 (续)

returns.corrwith(volume)  # 与成交量的成对相关性

Note

计算成对相关性。

唯一值、值计数和成员资格

obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
uniques = obj.unique()  # 获取唯一值
uniques

唯一值、值计数和成员资格 (续)

obj.value_counts()  # 计算每个值的出现次数

唯一值、值计数和成员资格 (续)

pd.value_counts(obj.to_numpy(), sort=False) #使用pd.value_counts()

isin 方法

obj

isin 方法(续)

mask = obj.isin(['b', 'c'])  # 检查是否属于 ['b', 'c']
mask

isin 方法 (续)

obj[mask]  # 选择 mask 为 True 的元素

Note

isin：检查成员资格。

总结

  • 我们学习了 pandas 的基础数据结构：Series 和 DataFrame。
  • 掌握了关键操作：索引、选择、过滤、算术运算、函数应用、排序、排名以及描述性统计。
  • 了解了如何处理缺失数据。

思考与讨论

  • 对比 pandas 和其他数据分析工具 (例如 Excel, R)，各自的优势和劣势是什么？
  • 在实际工作中，有哪些 pandas 的应用场景？
  • pandas 有哪些局限性？ 在什么情况下应该选择其他工具？
  • 数据对齐和广播在 pandas 中为何如此重要？