解决Pandas DataFrame高度碎片化警告：高效创建多列的策略

本文深入探讨了pandas dataframe在通过循环或重复赋值创建大量新列时，可能遇到的“dataframe高度碎片化”性能警告。该警告通常指示了低效的内存操作和性能瓶颈。文章将详细解释警告产生的原因，并提供一个高效的解决方案，即利用`pd.concat`一次性创建并合并所有新列，从而显著提升性能并避免不必要的内存重分配，确保数据处理的流畅性。

理解Pandas DataFrame高度碎片化警告

在使用Pandas处理大量数据时，如果需要从现有列派生出大量新列，并采用逐个赋值的方式，可能会遇到PerformanceWarning: DataFrame is highly fragmented的警告。这个警告提示DataFrame的内存布局变得高度碎片化，通常是由于频繁调用frame.insert操作导致的，这会严重影响性能。

警告产生的原因

当您通过 df['new_col'] = ... 这种语法为DataFrame添加新列时，Pandas在底层可能会执行frame.insert操作。如果DataFrame已经很大，并且您反复执行此操作来添加数百甚至上千个新列，每次添加新列都可能导致DataFrame在内存中重新分配空间，并将现有数据复制到新的内存位置。这种频繁的内存重分配和数据复制是导致性能下降和“高度碎片化”警告的主要原因。尤其是在处理具有百万行、需要拆分为数百个子列的场景中，这个问题会尤为突出。

考虑以下一个典型的触发场景：

import pandas as pd
import numpy as np
import string

# 模拟一个具有100万行和一列长字符串的DataFrame
np.random.seed(0)
df = pd.DataFrame({
    "long_string": ["".join(np.random.choice(
        [*string.printable[:62]], size=5000)) for _ in range(10000)]
})

def parse_long_string_fragmented(df):
    # 假设需要从'long_string'中解析出972个子字符串
    # 这是一个简化示例，实际可能需要更多列
    for i in range(1, 10): # 仅演示少量列，避免示例过长
        start = (i - 1) * 2
        end = i * 2
        df[f'a{i:03d}'] = df['long_string'].str[start:end]
    # 如果循环次数足够多（例如972次），将触发PerformanceWarning
    return df

# 调用函数，如果列数足够多，将看到警告
# out_fragmented = parse_long_string_fragmented(df.copy())

上述代码中，通过循环逐一创建新列，每次循环都会修改原DataFrame的结构，从而可能触发性能警告。

解决方案：使用 pd.concat 高效创建多列

解决DataFrame高度碎片化问题的核心思想是：避免对原始DataFrame进行多次修改，而是将所有新列一次性创建，然后一次性合并到原始DataFrame中。pd.concat是实现这一目标的高效工具。

Grok

马斯克发起的基于大语言模型(LLM)的AI聊天机器人TruthGPT，现用名Grok

437

查看详情

核心策略

1. 定义切片规则： 将所有需要创建的列及其对应的字符串切片规则存储在一个映射（如字典）中。
2. 批量生成新列： 使用字典推导式（dictionary comprehension）和df.str.slice方法，为每个切片规则生成一个Pandas Series。
3. 合并新列： 将这些Series作为字典的值传递给pd.concat(axis=1)，一次性创建一个包含所有新列的新DataFrame。
4. 连接到原DataFrame： 使用df.join()方法将新生成的DataFrame连接到原始DataFrame上。

示例代码

以下是使用pd.concat解决上述问题的具体实现：

import pandas as pd
import numpy as np
import string

# 1. 准备示例数据
np.random.seed(0)
df = pd.DataFrame({
    "long_string": ["".join(np.random.choice(
        [*string.printable[:62]], size=5000)) for _ in range(10000)]
})

# 2. 定义所有列的切片规则
# 假设我们有972个切片规则，这里用字典来存储
# 键为新列名，值为(起始索引, 结束索引)
slices_mapper = {f"a{i+1:03d}": (i*2, (i+1)*2) for i in range(972)}
# 对于最后一个切片，如果需要到字符串末尾，结束索引可以设为None
# 例如，如果最后一个切片是'a972'，从4994开始到末尾
slices_mapper['a972'] = (4994, None) # 覆盖之前的定义，确保最后一个切片正确

def parse_long_string_efficient(df, mapper):
    # 3. 批量生成所有新列
    # 使用字典推导式为每个切片规则生成一个Series
    # 然后用pd.concat(axis=1)将这些Series合并成一个新DataFrame
    new_cols_df = pd.concat(
        {
            col_name: df["long_string"].str[start_idx:end_idx]
            for col_name, (start_idx, end_idx) in mapper.items()
        },
        axis=1 # 沿列方向合并
    )

    # 4. 将新生成的DataFrame连接到原始DataFrame
    # df.join() 是一个高效的连接操作，因为它默认基于索引进行连接
    return df.join(new_cols_df)

# 调用高效的解析函数
output_df = parse_long_string_efficient(df.copy(), slices_mapper)

print(output_df.head())
print(f"\nDataFrame形状: {output_df.shape}")

代码解释：

• slices_mapper 字典：清晰地定义了每个新列的名称及其对应的字符串切片范围。这使得代码更具可读性和可维护性。
• 字典推导式 { col_name: df["long_string"].str[start_idx:end_idx] for ... }：在内存中一次性计算出所有新列的Series数据。
• pd.concat(..., axis=1)：将这些Series（作为字典的值）沿着列方向合并成一个新的DataFrame (new_cols_df)。这个操作是高度优化的，因为它知道要创建多少列，并能进行一次性内存分配。
• df.join(new_cols_df)：将包含所有新列的new_cols_df一次性连接到原始DataFrame df上。join方法通常比多次的df['new_col'] = ...赋值更高效，因为它也是基于索引的合并操作。

性能优势

通过pd.concat和df.join的组合，我们避免了对原始DataFrame进行数百次的修改操作。Pandas只需要进行一次大的内存分配和数据复制（如果需要的话），而不是数百次小的、重复的内存操作。这显著减少了计算时间和内存开销，从而消除了“DataFrame高度碎片化”的性能警告。

总结与注意事项

• 核心原则： 在Pandas中创建大量新列时，尽量避免循环逐个赋值，转而采用批量操作。
• pd.concat的妙用： 它是解决DataFrame碎片化警告的强大工具，尤其适用于从现有列派生出多个新列的场景。
• df.assign()： 另一个创建新列的函数是df.assign()，它也可以用于批量创建新列，但通常更适用于基于函数或表达式生成少量新列的场景。对于本教程中这种通过切片生成大量列的情况，pd.concat结合字典推导式更为直接和高效。
• 理解警告： PerformanceWarning并非错误，但它强烈提示您的代码存在性能瓶颈。忽视这些警告可能导致在处理大规模数据集时程序运行缓慢，甚至内存溢出。
• 内存管理： 了解Pandas的底层内存管理机制有助于编写更高效的代码。DataFrame的内存布局对性能有显著影响。

通过采纳本文介绍的pd.concat策略，您可以有效规避Pandas DataFrame的高度碎片化问题，确保数据处理流程的流畅性和高效性。

以上就是解决Pandas DataFrame高度碎片化警告：高效创建多列的策略的详细内容，更多请关注php中文网其它相关文章！