pandas (opens new window) is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool, built on top of the Python programming language.

常用 API

导入数据

• pd.read_csv(filename, sep=',', encoding='utf-8', header=0, index_col=None): 从 CSV 文件导入数据，可指定分隔符、编码、表头行和索引列
• pd.read_table(filename, sep='\t', encoding='utf-8', header=0): 从限定分隔符的文本文件导入数据
• pd.read_excel(filename, sheet_name=0, header=0, index_col=None): 从 Excel 文件导入数据，可指定sheet名、表头行和索引列
• pd.read_sql(query, connection_object, index_col=None): 从 SQL 表/库导入数据，可指定索引列
• pd.read_json(json_string, orient='records'): 从 JSON 格式的字符串导入数据，可指定数据方向
• pd.read_html(url, header=0, index_col=0): 解析 URL、字符串或者 HTML 文件，抽取其中的 tables 表格，可指定表头和索引
• pd.read_clipboard(): 从你的粘贴板获取内容，并传给 read_table()
• pd.DataFrame(dict): 从字典对象导入数据，Key 是列名，Value 是数据

导出数据

• df.to_csv(filename, sep=',', encoding='utf-8', index=True): 导出数据到 CSV 文件，可指定分隔符、编码和是否包含索引
• df.to_excel(filename, sheet_name='Sheet1', index=True): 导出数据到 Excel 文件，可指定sheet名和是否包含索引
• df.to_sql(name, con, if_exists='fail', index=True): 导出数据到 SQL 表，可指定表名、连接和是否包含索引
• df.to_json(filename, orient='records'): 以 Json 格式导出数据到文本文件，可指定数据方向

创建测试对象

• pd.DataFrame(np.random.rand(20,5)): 创建 20 行 5 列的随机数组成的 DataFrame 对象
• pd.Series(my_list): 从可迭代对象 my_list 创建一个 Series 对象
• df.index = pd.date_range('1900/1/30', periods=df.shape[0]): 增加一个日期索引
• np.random.randn(5, 5): 生成一个形状为 (5, 5) 的 NumPy 数组，其中的值是从标准正态分布(均值为 0，标准差为 1)中随机抽取的
• np.random.rand(10, 2) * 5: 首先生成一个形状为 (10, 2) 的随机数组，其中的值在 0 到 1 之间，然后将所有值乘以 5

查看、检查数据

• df.head(n): 查看 DataFrame 对象的前 n 行
• df.tail(n): 查看 DataFrame 对象的最后 n 行
• df.shape: 查看行数和列数
• df.info(): 查看索引、数据类型和内存信息
• df.describe(): 查看数值型列的汇总统计
• s.value_counts(dropna=False): 查看 Series 对象的唯一值和计数
• df.apply(pd.Series.value_counts): 查看 DataFrame 对象中每一列的唯一值和计数

数据选取

• df[col]: 根据列名，并以 Series 的形式返回列

• df[[col1, col2]]: 以 DataFrame 形式返回多列

• 基于标签的索引 (loc)

  • df.loc[行标签, 列标签]: 基于标签的索引
  • df.loc['row1', 'col1']: 选择特定行和列
  • df.loc['row1':'row2', 'col1':'col2']: 选择行和列的范围
  • df.loc[df['col1'] > 0, ['col1', 'col2']]: 条件选择
  • df.loc[df['col1'].between(1, 10)]: 选择 col1 列中值在 1 到 10 之间的行
  • df.loc[df['col1'].between(1, 10, inclusive='left')]: 选择 col1 列中值在 [1, 10) 之间的行
  • df.loc[df['col1'].between(1, 10, inclusive='right')]: 选择 col1 列中值在 (1, 10] 之间的行
  • df.loc[df['col1'].between(1, 10, inclusive='neither')]: 选择 col1 列中值在 (1, 10) 之间的行

• 基于位置的索引 (iloc)

  • df.iloc[行位置, 列位置]: 基于位置的索引
  • df.iloc[0:5, 0:2]: 选择前5行和前2列
  • df.iloc[[0,2,4], [0,1]]: 选择特定行和列
  • df.iloc[0,:]: 返回第一行
  • df.iloc[0,0]: 返回第一列的第一个元素
  • df.iloc[:, :2]: 返回前两列数据
  • df.iloc[:, lambda df: [0, 1]]

• 快速访问

  • df.at[行标签, 列标签]: 快速访问单个值
  • df.iat[行位置, 列位置]: 基于位置的快速访问

• 其他选择方法

  • df.values[:,:-1]: 返回除了最后一列的其他列的所有数据
  • df.query('[1, 2] not in c'): 返回 c 列中不包含 1, 2 的其他数据集
  • df[df['col1'].between(1, 10)]: 使用 between 方法直接过滤
  • df.query('1 <= col1 <= 10'): 使用 query 方法进行范围过滤

数据清理

• df.columns = ['a','b','c']: 重命名列名
• pd.isnull(): 检查 DataFrame 对象中的空值，并返回一个 Boolean 数组
• pd.notnull(): 检查 DataFrame 对象中的非空值，并返回一个 Boolean 数组
• df.dropna(how='any', thresh=None, subset=None): 删除缺失值，可指定删除方式、阈值和子集
• df.dropna(axis=1): 删除所有包含空值的列
• df.dropna(axis=1,thresh=n): 删除所有小于 n 个非空值的行
• df.fillna(value=None, method=None, limit=None): 填充缺失值，可指定填充值、方法和限制
• s.astype(float): 将 Series 中的数据类型更改为 float 类型
• s.replace(1,'one'): 用'one'代替所有等于 1 的值
• s.replace([1,3],['one','three']): 用'one'代替 1，用'three'代替 3
• df.rename(columns=lambda x: x + 1): 批量更改列名
• df.rename(columns={'old_name': 'new_name'}): 选择性更改列名
• df.set_index('column_one'): 更改索引列
• df.rename(index=lambda x: x + 1): 批量重命名索引
• df.duplicated(subset=None, keep='first'): 检查重复行
• df.drop_duplicates(subset=None, keep='first'): 删除重复行

数据处理

• Filter、Sort 和 GroupBy

  • df[df[col] > 0.5]: 选择 col 列的值大于 0.5 的行
  • df.sort_values(col1): 按照列 col1 排序数据，默认升序排列
  • df.sort_values(col2, ascending=False): 按照列 col1 降序排列数据
  • df.sort_values([col1,col2], ascending=[True,False]): 先按列 col1 升序排列，后按 col2 降序排列数据
  • df.groupby(by=None, axis=0, level=None, as_index=True): 分组操作，可指定分组键、轴、级别和是否使用索引
  • df.groupby([col1,col2]): 返回一个按多列进行分组的 Groupby 对象
  • df.groupby(col1)[col2]: 返回按列 col1 进行分组后，列 col2 的均值
  • df.groupby(col1).agg({'col2': ['mean', 'sum'], 'col3': 'max'}): 对分组后的数据进行聚合操作
  • df.groupby(col1).transform(lambda x: x - x.mean()): 对分组后的数据进行转换
  • df.groupby(col1).filter(lambda x: x['col2'].mean() > 0): 对分组后的数据进行过滤
  • df.pivot_table(values=None, index=None, columns=None, aggfunc='mean'): 创建数据透视表，可指定值、索引、列和聚合函数
  • df.eval: 用于在 DataFrame 上执行表达式的方法，这些表达式通常包含 DataFrame 的列
  • data.apply(np.mean): 对 DataFrame 中的每一列应用函数 np.mean
  • data.apply(np.max,axis=1): 对 DataFrame 中的每一行应用函数 np.max

• 数据合并

  • pd.concat([df1, df2], axis=0, join='outer', ignore_index=False): 连接多个DataFrame，可指定轴、连接方式和是否忽略索引
  • pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None): 合并DataFrame，支持多种连接方式
  • df1.join(df2,on=col1,how='inner'): 对 df1 的列和 df2 的列执行 SQL 形式的 join

数据统计

• df.describe(): 查看数据值列的汇总统计
• df.mean(): 返回所有列的均值
• df.median(): 返回所有列的中位数
• df.quantile(q=0.5, axis=0): 计算分位数
• df.mode(axis=0): 计算众数
• df.corr(): 返回列与列之间的相关系数
• df.cov(): 计算协方差矩阵
• df.count(): 返回每一列中的非空值的个数
• df.max(): 返回每一列的最大值
• df.min(): 返回每一列的最小值
• df.std(): 返回每一列的标准差
• df.skew(axis=0): 计算偏度
• df.kurt(axis=0): 计算峰度
• (df[xx] > 0).sum(): 返回 xx 大于 0 的个数

时间序列处理

• pd.to_datetime(arg, format=None): 转换为日期时间格式
• df.resample(rule='D', how=None): 重采样
• df.rolling(window=3, min_periods=1): 滚动窗口计算
• df.expanding(min_periods=1): 扩展窗口计算
• df.shift(periods=1): 数据移动

api

merge

pandas 库提供了多个用于合并数据的 API, 其中最常用的是 merge 函数。merge 函数用于将两个或多个 DataFrame 对象按照一个或多个键(共同的列)进行合并。以下是 merge 函数的基本用法和一些关键参数:

result = pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False)

• left: 要合并的左侧 DataFrame
• right: 要合并的右侧 DataFrame
• how: 指定如何合并。常见选项包括:
  • 'inner'(默认值): 取两个 DataFrame 的交集, 只保留两者都有的键
  • 'outer': 取两个 DataFrame 的并集, 保留所有键, 缺失的数据用 NaN 填充
  • 'left': 以左侧 DataFrame 的键为基准, 保留所有左侧键
  • 'right': 以右侧 DataFrame 的键为基准, 保留所有右侧键
• on: 指定用于合并的列名(键)。可以是单个列名的字符串, 也可以是多个列名组成的列表
• left_on: 指定左侧 DataFrame 用于合并的列名(键)
• right_on: 指定右侧 DataFrame 用于合并的列名(键)
• left_index 和 right_index: 如果为 True, 表示使用左侧或右侧 DataFrame 的索引作为合并键
• sort: 如果为 True, 则合并后的结果将按合并键排序

expanding

S.expanding() 作用及使用场景

S.expanding() 是 Pandas Series 和 DataFrame 对象的一个方法, 用于创建一个展开窗口。展开窗口是一个类似滑动窗口的概念, 但不会移动, 它从序列的开始一直扩展到当前位置。展开窗口对于计算累积、移动平均或其他累积性的统计量非常有用

使用场景:

• 累积统计: 展开窗口可以用来计算累积统计量, 如累积和、累积平均、累积方差等
• 滚动平均: 如果你需要计算移动平均值, 但不需要滑动窗口, 你可以使用展开窗口
• 分析时间序列数据: 在时间序列数据分析中, 展开窗口通常用于计算累积收益、累积收益率等

以下是一个示例, 演示如何使用 S.expanding()来计算累积和:

import pandas as pd

# 创建一个示例 Series
S = pd.Series([1, 2, 3, 4, 5])

# 使用 expanding() 计算累积和,计算过程详解
#   在位置 0, 展开窗口包括值 [1], 所以累积和是 1
#   在位置 1, 展开窗口包括值 [1, 2], 所以累积和是 1 + 2 = 3
#   在位置 2, 展开窗口包括值 [1, 2, 3], 所以累积和是 1 + 2 + 3 = 6
#   在位置 3, 展开窗口包括值 [1, 2, 3, 4], 所以累积和是 1 + 2 + 3 + 4 = 10
#   在位置 4, 展开窗口包括值 [1, 2, 3, 4, 5], 所以累积和是 1 + 2 + 3 + 4 + 5 = 15
cumulative_sum = S.expanding().sum()

print(cumulative_sum)

以上代码将生成一个包含累积和的新 Series, 其中每个元素都是原始 Series 中对应位置及之前所有元素的累积和。这对于分析和可视化时间序列数据以及执行累积性计算非常有用

stack

pandas 中的 DataFrame 对象提供了 stack() 方法, 用于将数据从列堆叠到行, 从而创建一个具有多级索引的新 Series 对象。这个方法通常在数据透视和重塑操作中非常有用

举例说明: 原始数据为如下的 df, 通过 stack 的内容变化展示

原始 <class 'pandas.core.frame.DataFrame'>:
    A       B
  one two one two
X   1   4   7  10
Y   2   5   8  11
Z   3   6   9  12

堆叠后的 <class 'pandas.core.frame.DataFrame'>:
       A   B
X one  1   7
  two  4  10
Y one  2   8
  two  5  11
Z one  3   9
  two  6  12

堆叠后的[2] <class 'pandas.core.series.Series'>:
X  one  A     1
        B     7
   two  A     4
        B    10
Y  one  A     2
        B     8
   two  A     5
        B    11
Z  one  A     3
        B     9
   two  A     6
        B    12
dtype: int64

unstack

unstack 是 Pandas 中用于数据透视的函数之一, 它用于将堆叠的数据重新排列为未堆叠的形式, 通常用于将多层索引的数据逆转。以下是 unstack 函数的一些常见用法和示例:

**语法: **

DataFrame.unstack(level=-1, fill_value=None)

• level: 可选参数, 指定要取消堆叠的索引级别。默认是取消最内层(level=-1)的堆叠
• fill_value: 可选参数, 用于替换缺失值(NaN)的值

**示例: ** 假设有一个多层索引的 DataFrame:

import pandas as pd

data = {
    ('A', 'one'): [1, 2, 3],
    ('A', 'two'): [4, 5, 6],
    ('B', 'one'): [7, 8, 9],
    ('B', 'two'): [10, 11, 12],
}

df = pd.DataFrame(data, index=['X', 'Y', 'Z'])

• **基本使用: ** 默认情况下, unstack 会取消堆叠最内层的索引:

  unstacked = df.unstack()
  

• **指定取消堆叠的级别: ** 您可以通过指定 level 参数来取消堆叠特定级别的索引。例如, 要取消堆叠第一级别的索引:

  unstacked = df.unstack(level=0)
  

• **处理缺失值: ** 如果在取消堆叠后出现缺失值, 您可以使用 fill_value 参数来指定要填充的值。例如, 使用 0 来填充缺失值:

  unstacked = df.unstack(fill_value=0)
  

unstack 的逆操作是 stack, 它可以将未堆叠的数据重新堆叠成多层索引的形式。这两个函数通常用于数据重塑和透视操作, 以便更方便地进行数据分析和处理

melt

melt 函数是pandas中用于数据重塑的重要函数，其作用是将DataFrame从宽格式(wide format)转换为长格式(long format)。这种转换在数据分析和可视化中非常有用，特别是在需要比较多个变量或绘制多变量关系图时。

基本语法

pd.melt(
    frame,              # 要转换的DataFrame
    id_vars=None,       # 保持不变的列（标识列）
    value_vars=None,    # 要转换为长格式的列
    var_name='variable',# 存储原列名的列名
    value_name='value', # 存储值的列名
    col_level=None      # 如果列是多级索引，指定要使用的级别
)

示例1：基本用法

示例链接 (opens new window)

示例2：多级索引

# 创建具有多级列索引的DataFrame
df = pd.DataFrame({
    ('A', 'x'): [1, 2, 3],
    ('A', 'y'): [4, 5, 6],
    ('B', 'x'): [7, 8, 9],
    ('B', 'y'): [10, 11, 12]
})

# 使用melt转换，指定列级别
melted = df.melt(col_level=0)  # 使用第一级列索引

主要应用场景

1. 数据可视化：

   • 当需要绘制多个变量的对比图时
   • 当需要创建分组箱线图或小提琴图时
   • 当需要绘制多变量时间序列图时

2. 数据分析：

   • 当需要按变量类型进行分组分析时
   • 当需要计算多个变量的统计量时
   • 当需要创建数据透视表时

3. 数据清洗：

   • 当需要统一处理多个相似列时
   • 当需要将多个测量值合并为一个变量时
   • 当需要处理重复的列名时

注意事项

1. 性能考虑：

   • 对于大型数据集，melt操作可能会消耗较多内存
   • 建议在转换前先进行必要的数据筛选

2. 数据完整性：

   • 确保id_vars中的列能够唯一标识每一行
   • 注意处理缺失值（NaN）的情况

3. 列名处理：

   • 如果原数据列名包含特殊字符，转换后可能会需要额外处理
   • 考虑使用有意义的var_name和value_name

与其他函数的配合

melt函数经常与其他pandas函数配合使用：

# 示例：melt后接groupby和unstack
melted = df.melt(id_vars='config', value_vars=['onLegoPopViewPreLoad', 'xxx', 'yy', 'pid'])
mean = melted.groupby(['config', 'variable'])['value'].mean()
result = mean.unstack()  # 转回宽格式

这种组合使用可以实现复杂的数据重塑和分析任务。

pivot

pivot 在 Pandas 中是一个数据重塑（reshape）操作，它可以将数据从长格式（long format）转换为宽格式（wide format）。这个过程就像是在做数据透视表，将数据按照不同的维度重新组织。 示例链接 (opens new window)

1. pivot 和 pivot_table 的主要区别：

   • pivot：
     • 只能处理唯一索引的数据
     • 不支持聚合操作
     • 当数据有重复时会报错
     • 适合简单的数据转换
   • pivot_table：
     • 可以处理重复索引的数据
     • 支持聚合操作（aggfunc参数）
     • 更灵活，功能更强大
     • 适合复杂的数据分析

2. 使用场景对比：

   # 使用pivot（数据无重复）
   df_pivot = df.pivot(index='Product', columns='Month', values='Sales')
   
   # 使用pivot_table（数据有重复，需要聚合）
   df_pivot_table = df.pivot_table(
       index='Product', 
       columns='Month', 
       values='Sales',
       aggfunc='sum'  # 可以指定聚合函数
   )
   

3. 补充 pivot_table 的重要参数：

   • index：行索引，可以是单个列名或列名列表
   • columns：列索引，可以是单个列名或列名列表
   • values：要聚合的值，可以是单个列名或列名列表
   • aggfunc：聚合函数，可以是：
     • 字符串：'sum', 'mean', 'count', 'min', 'max'等
     • 函数：np.sum, np.mean等
     • 字典：对不同列使用不同的聚合函数
     • 列表：对同一列使用多个聚合函数
   • fill_value：用于替换缺失值的值
   • margins：是否添加总计行/列
   • margins_name：总计行/列的名称

4. 实际应用示例：

   # 多级索引的透视表
   df_pivot = df.pivot_table(
       index=['Product', 'Category'],
       columns='Month',
       values='Sales',
       aggfunc={'Sales': ['sum', 'mean']},
       fill_value=0,
       margins=True,
       margins_name='Total'
   )
   

5. 常见问题和解决方案：

   • 处理重复数据：使用 pivot_table 并指定合适的聚合函数
   • 处理缺失值：使用 fill_value 参数
   • 性能优化：对于大数据集，考虑使用 groupby 后再进行透视
   • 多维度分析：使用多级索引和多个聚合函数

6. 与其他函数的对比：

   • groupby：更灵活但结果格式不同
   • crosstab：专门用于计算频率表
   • melt：pivot 的反向操作，将宽格式转换为长格式

other

wide format

"wide format"(宽格式)是一种数据排列格式, 其中每个变量通常以列的形式表示, 每一行则表示一个观察结果。在宽格式中, 数据通常会占据更多的列, 而行数相对较少。这种格式通常用于数据的录入、查看和简单的统计汇总。longandwide (opens new window)

• 举个例子, 假设你有一个包含学生考试成绩的数据集, 其中每个学生有多个科目的成绩。在宽格式中, 数据可能如下所示: :

学生	科目 1	科目 2	科目 3
A	90	85	78
B	88	92	75
C	76	89	82

• 在上面的示例中, 每个学生的成绩分布在不同的列中, 每一列代表一个科目。这是宽格式的典型示例。:

• 宽格式通常适合于人工录入和查看, 但在某些情况下, 特别是在数据分析和可视化方面, 更适合使用:"long format"(长格式), 其中数据的排列更具灵活性, 以便进行更多类型的操作和分析。例如, 长格式数据通常更容易用于绘制多变量关系图、进行数据透视表操作以及进行各种数据分析任务

long format

"Long format"(长格式)是一种数据排列格式, 其中每个变量和其对应的值通常以行的形式表示, 而每一列表示不同的属性。在长格式中, 数据通常会占据更多的行, 而列数相对较多。这种格式通常更适合用于数据分析、可视化和处理多变量数据。longandwide (opens new window)

• 举个例子, 假设你有一个包含学生考试成绩的数据集, 其中每个学生有多个科目的成绩。在长格式中, 数据可能如下所示: :

学生	科目	成绩
A	科目 1	90
A	科目 2	85
A	科目 3	78
B	科目 1	88
B	科目 2	92
B	科目 3	75
C	科目 1	76
C	科目 2	89
C	科目 3	82

• 在上面的示例中, 每一行表示一个学生的成绩, 包括学生的姓名、所修科目和相应的成绩。这是长格式的典型示例。:

• 长格式通常更适合在数据分析、数据透视表、多变量关系图和其他复杂数据处理任务中使用。它提供了更大的灵活性, 可以更容易地进行多变量分析和数据操作。长格式也更容易与多种数据分析工具和库兼容。:

颜色映射

颜色映射是数据可视化中常用的工具, 它将数值范围映射到不同的颜色, 以帮助观察者理解数据的分布和趋势

Matplotlib(一个常用的 Python 数据可视化库)提供了众多内置的颜色映射, 以满足不同数据可视化需求。以下是一些常见的颜色映射名称:

• "viridis"
• "plasma"
• "inferno"
• "magma"
• "cividis"
• "gray"
• "bone"
• "hot"
• "cool"
• "Wistia"
• "autumn"
• "winter"
• "spring"
• "summer"
• "seismic"
• "YlGnBu"
• "YlOrRd"
• "RdYlBu"
• "RdYlGn"
• "coolwarm"

这只是其中一小部分, Matplotlib 中提供了更多的颜色映射供选择。你可以根据数据的性质和可视化需求选择适当的颜色映射。要查看 Matplotlib 中可用的所有颜色映射, 你可以访问官方文档或使用如下代码:

import matplotlib.pyplot as plt

cmaps = plt.colormaps()
print(cmaps)

这将打印出 Matplotlib 中可用的所有颜色映射名称列表。不同的颜色映射在颜色梯度和视觉效果上有所不同, 因此你可以根据你的数据和审美需求选择合适的颜色映射

%timeit魔法命令

%timeit df.apply(lambda x: integrate_f(x["a"], x["b"], x["N"]), axis=1)
116 ms +- 5.56 ms per loop (mean +- std. dev. of 7 runs, 10 loops each)

%timeit 是一个用于在 Jupyter Notebook 中测试代码性能的魔法命令。在你的示例中, 你正在测试一个 DataFrame 上的 apply 函数, 该函数使用一个 lambda 函数来对 DataFrame 的每一行执行一个操作。在这种情况下, 你测试了对 DataFrame 的每一行应用 integrate_f 函数, 其中 integrate_f 函数需要每一行的 "a," "b," 和 "N" 列作为输入参数

%timeit 命令返回一些性能测量信息, 包括:

• 执行这行代码的平均时间(mean)
• 执行这行代码的标准差(std. dev.)
• 总共运行的次数(7 runs)
• 循环的次数(10 loops each)

在你的示例中, 你的代码平均需要 116 毫秒执行一次, 并且标准差约为 5.56 毫秒。这是通过多次执行代码并计算平均值和标准差得出的结果。你的代码在 7 次运行中平均需要 116 毫秒

%timeit 很有用, 因为它可以帮助你比较不同方法的性能, 找出哪种方法更有效

pyarrow

PyArrow(Apache Arrow 的 Python 实现)在 Pandas 中的角色是提供了一种高效的数据格式和数据交换方法, 以便在 Pandas 和其他数据处理工具之间进行数据交互。它主要发挥以下作用:

• 高性能数据交换: PyArrow 提供了一个内存布局, 可以在 Pandas 和其他支持 Arrow 的数据处理工具之间进行高效的数据交换, 而无需复制或数据转换。这提高了数据处理速度, 特别是在大数据集的情况下

• Columnar 数据结构: Arrow 的数据结构是列式的(columnar), 这与 Pandas 的数据帧(DataFrame)非常相似。这种列式存储结构在分析大数据集时非常高效, 因为它可以有效地进行压缩、并行处理和查询

• 跨平台和跨语言支持: PyArrow 的 Arrow 数据格式是一种跨平台和跨语言的数据交换格式。这意味着你可以在不同编程语言之间轻松共享和交换数据, 包括 Python、C++、Java、R 等

• 文件格式: Arrow 还定义了一种列式文件格式(Arrow Flight), 使得数据可以轻松存储为可跨平台的列式文件, 而无需经历复杂的数据导出和导入过程

• 互操作性: Arrow 的存在增强了 Pandas 与其他数据处理工具、数据库和存储系统之间的互操作性。它允许 Pandas 用户更轻松地与其他工具集成和交换数据

总之, PyArrow 作为 Pandas 的附加库, 提供了高性能、跨平台和跨语言的数据交换机制, 有助于改进 Pandas 与其他数据处理工具之间的数据交互, 并提高数据处理效率

堆叠的数据

堆叠的数据是一种多层索引的数据结构, 通常用于表示多维数据或多维度数据。在这种结构中, 数据被组织为多个层次的索引, 每个索引级别代表数据的一个维度或特征。这种数据结构在数据分析中非常有用, 因为它可以帮助组织和分析复杂的多维数据

多层索引的数据结构可以在 Pandas 中使用 DataFrame 或 Series 来表示。每个索引级别都用于唯一标识数据点, 并且可以具体表示不同维度或特征中的取值。这使得堆叠的数据非常适用于存储和分析多类别数据、时间序列数据、多组实验数据等

通过使用多层索引, 您可以更轻松地进行数据切片、筛选、分组和聚合操作, 以及绘制多维数据的图表和可视化。这使得堆叠的数据结构成为处理复杂数据的有力工具, 有助于更深入地理解数据中的关系和趋势

举例

让我们通过一个示例来说明堆叠的数据结构。假设您正在分析某个公司的销售数据, 其中包括不同产品、不同地区和不同时间的销售额。您希望将这些数据以堆叠的方式组织, 以便更容易进行分析

假设您的原始数据如下:

Product    Region    Date       Sales
A          North     2021-01-01  100
B          North     2021-01-01  150
A          South     2021-01-01  120
B          South     2021-01-01  130
A          North     2021-01-02  110
B          North     2021-01-02  160
A          South     2021-01-02  130
B          South     2021-01-02  140

您可以使用堆叠的数据结构将数据重组为一个多层索引的 DataFrame。在这个示例中, 您可以将 "Product"、"Region" 和 "Date" 列作为索引级别, 以便在数据中表示产品、地区和时间的不同维度

重组后的数据结构如下:

import pandas as pd

data = {
    'Product': ['A', 'B', 'A', 'B', 'A', 'B', 'A', 'B'],
    'Region': ['North', 'North', 'South', 'South', 'North', 'North', 'South', 'South'],
    'Date': ['2021-01-01', '2021-01-01', '2021-01-01', '2021-01-01', '2021-01-02', '2021-01-02', '2021-01-02', '2021-01-02'],
    'Sales': [100, 150, 120, 130, 110, 160, 130, 140]
}

df = pd.DataFrame(data)
df = df.set_index(['Product', 'Region', 'Date'])

现在, 您的数据已经以堆叠的方式组织, 并可以轻松地进行多维分析。您可以按照不同索引级别进行切片、筛选和聚合操作, 以获取有关销售的更详细信息。例如, 您可以轻松地计算不同产品在不同地区和不同日期的销售总额, 或者绘制产品销售随时间的趋势图

这是堆叠的数据结构如何帮助组织和分析多维数据的示例。它使数据分析更加灵活和有力

**堆叠的数据相对于堆叠前有什么好处: **

堆叠的数据结构相对于未堆叠的数据具有一些好处, 特别是在多维数据分析和可视化方面。以下是一些好处:

• 多维数据表示: 堆叠的数据结构能够更清晰地表示多维数据, 允许您将数据以更结构化的方式组织。这对于具有多个维度或特征的数据集非常有用, 例如时间序列数据、多组实验数据、多类别数据等

• 灵活性: 堆叠的数据结构提供了更多的分析和操作灵活性。您可以根据需要使用不同的索引级别来访问和分析数据, 而不需要重新组织原始数据

• 多维切片和筛选: 使用堆叠的数据结构, 您可以轻松地在多个索引级别上进行切片、筛选和子集选择。这使得在多维数据集中查找和提取特定数据更加方便

• 数据聚合: 堆叠的数据结构可以更轻松地进行数据聚合操作, 例如计算每个索引组合的平均值、总和或其他汇总统计量

• 数据可视化: 堆叠的数据结构有助于更容易创建多维数据的可视化图表。您可以根据不同的索引级别生成不同维度的图表, 以更好地理解数据

• 数据分析: 多维数据的探索性数据分析更加直观, 您可以更容易地查看不同维度之间的关系和趋势

总的来说, 堆叠的数据结构提供了更多的数据处理和分析选项, 特别适用于需要处理多维数据或多维度数据的情况。它使数据更有组织性, 更易于理解和利用

数据透视表

"pivot" 一词在数据处理中通常用来表示在某种方式上重新排列数据, 以便将原始数据按照不同的轴重新组织和展示

数据透视表(Pivot Table)是数据分析和报表制作中常用的工具, 它可以用于对大量数据进行汇总和可视化展示。数据透视表通常用于以下情况:

• 汇总数据: 数据透视表可以将大量的原始数据按照指定的方式进行分组和汇总, 以生成更简洁的摘要信息。这有助于从复杂的数据中提取有用的见解

• 多维度分析: 数据透视表允许用户在多个维度上分析数据, 例如按时间、地区、产品类别等维度进行分组和分析。这有助于发现不同维度之间的关联和趋势

• 可视化: 数据透视表通常以表格或交互式图形的形式呈现, 使数据更容易理解。用户可以根据需要自定义数据透视表的布局和可视化方式

• 过滤和筛选: 数据透视表通常允许用户根据特定条件过滤和筛选数据, 以便进行更深入的分析

• 汇总函数: 数据透视表支持各种汇总函数, 如求和、平均、最大值、最小值、中位数等, 以便计算和显示聚合数据

• 快速报表生成: 数据透视表工具通常具有用户友好的界面, 可以通过拖放或选择字段来生成报表, 而无需编写复杂的代码

Pandas 库中的 pivot_table 函数是一个常见的工具, 用于创建和操作数据透视表。数据透视表在数据分析、数据可视化和业务报表生成中非常有用, 因为它可以帮助用户更好地理解和解释数据

groupby 和 pivot_table

groupby 和 pivot_table 是 Pandas 中用于数据重塑和聚合的两种不同方法

groupby:

• groupby 用于将数据根据一个或多个列的值分组 您可以对每个组应用聚合函数, 例如 sum, mean, count, 等
• groupby 通常用于生成汇总信息, 如计算每个组的总和、均值等 结果是一个 GroupBy 对象, 您可以在其上应用聚合函数

示例:

grouped = df.groupby('category')
result = grouped['value'].sum()

pivot_table:

• pivot_table 用于将数据从长格式(long format)重塑为宽格式(wide format) 它允许您将一个或多个列作为行和列索引, 然后填充这些单元格的值
• pivot_table 通常用于创建透视表, 将数据沿着不同的维度进行汇总 结果是一个新的数据框, 其中行和列被重新组织以便进行更方便的分析

pivot_df = df.pivot_table(index='date', columns='category', values='value', aggfunc='sum')

总结:

• 使用 groupby 当您希望按照某些列的值对数据进行分组, 并对每个组应用聚合操作
• 使用 pivot_table 当您希望将数据从长格式(例如时间序列数据)转换为宽格式, 以便进行透视分析或制作透视表

这两种方法在不同情况下非常有用, 具体取决于您的数据分析需求

堆叠的数据与宽格式, 长格式

堆叠的数据、宽格式和长格式是数据在数据分析领域中的不同表示方式, 它们之间存在关系, 通常用于不同的数据分析需求

宽格式(Wide Format):

• 宽格式数据通常以表格的形式表示, 其中每个变量(列)占据表格的一列, 每行表示一个观察或数据点
• 这种格式适合于一次性查看多个变量和进行某些类型的统计分析
• 宽格式数据对于简单的数据报表和可视化非常有用

长格式(Long Format):

• 长格式数据通常具有多层索引, 其中每个观察都可以由多个索引级别来唯一标识
• 这种格式适合于包含多维数据或多维度数据的情况, 例如时间序列数据、多组实验数据或多类别数据
• 长格式数据通常使用 Pandas 的 MultiIndex(多层索引)或包含多个变量的列来表示

堆叠的数据(Stacked Data):

• 堆叠的数据通常是长格式数据的一种表示方式, 其中数据以多层索引的形式存储, 使得每个数据点都可以由多个索引级别来唯一标识
• 这种格式通常用于多维数据或多维度数据的表示, 允许更灵活的分析和操作
• 堆叠数据通常在 Pandas 中使用 MultiIndex 的 DataFrame 或 Series 来表示

**关系: **

• 堆叠的数据可以视为长格式数据的一种表示方式, 其中多层索引的使用允许更灵活地表示多个维度或多个特征
• 当需要在长格式和宽格式之间切换时, Pandas 提供了许多方法, 如 pivot、pivot_table、melt 等, 以帮助数据的转换和透视

总之, 这些数据表示格式之间存在关系, 您可以根据您的数据和分析需求选择最适合的格式。通常, 长格式和堆叠的数据更适合多维数据, 而宽格式更适合简单的数据报表和可视化

style

style.apply 和 style.applymap 都是 Pandas 的样式功能中的方法, 用于在 DataFrame 的元素上应用样式。虽然它们的名称相似, 但它们的用法和适用范围略有不同

1. style.applymap:

适用范围: 用于 DataFrame 中的每个元素 用法: 接受一个函数, 该函数将被应用于 DataFrame 的每个元素, 使你能够基于元素的值来自定义样式

def style_function(value):
    # 返回 CSS 样式字符串
    return 'color: red' if value < 0 else 'color: green'

styled_df = df.style.applymap(style_function)

2. style.apply:

适用范围: 用于按行或按列对 DataFrame 应用样式 用法: 接受一个函数, 并指定轴(axis), 函数将按照指定的轴应用于 DataFrame。这允许你在整行或整列上根据一些聚合或条件来定义样式

def style_function(series):
    # 返回 CSS 样式字符串
    return ['color: red' if val < 0 else 'color: green' for val in series]

styled_df = df.style.apply(style_function, axis=0)  # 在列上应用样式

总体而言, style.applymap 更适合在每个单独的元素上应用样式, 而 style.apply 更适合在整行或整列上应用样式。在选择使用哪个方法时, 取决于你想要的样式效果以及你希望在 DataFrame 的哪个级别上应用样式

shift 和 rolling

shift 和 rolling 是 pandas 中用于时间序列数据处理的两个常用函数, 它们分别用于对数据进行移动和滚动计算

1. shift: 作用: shift 主要用于将数据向前或向后移动指定数量的步长

2. rolling: 使用示例 (opens new window) 作用: rolling 主要用于执行滚动计算, 例如计算滚动均值或滚动总和

link

• pandas (opens new window)
  • reference (opens new window)
• w3c-Pandas: DataFrame (opens new window)