PandasMultiIndexDataFrame数据批量添加方法

哈喽！今天心血来潮给大家带来了《Pandas MultiIndex DataFrame 批量添加数据技巧》，想必大家应该对文章都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习文章，千万别错过这篇文章~希望能帮助到你！

在数据分析和科学计算中，Pandas DataFrame以其强大的数据处理能力成为不可或缺的工具。特别是当数据具有多层分类结构时，MultiIndex DataFrame能够提供清晰、灵活的数据组织方式。然而，当我们需要向一个已有的MultiIndex DataFrame中添加大量新行，尤其是这些新行涉及到MultiIndex中新的高层级（例如新的主题、新的试验）时，效率问题便浮出水面。

低效的循环添加方法及其弊端

考虑一个实验场景，我们收集了不同受试者（subject）、不同试验（trial）下，每个试验中不同事件（event）的数据，并使用MultiIndex DataFrame进行存储：

import pandas as pd

# 初始数据
tuples = [
    ('s1', 't1', 0, 1, 11), ('s1', 't2', 0, 4, 14), ('s1', 't2', 1, 5, 15), ('s2', 't1', 0, 6, 16),
    ('s2', 't1', 1, 7, 17), ('s2', 't2', 0, 8, 18), ('s2', 't3', 0, 9, 19),
]
df = pd.DataFrame.from_records(tuples, index=['subject', 'trial', 'event'],
                              columns=['subject', 'trial', 'event', 'A', 'B'])
print("原始DataFrame:")
print(df)

输出如下：

                     A   B
subject trial event       
s1      t1    0      1  11
        t2    0      4  14
              1      5  15
s2      t1    0      6  16
              1      7  17
        t2    0      8  18
        t3    0      9  19

现在，假设我们要为新的受试者 's3'、新的试验 't1' 添加一系列新的事件数据，例如 events = [5, 6, 7]。一种直观但效率低下的做法是使用循环和 df.loc 进行逐行添加：

events = [5, 6, 7] # 待添加的事件数据列表
for i, event_val in enumerate(events):
    df.loc[('s3', 't1', i), 'A'] = event_val
print("\n使用循环添加后的DataFrame:")
print(df)

其输出为：

                       A     B
subject trial event           
s1      t1    0      1.0  11.0
        t2    0      4.0  14.0
              1      5.0  15.0
s2      t1    0      6.0  16.0
              1      7.0  17.0
        t2    0      8.0  18.0
        t3    0      9.0  19.0
s3      t1    0      5.0   NaN
              1      6.0   NaN
              2      7.0   NaN

这种方法虽然实现了功能，但在内部，每次循环迭代都可能导致Pandas重新分配内存并复制整个DataFrame，这对于大量数据或频繁操作而言，会产生巨大的性能开销。尤其当添加的索引层级（如 's3'）是全新的，Pandas需要扩展其内部结构来容纳新数据，这使得复制操作更为频繁和昂贵。

尝试直接使用 df.loc 批量赋值给新的MultiIndex组合，通常会遇到 KeyError 或 ValueError，因为Pandas期望现有索引或能够直接匹配的索引结构，而不是凭空创建新的MultiIndex组合。例如：

# 常见失败尝试示例
# df.loc[('s3','t2'), 'A'] = events    # --> KeyError
# df.loc[('s3','t2', slice(None)), 'A'] = events    # --> ValueError

这些错误表明，df.loc 主要用于对现有数据进行选择和修改，或在现有索引下添加数据，而非高效地创建新的、多层级的索引结构并批量插入数据。

高效的批量添加策略：构建新DataFrame并合并

解决上述效率问题的关键在于利用Pandas的向量化操作能力。最佳实践是：

1. 将所有待添加的新数据组织成一个新的DataFrame。
2. 确保这个新DataFrame具有与目标DataFrame兼容的MultiIndex结构。
3. 使用 pd.concat() 函数将新旧DataFrame合并。

下面是具体实现步骤：

# 待添加的新事件数据
events_new = [5, 6, 7]
num_of_events_new = len(events_new)

# 1. 构建新数据的MultiIndex
# MultiIndex的每个层级都需要一个与数据长度相等的列表
# 这里为's3'、't1'、以及事件序号0, 1, 2
new_subject_level = ['s3'] * num_of_events_new
new_trial_level = ['t1'] * num_of_events_new
new_event_level = range(num_of_events_new) # 0, 1, 2

# 使用pd.MultiIndex.from_arrays()创建MultiIndex
idx_new = pd.MultiIndex.from_arrays([new_subject_level, new_trial_level, new_event_level],
                                     names=['subject', 'trial', 'event'])

# 2. 创建包含新数据的新DataFrame
# 将events_new列表作为数据，使用上面构建的MultiIndex
# 注意，我们只添加了'A'列的数据，'B'列将自动填充NaN
df_to_add = pd.DataFrame(events_new, index=idx_new, columns=['A'])

print("\n待添加的新DataFrame:")
print(df_to_add)

# 3. 使用pd.concat()合并原始DataFrame和新DataFrame
# ignore_index=False (默认) 会保留原始索引
# axis=0 (默认) 会按行合并
df_combined = pd.concat([df, df_to_add])

print("\n高效添加后的DataFrame:")
print(df_combined)

输出结果：

待添加的新DataFrame:
                     A
subject trial event   
s3      t1    0      5
              1      6
              2      7

高效添加后的DataFrame:
                       A     B
subject trial event           
s1      t1    0      1.0  11.0
        t2    0      4.0  14.0
              1      5.0  15.0
s2      t1    0      6.0  16.0
              1      7.0  17.0
        t2    0      8.0  18.0
        t3    0      9.0  19.0
s3      t1    0      5.0   NaN
              1      6.0   NaN
              2      7.0   NaN

注意事项与最佳实践

1. 索引层级匹配： 新构建的DataFrame的MultiIndex的层级名称（names 参数）应与原始DataFrame的MultiIndex层级名称保持一致，以确保 pd.concat() 能够正确对齐。
2. 数据对齐： 如果新DataFrame的列与原始DataFrame的列不完全匹配，pd.concat() 会自动填充 NaN 值。这通常是期望的行为，但需要注意数据的完整性。
3. 向量化优势： 这种方法充分利用了Pandas底层的C语言优化，避免了Python循环带来的开销，尤其适用于大规模数据操作。
4. 内存管理： 虽然 pd.concat() 仍可能涉及数据复制，但它通常比反复修改原DataFrame的内存效率更高，因为它是一次性操作，而非多次小规模的重新分配。
5. 适用场景： 这种策略特别适合于一次性添加一个“块”的数据，即新增的数据属于MultiIndex中的一个或多个新的高层级组合。

总结

当需要在Pandas MultiIndex DataFrame中高效批量添加多行数据，尤其是涉及到新增索引层级时，避免使用循环逐行添加。正确的做法是，首先构造一个带有正确MultiIndex结构的新DataFrame来承载所有待添加的数据，然后利用 pd.concat() 函数将其与原始DataFrame进行合并。这种方法不仅能够确保数据的正确对齐，更能显著提升操作效率和性能，是处理此类数据添加任务的推荐实践。掌握这一技巧，将有助于更高效地管理和操作复杂的结构化数据。

以上就是《PandasMultiIndexDataFrame数据批量添加方法》的详细内容，更多关于的资料请关注golang学习网公众号！