Pandas DataFrame性能优化：高效处理“高度碎片化”警告与多列创建

本文旨在解决pandas dataframe在创建大量新列时出现的“高度碎片化”`performancewarning`。该警告通常源于迭代式地向dataframe添加列，导致性能下降。我们将详细探讨其产生原因，并提供一个使用`pd.concat`和`df.join`的优化方案，以实现高效、批量地创建新列，从而避免性能问题，提升数据处理效率。

理解PerformanceWarning：DataFrame碎片化问题

在使用Pandas处理大量数据时，如果频繁地以迭代方式向一个大型DataFrame添加新列，可能会遇到PerformanceWarning: DataFrame is highly fragmented的警告。这个警告提示DataFrame已经高度碎片化，通常是由于多次调用内部的frame.insert操作造成的，这会导致显著的性能开销。

当通过df['new_column'] = ...这种语法逐个创建新列时，Pandas在后台可能需要重新分配内存并复制数据，尤其是在DataFrame的内存布局发生变化时。对于包含百万行数据且需要创建数百甚至上千个新列的场景，这种逐个添加的方式会极大地降低效率，并可能导致内存使用率升高。

低效的列创建方式及其问题

考虑一个常见场景：从一个包含长字符串的列中，根据不同的切片规则解析出多个子字符串，并将它们作为新的列添加到DataFrame中。以下是一个典型的低效实现示例：

import pandas as pd
import numpy as np
import string

# 模拟一个大型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_inefficient(df):
    # 假设需要创建972个新列
    for i in range(1, 973):
        start = (i-1) * 2
        end = i * 2 if i < 972 else None # 最后一个切片可能到末尾
        col_name = f'a{i:03d}'
        df[col_name] = df['long_string'].str[start:end]
    return df

# 调用此函数时，可能会收到PerformanceWarning
# out_inefficient = parse_long_string_inefficient(df.copy())

上述代码通过循环逐个创建并赋值新列。当循环次数（即新列数量）非常大时，每次df[col_name] = ...的操作都可能触发DataFrame的内部重构，导致内存碎片化，进而引发PerformanceWarning并严重影响执行性能。Pandas建议使用pd.concat(axis=1)等方法一次性合并所有新列，以避免这种碎片化。

高效解决方案：利用pd.concat和df.join

解决DataFrame碎片化问题的核心思想是：避免迭代地修改原始DataFrame，而是将所有新列一次性创建为一个独立的DataFrame，然后通过高效的合并操作（如pd.join或pd.concat）将其与原始DataFrame结合。

Sider

多功能AI浏览器助手，帮助用户进行聊天、写作、阅读、翻译等

3159

查看详情

以下是利用pd.concat和df.join实现高效多列创建的步骤和示例：

1. 定义列切片规则： 将所有需要创建的列名及其对应的字符串切片范围存储在一个映射结构中（例如字典）。
2. 批量创建新列： 使用字典推导式（Dictionary Comprehension）结合df['long_string'].str.slice方法，一次性生成所有新列的数据系列（Series）。
3. 使用pd.concat构建新DataFrame： 将这些新生成的Series作为字典的值，键为列名，然后传递给pd.concat函数，并设置axis=1，将其合并成一个包含所有新列的DataFrame。
4. 使用df.join合并： 将这个包含所有新列的DataFrame通过df.join()方法高效地与原始DataFrame合并。join操作通常比concat更适合基于索引的合并，且在处理少量DataFrame合并时效率更高。

完整示例代码

import pandas as pd
import numpy as np
import string
import time # 用于性能对比

# 1. 模拟一个大型DataFrame
np.random.seed(0)
num_rows = 10000
long_string_length = 5000
df = pd.DataFrame({
    "long_string": ["".join(np.random.choice(
        [*string.printable[:62]], size=long_string_length)) for _ in range(num_rows)]
})

# 2. 定义列切片规则
# 假设我们从长字符串中每2个字符切片为一个新列，直到字符串末尾
# 示例中创建了972个列，前971列每列2个字符，最后一列是剩余字符
slices_mapper = {}
current_start = 0
for i in range(1, 973): # 假设需要创建972列
    col_name = f'a{i:03d}'
    if i < 972:
        end = current_start + 2
        slices_mapper[col_name] = (current_start, end)
        current_start = end
    else: # 最后一列，切片到字符串末尾
        slices_mapper[col_name] = (current_start, None)

print(f"将创建 {len(slices_mapper)} 个新列。")

# 3. 高效解析函数
def parse_long_string_efficient(df_input, mapper):
    """
    使用pd.concat和df.join高效解析长字符串并创建多列。

    Args:
        df_input (pd.DataFrame): 包含'long_string'列的原始DataFrame。
        mapper (dict): 字典，键为新列名，值为(start, end)切片元组。

    Returns:
        pd.DataFrame: 包含原始列和所有新创建列的DataFrame。
    """
    # 使用字典推导式和pd.concat一次性创建所有新列
    new_cols_df = pd.concat(
        {
            col_name: df_input["long_string"].str[start:end]
            for col_name, (start, end) in mapper.items()
        },
        axis=1 # 沿列方向合并
    )

    # 将新列DataFrame与原始DataFrame合并
    return df_input.join(new_cols_df)

# 4. 执行并验证
start_time = time.time()
result_df = parse_long_string_efficient(df.copy(), slices_mapper)
end_time = time.time()

print(f"\n高效方法执行时间: {end_time - start_time:.4f} 秒")
print("\n结果DataFrame头部：")
print(result_df.head())
print("\n结果DataFrame信息：")
print(result_df.info())
print(f"\n结果DataFrame形状: {result_df.shape}")

# 验证某一列的数据
# print("\n'a001'列前5行:", result_df['a001'].head().tolist())
# print("'a972'列前5行:", result_df['a972'].head().tolist())

运行上述代码，您会发现不再出现PerformanceWarning，且在大规模数据和多列创建场景下，性能得到了显著提升。

最佳实践与注意事项

1. 批量操作优先： 尽可能使用Pandas提供的向量化操作和批量处理函数（如apply配合返回Series或DataFrame、pd.concat、df.assign），避免使用Python原生的循环逐行或逐列操作。
2. 理解df.assign： 对于创建少量新列，df.assign()也是一个非常方便且高效的方法，它允许您在一个方法调用中创建多个新列，并且会返回一个新的DataFrame。

   # 示例 df.assign
   # df_new = df.assign(
   #     col1=df['A'] + df['B'],
   #     col2=df['C'].apply(lambda x: x * 2)
   # )

   登录后复制

   然而，当新列的创建逻辑非常复杂，或者新列数量非常庞大时，pd.concat的灵活性和性能优势可能更突出。

3. 内存管理： 即使使用了高效方法，创建大量新列仍然会增加DataFrame的内存占用。在处理极大规模数据时，需要注意系统的内存限制。
4. 数据类型优化： 如果新创建的列可以指定更小或更精确的数据类型（例如，整数列可以使用int8而不是默认的int64），在创建时显式指定可以进一步节省内存并可能提高性能。
5. df.copy()的作用： 警告中提到newframe = frame.copy()可以获取一个“去碎片化”的DataFrame。这意味着如果你已经有了一个高度碎片化的DataFrame，并且需要进行后续操作，copy()操作可以强制Pandas重新组织内存，从而改善后续操作的性能。但这并不能解决创建列时产生碎片化的问题，而是在碎片化发生后的一种补救措施。对于创建新列的场景，最好的方法是避免碎片化的发生，即使用pd.concat等批量创建方式。

总结

PerformanceWarning: DataFrame is highly fragmented是Pandas在检测到潜在性能问题时发出的重要提示。当需要从现有列中解析并创建大量新列时，应避免迭代式地使用df['new_col'] = ...语法。通过将所有新列的创建逻辑封装在一个字典推导式中，然后利用pd.concat(axis=1)一次性构建一个包含所有新列的DataFrame，最后使用df.join()将其与原始DataFrame合并，可以有效地避免DataFrame碎片化，显著提升数据处理的效率和性能。掌握这种批量操作的技巧，对于优化大型数据集的Pandas处理流程至关重要。

以上就是Pandas DataFrame性能优化：高效处理“高度碎片化”警告与多列创建的详细内容，更多请关注php中文网其它相关文章！