Pandas DataFrame中NumPy数组列的展开与重构为新列

本教程详细介绍了如何在pandas dataframe中将包含numpy数组的“键”和“值”列展开为新的独立列。文章提供了两种核心场景的解决方案：当所有行的“键”数组相同时，以及当“键”数组在不同行之间存在差异时。通过使用pandas的`join`、`dataframe`构造函数和列表推导等功能，可以高效地将数组内容转换为结构化的dataframe新列，并处理可能出现的缺失值。

在数据分析和处理中，我们经常会遇到DataFrame的某一列或几列中存储着数组（如NumPy数组或Python列表）的情况。当这些数组包含结构化的信息，例如键值对，并且我们希望将这些键作为新的列名，将对应的值作为新列的数据时，就需要进行列的展开和重构。本教程将深入探讨如何使用Pandas库实现这一目标，涵盖两种常见的场景：键在所有行中保持一致，以及键在不同行中可能不一致。

场景一：键在所有行中保持一致

当DataFrame中存储键的NumPy数组在所有行中都相同时，我们可以利用这一特性进行高效的转换。

原始数据结构示例

假设我们有一个DataFrame，其中包含两列keys和values，它们都是NumPy数组类型，并且keys列在所有行中的内容都相同。

import pandas as pd
import numpy as np

source_df = pd.DataFrame(
    [
        ['data_A1', 'data_B1', np.array(['key1', 'key2', 'key3']), np.array(['value1a', 'value2a', 'value3a'])],
        ['data_A2', 'data_B2', np.array(['key1', 'key2', 'key3']), np.array(['value1b', 'value2b', 'value3b'])],
        ['data_A3', 'data_B3', np.array(['key1', 'key2', 'key3']), np.array(['value1c', 'value2c', 'value3c'])]
    ],
    columns=['Col A', 'Col B', 'keys', 'values']
)
print("原始 DataFrame:")
print(source_df)

输出的source_df将如下所示：

原始 DataFrame:
    Col A    Col B              keys                   values
0  data_A1  data_B1  [key1, key2, key3]  [value1a, value2a, value3a]
1  data_A2  data_B2  [key1, key2, key3]  [value1b, value2b, value3b]
2  data_A3  data_B3  [key1, key2, key3]  [value1c, value2c, value3c]

我们的目标是将其转换为：

    Col A    Col B     key1     key2     key3
0  data_A1  data_B1  value1a  value2a  value3a
1  data_A2  data_B2  value1b  value2b  value3b
2  data_A3  data_B3  value1c  value2c  value3c

解决方案

在这种情况下，我们可以通过以下步骤实现转换：

1. 提取并转换值数组：将values列中的NumPy数组转换为Python列表，然后使用pd.DataFrame构造函数将其转换为一个新的DataFrame。
2. 确定新列名：由于keys在所有行中都相同，我们可以直接使用第一行（或任意一行）的keys数组作为新DataFrame的列名。
3. 合并回原DataFrame：将原始DataFrame中不需要的keys和values列删除，然后将新生成的DataFrame与原始DataFrame进行合并（join）。

# 方案一：创建新的DataFrame并合并
output_df_method1 = (source_df.drop(columns=['keys', 'values'])
                     .join(pd.DataFrame(source_df['values'].tolist(),
                                        columns=source_df['keys'].iloc[0]))
                    )
print("\n方案一转换后的 DataFrame:")
print(output_df_method1)

代码解析：

序列猴子开放平台

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

0

查看详情

• source_df.drop(columns=['keys', 'values']): 创建一个移除了keys和values列的DataFrame副本。
• source_df['values'].tolist(): 将values列中的每个NumPy数组转换为Python列表。这将得到一个列表的列表，例如 [['value1a', 'value2a', 'value3a'], ['value1b', 'value2b', 'value3b'], ...]。
• source_df['keys'].iloc[0]: 访问keys列的第一行元素，即['key1', 'key2', 'key3']，这将被用作新DataFrame的列名。
• pd.DataFrame(..., columns=...): 使用上述列表的列表作为数据，以及提取的键作为列名，构造一个新的DataFrame。
• .join(...): 将原始DataFrame（已删除keys和values列）与新构造的DataFrame按索引合并。

替代方案：原地修改

如果你希望直接在原始DataFrame上进行修改，可以使用pop方法结合赋值操作：

# 方案二：原地修改 DataFrame
# 为了演示，我们先复制一份原始数据
df_in_place = source_df.copy()

# 使用 pop 移除 'keys' 和 'values' 列，并获取它们的内容
# pop('keys') 会返回 'keys' 列的 Series，其 .iloc[0] 提供了列名
# pop('values') 会返回 'values' 列的 Series，其 .tolist() 提供了数据
df_in_place[df_in_place.pop('keys').iloc[0]] = pd.DataFrame(df_in_place.pop('values').tolist())

print("\n方案二原地修改后的 DataFrame:")
print(df_in_place)

代码解析：

• df_in_place.pop('keys'): 从df_in_place中移除keys列，并返回该列的Series。我们通过.iloc[0]获取其第一个元素（即所有行的共同键数组）作为新列名。
• df_in_place.pop('values'): 从df_in_place中移除values列，并返回该列的Series。我们通过.tolist()将其转换为列表的列表。
• pd.DataFrame(...): 使用转换后的值数据创建一个临时的DataFrame。
• df_in_place[...] = ...: 将临时DataFrame赋值给由pop('keys')提取出的列名，从而将新列添加到df_in_place中。

场景二：键在不同行中不一致

当keys列中的NumPy数组在不同行之间可能存在差异时，上述方法就不再适用，因为我们无法简单地取第一行的键作为所有列名。在这种情况下，我们需要为每一行独立地构建键值映射。

原始数据结构示例

考虑以下DataFrame，其中keys列在不同行中包含不同的键：

source_df_non_identical = pd.DataFrame(
    [
        ['data_A1', 'data_B1', np.array(['key1', 'key2', 'key3']), np.array(['value1a', 'value2a', 'value3a'])],
        ['data_A2', 'data_B2', np.array(['key3', 'key4', 'key1']), np.array(['value3b', 'value4b', 'value1b'])],
        ['data_A3', 'data_B3', np.array(['key5', 'key1']), np.array(['value5c', 'value1c'])]
    ],
    columns=['Col A', 'Col B', 'keys', 'values']
)
print("\n原始 DataFrame (键不一致):")
print(source_df_non_identical)

输出的source_df_non_identical将如下所示：

原始 DataFrame (键不一致):
    Col A    Col B              keys                       values
0  data_A1  data_B1  [key1, key2, key3]  [value1a, value2a, value3a]
1  data_A2  data_B2  [key3, key4, key1]  [value3b, value4b, value1b]
2  data_A3  data_B3      [key5, key1]      [value5c, value1c]

目标是将其转换为：

    Col A    Col B     key1     key2     key3     key4     key5
0  data_A1  data_B1  value1a  value2a  value3a      NaN      NaN
1  data_A2  data_B2  value1b      NaN  value3b  value4b      NaN
2  data_A3  data_B3  value1c      NaN      NaN      NaN  value5c

注意，对于某行中不存在的键，对应的新列位置将填充NaN。

解决方案

当键不一致时，我们需要为每一行创建键值映射（字典），然后将这些字典的列表转换为DataFrame。Pandas会智能地将所有唯一的键作为列名，并对缺失的键填充NaN。

output_df_non_identical = (source_df_non_identical.drop(columns=['keys', 'values'])
                           .join(pd.DataFrame([dict(zip(k, v)) for k, v in
                                               zip(source_df_non_identical['keys'],
                                                   source_df_non_identical['values'])]))
                          )
print("\n键不一致场景转换后的 DataFrame:")
print(output_df_non_identical)

代码解析：

• source_df_non_identical.drop(columns=['keys', 'values']): 同样，首先移除原始的keys和values列。
• zip(source_df_non_identical['keys'], source_df_non_identical['values']): 这会创建一个迭代器，每次迭代返回一对(key_array, value_array)，分别来自keys和values列的同一行。
• zip(k, v): 对于每一对(key_array, value_array)，内部的zip将键和值一一配对。
• dict(...): 将配对后的键值对转换为字典，例如 {'key1': 'value1a', 'key2': 'value2a', 'key3': 'value3a'}。
• [dict(...) for k, v in ...]: 这是一个列表推导式，它遍历所有行，为每一行生成一个键值字典，最终得到一个字典的列表。
• pd.DataFrame(...): 使用这个字典列表构造一个新的DataFrame。Pandas会自动识别所有字典中的唯一键，并将其作为列名，如果某个字典中缺少某个键，则对应的位置将填充NaN。
• .join(...): 将原始DataFrame（已删除keys和values列）与新构造的DataFrame按索引合并。

注意事项与总结

1. 性能考量：对于非常大的DataFrame，尤其是当keys和values列中的数组包含大量元素时，列表推导式或apply方法可能会有性能开销。在可能的情况下，优先使用Pandas内置的矢量化操作。对于键一致的场景，方案一通常效率更高。
2. 数据类型：展开后的新列的数据类型将取决于values数组中的元素类型。如果values数组中包含混合类型，或者在键不一致的场景中引入了NaN，Pandas可能会将列的数据类型提升（例如，整数列变为浮点数，或对象类型）。
3. 列名冲突：如果原始DataFrame中已经存在与keys数组中相同的列名，使用join或直接赋值时可能会导致列名冲突。在实际应用中，可能需要对keys进行预处理，例如添加前缀，以避免冲突。
4. 键的顺序：在键不一致的场景中，pd.DataFrame从字典列表构建时，新列的顺序可能不是固定的，或者会按照字典键的自然排序（如果所有键都是字符串）。如果需要特定的列顺序，可能需要在生成DataFrame后进行重新排序。

通过以上两种方案，无论keys列中的数组是完全一致还是各不相同，我们都能够灵活高效地将DataFrame中包含NumPy数组的列展开并重构为新的独立列，极大地提升了数据处理的灵活性和便利性。理解这些方法背后的逻辑，有助于在面对复杂数据结构时，选择最合适的处理策略。

以上就是Pandas DataFrame中NumPy数组列的展开与重构为新列的详细内容，更多请关注php中文网其它相关文章！