创建堆叠DataFrame分组比率教程

最近发现不少小伙伴都对文章很感兴趣，所以今天继续给大家介绍文章相关的知识，本文《创建堆叠DataFrame分组比率教程》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

本文介绍如何在Pandas中高效地对堆叠式DataFrame进行分组，计算特定类型变量（如'ts'/'td'）的行间比率，并将其作为新行添加回原数据。文章通过`set_index`、`unstack`和`div`等Pandas核心操作，展示了如何优雅地处理数据转换、比率计算以及缺失值（NaN）的填充，同时保留原始数据结构，避免了低效的循环或`apply`方法。

数据结构与目标

在数据分析中，我们经常会遇到需要从“长格式”（或堆叠式）DataFrame中提取特定行值并进行计算的场景。例如，给定一个包含分组键（如G1, G2）、类型标识符（TPE，如'td'或'ts'）和数值（QC）的DataFrame，我们的目标是：

1. 根据G1和G2进行分组。
2. 在每个组内，计算TPE为'ts'的QC值与TPE为'td'的QC值的比率（ts/td）。
3. 将这些比率作为新行添加到原始DataFrame中，新行的TPE列标记为'ratio'。
4. 如果某个组缺少'td'或'ts'值，则对应的比率应为空（NaN）。

以下是输入DataFrame的示例：

import pandas as pd
import numpy as np

data = {
    'G1': ['A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'C', 'D'],
    'G2': ['S1', 'S1', 'S2', 'S2', 'S1', 'S1', 'S2', 'S2', 'S1', 'S2'],
    'TPE': ['td', 'ts', 'td', 'ts', 'td', 'ts', 'td', 'ts', 'td', 'ts'],
    'QC': [2, 4, 6, 3, 20, 40, 60, 30, 90, 7]
}
df_in = pd.DataFrame(data)

# 模拟缺失td或ts的情况
df_in.loc[8, 'TPE'] = 'td' # C S1只有td
df_in.loc[9, 'TPE'] = 'ts' # D S2只有ts

print("原始DataFrame (df_in):")
print(df_in)

输出的df_in如下：

   G1  G2 TPE  QC
0  A  S1  td   2
1  A  S1  ts   4
2  A  S2  td   6
3  A  S2  ts   3
4  B  S1  td  20
5  B  S1  ts  40
6  B  S2  td  60
7  B  S2  ts  30
8  C  S1  td  90
9  D  S2  ts   7

传统处理方法的挑战

一种直观但效率不高的做法是使用groupby().apply()结合自定义函数。例如：

def calculate_ratio_inefficient(group):
    td_row = group[group['TPE'] == 'td']
    ts_row = group[group['TPE'] == 'ts']
    if not td_row.empty and not ts_row.empty:
        ratio = ts_row['QC'].values[0] / td_row['QC'].values[0]
        return pd.DataFrame({'G1': [group['G1'].iloc[0]], 
                             'G2': [group['G2'].iloc[0]], 
                             'TPE': ['ratio'], 
                             'QC': [ratio]})
    # 如果缺少td或ts，返回一个空DataFrame，这会导致该组的比率行被忽略
    return pd.DataFrame()

# grouped = df_in.groupby(['G1', 'G2']).apply(calculate_ratio_inefficient).reset_index(drop=True)
# df_out_inefficient = pd.concat([df_in, grouped], ignore_index=True)
# print("\n使用apply的输出 (会丢失缺失比率的组):")
# print(df_out_inefficient)

这种方法虽然能实现比率计算，但存在几个问题：

• 效率低下：apply()操作通常比Pandas的矢量化操作慢，尤其是在大数据集上。
• 缺失值处理复杂：为了保留所有组（包括那些缺少'td'或'ts'的组）的比率行并填充NaN，自定义函数需要更复杂的逻辑，否则如上述代码所示，这些组的比率行会被直接丢弃。

利用Pandas实现高效比率计算

Pandas提供了更高效、更“Pythonic”的方式来解决这类问题，核心思想是利用set_index和unstack将不同类型的值转换为列，从而实现矢量化计算。

核心代码解析

# 步骤1: 设置多级索引并将'TPE'列unstack为新列
# 这会将G1, G2作为行索引，TPE的值（td, ts）作为列名，QC的值填充这些新列。
# 如果某个G1/G2组合缺少td或ts，unstack会自动填充NaN。
tmp = df_in.set_index(['G1', 'G2', 'TPE']).unstack()['QC']
print("\n中间结果 (tmp DataFrame):")
print(tmp)

tmp DataFrame的输出：

TPE    td    ts
G1 G2          
A  S1   2.0   4.0
   S2   6.0   3.0
B  S1  20.0  40.0
   S2  60.0  30.0
C  S1  90.0   NaN
D  S2   NaN   7.0

从tmp中可以看到，TPE列的值'td'和'ts'已经变成了新的列名，并且QC值填充了相应的位置。对于C S1，由于没有'ts'，ts列显示为NaN；同理，D S2的td列也显示为NaN。

# 步骤2: 计算比率
# 直接对unstacked后的列进行除法操作。Pandas会自动处理NaN。
# ts / td
ratio_series = tmp['ts'].div(tmp['td'])
print("\n计算出的比率Series:")
print(ratio_series)

ratio_series的输出：

G1  G2
A   S1    2.0
    S2    0.5
B   S1    2.0
    S2    0.5
C   S1    NaN
D   S2    NaN
dtype: float64

这里，C S1和D S2的比率因为存在NaN值而计算结果也为NaN，这正是我们期望的行为。

# 步骤3: 将比率Series转换回DataFrame并添加'TPE'列
# reset_index()将多级索引G1, G2变回普通列。
# name='QC'将比率Series的名称设为'QC'，使其成为DataFrame中的一列。
# assign(TPE='ratio')添加一个名为'TPE'的新列，并将其值设置为'ratio'。
ratio_df = ratio_series.reset_index(name='QC').assign(TPE='ratio')
print("\n比率DataFrame (ratio_df):")
print(ratio_df)

ratio_df的输出：

  G1  G2  QC    TPE
0  A  S1   2.0  ratio
1  A  S2   0.5  ratio
2  B  S1   2.0  ratio
3  B  S2   0.5  ratio
4  C  S1   NaN  ratio
5  D  S2   NaN  ratio

结果整合与最终输出

最后一步是将原始DataFrame df_in与新生成的比率DataFrame ratio_df合并。

# 步骤4: 合并原始DataFrame和比率DataFrame
df_out = pd.concat([df_in, ratio_df], ignore_index=True)
print("\n最终输出DataFrame (df_out):")
print(df_out)

最终的df_out如下：

   G1  G2    TPE   QC
0   A  S1     td  2.0
1   A  S1     ts  4.0
2   A  S2     td  6.0
3   A  S2     ts  3.0
4   B  S1     td  20.0
5   B  S1     ts  40.0
6   B  S2     td  60.0
7   B  S2     ts  30.0
8   C  S1     td  90.0
9   D  S2     ts  7.0
10  A  S1  ratio  2.0
11  A  S2  ratio  0.5
12  B  S1  ratio  2.0
13  B  S2  ratio  0.5
14  C  S1  ratio  NaN
15  D  S2  ratio  NaN

总结与最佳实践

这种利用set_index、unstack、矢量化操作（如div）和concat的组合方法是Pandas中处理此类数据转换的强大且高效的模式。

优点：

• 矢量化操作：充分利用Pandas底层C语言实现，性能远超基于Python循环或apply的方案。
• 简洁性：代码逻辑清晰，易于理解和维护。
• 健壮性：unstack操作能够自然地处理缺失值，自动引入NaN，避免了手动条件判断的复杂性。
• 灵活性：此模式可以轻松扩展到计算其他类型的比率或进行更复杂的列间运算。

在处理大型数据集时，优先考虑使用Pandas提供的矢量化函数和数据重塑工具，而不是编写自定义的apply函数，这将显著提升代码的性能和可读性。

今天关于《创建堆叠DataFrame分组比率教程》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！