高效处理变长列表数据并合并至Pandas DataFrame的教程

本教程旨在解决将长度不一的列表数据作为新列高效地添加到现有pandas dataframe中的问题，尤其是在循环场景下避免性能瓶颈。我们将探讨如何利用python的`itertools.zip_longest`函数处理变长列表，并结合pandas的dataframe构造与`concat`方法，实现数据规整化和高效合并，从而避免“dataframe高度碎片化”的性能警告。

挑战：合并变长列表数据至DataFrame

在数据处理过程中，我们经常会遇到需要将结构不规则的数据（例如，长度不一的列表）合并到Pandas DataFrame的场景。一个典型的例子是，我们有一组列名列表（list1）和一组包含行数据的列表（list2），其中list2的每个子列表长度可能不同，且其行数需要与现有DataFrame的行数匹配。直接尝试使用df[list1] = pd.DataFrame(list2, index=df.index) 可能会导致PerformanceWarning: DataFrame is highly fragmented，尤其当此操作在循环中重复执行时，会严重影响性能。

以下是具体的数据示例：

import pandas as pd
from itertools import zip_longest

# 现有DataFrame
df = pd.DataFrame([
    ['Alex', 33, 'Male'],
    ['Marly', 28, 'Female'],
    ['Charlie', 30, 'Female'],
    ['Mimi', 37, 'Female'],
    ['James', 44, 'Male'],
    ['Jone', 25, 'Male']
], columns=['Name', 'Age', 'Gender'])

# 待添加的列名
list1 = ['col1', 'col2', 'col3', 'col4']

# 待添加的行数据，子列表长度不一
list2 = [[1, 2, 3], [2, 3], [1, 8, 4, 3], [22, 35, 32], [65], [2, 45, 55]]

print("原始DataFrame:")
print(df)
print("\n待添加的列名 (list1):")
print(list1)
print("\n待添加的行数据 (list2):")
print(list2)

期望的输出是将list1作为新的列标题，list2的数据填充到这些列中，对于长度不足的行，缺失值用0填充，最终结果与原DataFrame按列合并：

      name  age  Gender  col1  col2  col3  col4
0     Alex   33    Male     1     2     3     0
1    Marly   28  Female     2     3     0     0
2  Charlie   30  Female     1     8     4     3
3     Mimi   37  Female    22    35    32     0
4    James   44    Male    65     0     0     0
5     Jone   25    Male     2    45    55     0

解决方案：利用 itertools.zip_longest 和 Pandas concat

解决此问题的关键在于两点：

1. 规整化变长列表数据：使用 itertools.zip_longest 确保所有子列表具有相同的长度，并用指定值（如0）填充缺失部分。
2. 高效构建新DataFrame并合并：将规整后的数据直接构建成一个新DataFrame，然后使用 pd.concat 与原始DataFrame进行列合并，避免逐列添加导致的性能问题。

下面是详细的实现步骤和代码：

步骤一：规整化 list2 数据

itertools.zip_longest 函数可以接受多个可迭代对象作为参数，并会生成一个迭代器，每次产出一个元组，包含每个可迭代对象的下一个元素。如果某个可迭代对象提前耗尽，它会用 fillvalue 填充相应位置。

为了将 list2 中的子列表规整化为相同长度，我们需要一个巧妙的 zip 组合： zip_longest(*list2, fillvalue=0)：

• *list2 将 list2 解包为独立的参数，即 zip_longest([1, 2, 3], [2, 3], [1, 8, 4, 3], ...)。
• 这会进行“列式”填充，即处理 list2 的第一个元素、第二个元素等，直到最长的子列表结束。例如，它会生成 (1, 2, 1, 22, 65, 2) (所有子列表的第一个元素)，然后 (2, 3, 8, 35, 0, 45) (所有子列表的第二个元素，其中[65]的第二个元素被0填充)。
• 结果是一个迭代器，其元素是原始 list2 的“转置”版本，且所有“行”（原始子列表的对应索引）都已填充至相同长度。

zip(*zip_longest(*list2, fillvalue=0))：

• 对上一步的结果再次使用 *zip 进行解包和转置。
• 这次转置将把数据恢复到“行式”结构，但现在所有子列表都具有相同的长度，并且缺失值已用 fillvalue (这里是 0) 填充。
• 例如，它会生成 (1, 2, 3, 0)、(2, 3, 0, 0) 等，每个元组代表一个原始子列表，但已填充至最大长度（即 list1 的长度，或 list2 中最长子列表的长度，这里是4）。

步骤二：构建新 DataFrame

规整化后的数据（例如 (1, 2, 3, 0)）可以直接与 list1 中的列名结合，形成字典 { 'col1': 1, 'col2': 2, 'col3': 3, 'col4': 0 }。我们可以通过列表推导式为 list2 的每一行生成这样的字典，然后将这些字典的列表传递给 pd.DataFrame 构造函数。

序列猴子开放平台

具有长序列、多模态、单模型、大数据等特点的超大规模语言模型

0

查看详情

[dict(zip(list1, vals)) for vals in ...]：

• 对于规整化后的 list2 中的每个 vals (例如 (1, 2, 3, 0)), zip(list1, vals) 会将列名和值配对。
• dict(...) 将这些配对转换为字典。
• 最终得到一个字典列表，每个字典代表新DataFrame的一行数据。

pd.DataFrame(...)：

• 使用这个字典列表直接创建一个新的DataFrame。Pandas 会自动识别字典的键作为列名。

步骤三：合并 DataFrame

最后，使用 pd.concat 函数将原始DataFrame (df) 和新创建的DataFrame按列 (axis=1) 进行合并。pd.concat 是 Pandas 中用于连接DataFrame的推荐方法，它通常比逐列赋值更高效。

完整的解决方案代码如下：

import pandas as pd
from itertools import zip_longest

# 原始数据 (同上)
df = pd.DataFrame([
    ['Alex', 33, 'Male'],
    ['Marly', 28, 'Female'],
    ['Charlie', 30, 'Female'],
    ['Mimi', 37, 'Female'],
    ['James', 44, 'Male'],
    ['Jone', 25, 'Male']
], columns=['Name', 'Age', 'Gender'])
list1 = ['col1', 'col2', 'col3', 'col4']
list2 = [[1, 2, 3], [2, 3], [1, 8, 4, 3], [22, 35, 32], [65], [2, 45, 55]]

# 核心解决方案
# 1. 使用 zip_longest 规整化 list2 的子列表长度，用 0 填充
# 2. 再次 zip 转置，使每行数据成为一个元组
normalized_list2 = zip(*zip_longest(*list2, fillvalue=0))

# 3. 将规整后的数据与 list1 结合，创建字典列表
# 4. 使用字典列表构建一个新的 DataFrame
new_cols_df = pd.DataFrame([dict(zip(list1, vals)) for vals in normalized_list2])

# 5. 使用 pd.concat 将新 DataFrame 与原始 DataFrame 按列合并
out_df = pd.concat([df, new_cols_df], axis=1)

print("\n合并后的DataFrame:")
print(out_df)

输出结果：

合并后的DataFrame:
      Name  Age  Gender  col1  col2  col3  col4
0     Alex   33    Male     1     2     3     0
1    Marly   28  Female     2     3     0     0
2  Charlie   30  Female     1     8     4     3
3     Mimi   37  Female    22    35    32     0
4    James   44    Male    65     0     0     0
5     Jone   25    Male     2    45    55     0

注意事项与最佳实践

1. fillvalue 的选择：zip_longest 中的 fillvalue 参数非常重要。它决定了当子列表长度不足时填充什么值。在本例中，我们选择了 0，因为它与数值数据兼容。根据实际需求，也可以选择 None、np.nan 或其他默认值。
2. 数据类型：如果 fillvalue 的类型与 list2 中数据的类型不一致，可能会导致新列的数据类型变为 object 或 float (如果原数据是 int 且 fillvalue 是 np.nan)。在合并后，如果需要特定的数据类型，可以使用 df.astype() 进行转换。
3. 循环中的效率：如果这个操作确实在一个大循环中进行，并且 list1 和 list2 在每次迭代中都会更新，那么上述方法仍然是高效的。关键在于每次迭代都构建一个 完整的 new_cols_df，然后与 当前 的 df 进行合并。避免在循环内部逐个添加列，因为这会导致 DataFrame 的频繁重构。
4. 大规模数据处理：对于极大规模的数据，如果 list2 的行数非常庞大，考虑分块处理（batch processing）。每次处理一部分 list2，生成一个 new_cols_df，然后与 df 合并。

总结

本教程提供了一种健壮且高效的方法，用于将变长列表数据作为新列添加到 Pandas DataFrame。通过巧妙地结合 itertools.zip_longest 进行数据规整化，并利用 Pandas 的 DataFrame 构造函数和 pd.concat 进行批量操作，我们能够有效避免常见的性能问题，如“DataFrame高度碎片化”警告。这种方法尤其适用于需要动态添加数据且数据结构不规则的场景，确保了代码的性能和可维护性。

以上就是高效处理变长列表数据并合并至Pandas DataFrame的教程的详细内容，更多请关注php中文网其它相关文章！