基于另一个DataFrame条件更新列值的高效方法

引言：跨DataFrame条件性更新列的挑战

在数据处理和分析中，我们经常会遇到需要将一个DataFrame（源DataFrame）中的数据同步或更新到另一个DataFrame（目标DataFrame）中的场景。具体来说，当两个DataFrame之间存在共同的标识列（或多列）时，我们希望根据这些匹配的标识，将源DataFrame中特定列的值更新到目标DataFrame对应的行中。传统的做法可能涉及循环迭代，但这对于大型数据集而言效率低下。Pandas库提供了更高效、更“Pythonic”的解决方案。

Pandas update 方法详解

Pandas DataFrame对象提供了一个强大的 update 方法，专门用于将一个DataFrame中的值更新到另一个DataFrame中。其核心原理是基于索引对齐进行更新。当与 set_index 方法结合使用时，update 能够实现复杂的条件性更新，而无需显式循环。

核心原理

df1.update(df2) 的基本行为是：

1. 它会尝试将 df2 中的值更新到 df1 中。
2. 更新是基于DataFrame的索引进行的。如果两个DataFrame的索引有重叠，并且列名也相同，那么 df1 中对应位置的值将被 df2 中的值覆盖。
3. 默认情况下，update 方法只会用 df2 中非 NaN 的值去更新 df1 中对应位置的值。如果 df2 中的值为 NaN，则 df1 中对应位置的值不会被改变。

与 set_index 结合使用

为了实现基于特定列的条件更新，我们可以先使用 set_index 方法将用于匹配的列设置为DataFrame的索引。这样，update 方法就能根据这些“匹配列”的值进行对齐。

例如，如果我们想根据 ID 和 Name 列来匹配并更新 Type 列，可以这样做：

1. 将目标DataFrame（例如 df2）的 ID 和 Name 列设置为索引。
2. 将源DataFrame（例如 df1）的 ID 和 Name 列设置为索引，并仅选择需要更新的列（例如 Type）。
3. 使用目标DataFrame的 update 方法，传入经过处理的源DataFrame。

实现方案：update_columns 函数

为了封装这种常见的操作，我们可以创建一个通用的函数 update_columns。

代码示例

import pandas as pd

def update_columns(df_target, df_source, match_cols, update_cols):
    """
    根据匹配列的值，将源DataFrame的指定列更新到目标DataFrame中。

    参数:
    df_target (pd.DataFrame): 目标DataFrame，其列将被更新。
    df_source (pd.DataFrame): 源DataFrame，提供更新数据。
    match_cols (list): 用于匹配行的列名列表。
    update_cols (list): 需要从df_source更新到df_target的列名列表。

    返回:
    pd.DataFrame: 更新后的目标DataFrame。
    """
    # 将目标DataFrame和源DataFrame都以匹配列设置为索引
    # 注意：update方法是就地修改的，所以我们操作的是一个副本或先将df_target设置为res
    # 为了保持df_target的原始结构（非索引列），我们先将df_target的副本设置为res
    # 然后对其进行update操作，最后重置索引

    # 确保操作的是副本，避免直接修改传入的df_target
    res = df_target.set_index(match_cols)

    # 将源DataFrame也以匹配列设置为索引，并只选择需要更新的列
    # update方法会根据索引和列名进行对齐更新
    source_data_for_update = df_source.set_index(match_cols)[update_cols]

    # 执行更新操作。res（df_target的副本）将根据source_data_for_update进行更新
    res.update(source_data_for_update)

    # 重置索引，将匹配列变回普通列，并返回更新后的DataFrame
    return res.reset_index()

# 示例数据
df1 = pd.DataFrame({
    'ID': [1, 2, 3, 5], 
    'Name': ['client', 'detail_client', 'operations', 'audit'],
    'Type': ['str', 'var', 'str', 'nvar']
})

df2 = pd.DataFrame({
    'ID': [5, 3, 7, 2], 
    'Name': ['audit', 'operations', 'C', 'detail_client'],
    'Type': ['nan', 'nan', 'nan', 'nan'] # 注意：这里的'nan'是字符串，不是NaN值
})

print("原始 df1:")
print(df1)
print("\n原始 df2:")
print(df2)

# 调用函数更新df2的'Type'列，基于'ID'和'Name'进行匹配
updated_df2 = update_columns(df2, df1, ['ID', 'Name'], ['Type'])

print("\n更新后的 df2:")
print(updated_df2)

执行步骤分析

1. 设置索引 (df_target.set_index(match_cols) 和 df_source.set_index(match_cols)):

   • 这一步是关键。它将 df_target 和 df_source 的 ID 和 Name 列提升为DataFrame的索引。
   • update 方法在执行更新时，会根据这些索引进行精确的行匹配。只有当 df_target 和 df_source 的索引（即 ID 和 Name 的组合）完全一致时，才会进行更新。
   • 我们将 df_target 的索引化版本赋值给 res，因为 update 方法是就地修改的。

2. 选择待更新列 ([update_cols]):

   • 在对 df_source 设置索引后，我们只选择 update_cols（在本例中是 ['Type']）。这是因为 update 方法只更新具有相同列名的列。我们不希望 df_source 中的其他列（如果存在）影响到 df_target。

3. 执行更新 (res.update(source_data_for_update)):

   • res 是 df_target 的索引化副本。source_data_for_update 是 df_source 的索引化且仅包含 Type 列的部分。
   • Pandas 会查找 res 和 source_data_for_update 中索引（ID 和 Name 组合）和列名（Type）都匹配的位置。
   • 如果匹配成功，并且 source_data_for_update 中对应的值不是 NaN（在示例中是 'str', 'var', 'nvar' 等字符串），那么 res 中对应位置的 Type 值将被覆盖。
   • 例如，对于 df2 中的 (ID=5, Name='audit')，它在 df1 中有匹配项，其 Type 为 'nvar'，所以 df2 的 Type 从 'nan' 变成了 'nvar'。
   • 对于 df2 中的 (ID=7, Name='C')，在 df1 中没有匹配项，因此 df2 的 Type 值 'nan' 保持不变。

4. 重置索引 (res.reset_index()):

   • 更新完成后，res 的 ID 和 Name 列仍然是索引。
   • reset_index() 将这些索引变回普通的列，并返回一个全新的DataFrame，其结构与原始 df_target 相似，但 Type 列已根据条件进行了更新。

完整代码与运行结果

上述 update_columns 函数的完整代码及其在示例数据上的运行结果如下：

import pandas as pd

def update_columns(df_target, df_source, match_cols, update_cols):
    res = df_target.set_index(match_cols)
    source_data_for_update = df_source.set_index(match_cols)[update_cols]
    res.update(source_data_for_update)
    return res.reset_index()

df1 = pd.DataFrame({
    'ID': [1, 2, 3, 5], 
    'Name': ['client', 'detail_client', 'operations', 'audit'],
    'Type': ['str', 'var', 'str', 'nvar']
})

df2 = pd.DataFrame({
    'ID': [5, 3, 7, 2], 
    'Name': ['audit', 'operations', 'C', 'detail_client'],
    'Type': ['nan', 'nan', 'nan', 'nan']
})

print("原始 df1:")
print(df1)
print("\n原始 df2:")
print(df2)

updated_df2 = update_columns(df2, df1, ['ID', 'Name'], ['Type'])

print("\n更新后的 df2:")
print(updated_df2)

输出:

原始 df1:
   ID           Name  Type
0   1         client   str
1   2  detail_client   var
2   3     operations   str
3   5          audit  nvar

原始 df2:
   ID           Name Type
0   5          audit  nan
1   3     operations  nan
2   7              C  nan
3   2  detail_client  nan

更新后的 df2:
   ID           Name  Type
0   5          audit  nvar
1   3     operations   str
2   7              C   nan
3   2  detail_client   var

注意事项与最佳实践

1. update 方法的就地修改特性: df.update() 方法默认是就地修改调用它的DataFrame。在 update_columns 函数中，我们通过 res = df_target.set_index(match_cols) 创建了一个新的DataFrame res 来进行操作，从而避免直接修改传入的 df_target。最终返回的是 res 的重置索引版本。
2. NaN 值的处理: update 方法默认只会用非 NaN 的值去更新目标DataFrame中对应位置的值。如果源DataFrame中用于更新的值是 NaN，它不会覆盖目标DataFrame中已有的非 NaN 值。在示例中，df2['Type'] 包含的是字符串 'nan'，而非实际的 np.nan。因此，它被视为普通字符串，当有匹配项时会被源DataFrame中的值覆盖。如果 df2['Type'] 包含的是 np.nan，并且 df1 中对应位置的值是 'str'，那么 np.nan 也会被 'str' 覆盖。
3. 匹配列和更新列的选择: 确保 match_cols 列表中的列在两个DataFrame中都存在且数据类型兼容。update_cols 列表中的列必须在源DataFrame中存在，且是你希望同步到目标DataFrame的列。
4. 效率考量: 相比于使用 for 循环遍历行进行条件判断和赋值，set_index 结合 update 的方法利用了Pandas底层的优化，对于大型数据集而言，效率要高得多。它避免了Python层面的循环，将大部分计算推送到C语言实现，从而显著提升性能。
5. 列顺序: update 方法不会改变目标DataFrame中现有列的顺序。reset_index() 会将原索引列（即 match_cols）放在最前面，然后是其他列。如果需要特定的列顺序，可能需要后续进行 reindex 操作。

通过掌握 set_index 和 update 方法的组合使用，您可以高效、灵活地处理各种跨DataFrame的数据更新任务，提高数据处理代码的性能和可读性。

以上就是基于另一个DataFrame条件更新列值的高效方法的详细内容，更多请关注php中文网其它相关文章！