Pandas基于时间范围高效合并DataFrame的指南

本教程详细介绍了如何在Pandas中高效地合并两个DataFrame，其中一个DataFrame的时间列需要落在另一个DataFrame的两个时间列所定义的区间内。针对传统循环合并的性能瓶颈，文章提出并演示了利用NumPy广播机制进行向量化比较，从而实现显著的性能提升。教程涵盖了数据准备、广播逻辑、结果重构及重要的内存和索引处理注意事项。

在数据分析和处理中，我们经常需要根据复杂的条件来合并（join）或连接（merge）不同的数据集。当合并条件涉及到时间范围匹配时，例如判断一个时间点是否落在一个时间区间内，传统的基于循环的迭代方法往往效率低下，尤其是在处理大型数据集时。本教程将深入探讨如何利用Pandas和NumPy的强大功能，以高性能的方式解决这类时间范围合并问题。

场景描述

假设我们有两个Pandas DataFrame：

• df1 包含时间区间信息，例如 time_1 和 time_2 列，以及其他数据 dummy_data。
• df2 包含一系列时间点，例如 time_3 列，以及其他数据 dummy_data2。

我们的目标是：将 df2 中的每一行与 df1 中的行进行匹配，条件是 df2 的 time_3 值必须严格介于 df1 的 time_1 和 time_2 之间（即 time_1

示例数据结构：

df1 示例：

df2 示例：

期望的输出结果：

传统（低效）的解决方案

一种直观但效率低下的方法是使用嵌套循环遍历 df1 的每一行，然后对 df2 的 time_3 列应用 between 方法，最后通过 append 或 concat 逐行构建结果DataFrame。

薏米AI

YMI.AI-快捷、高效的人工智能创作平台

下载

import pandas as pd

# 假设 df1 和 df2 已经加载并处理好时间列
# df1['time_1'] = pd.to_datetime(df1['time_1'])
# df1['time_2'] = pd.to_datetime(df1['time_2'])
# df2['time_3'] = pd.to_datetime(df2['time_3'])

# ... (省略数据加载和类型转换代码)

# 模拟数据
data1 = {
    'time_1': pd.to_datetime(['2023-10-01 04:02:00', '2023-10-01 04:03:00']),
    'time_2': pd.to_datetime(['2023-10-01 08:29:00', '2023-10-01 08:49:00']),
    'dummy_data': [-245.669907, -1772.948571]
}
df1 = pd.DataFrame(data1)

data2 = {
    'time_3': pd.to_datetime([
        '2023-10-01 06:21:13.238024', '2023-10-01 06:47:19.796628',
        '2023-10-01 07:37:06.438740', '2023-10-01 08:16:16.995256',
        '2023-10-01 08:33:53.081095'
    ]),
    'dummy_data2': [-131.367901, -236.277444, 5.915493, -134.032433, -103.733212]
}
df2 = pd.DataFrame(data2)

output_df = pd.DataFrame()
for i in df1.index:
    # 找到 df2 中 time_3 落在当前 df1 行时间区间内的索引
    # 注意：原始问题中的 `inclusive='left'` 意味着 time_1 <= time_3 < time_2
    # 这里为了演示，我们先使用严格小于，与后续NumPy解法保持一致 (time_1 < time_3 < time_2)
    s = (df2['time_3'] > df1.loc[i, 'time_1']) & \
        (df2['time_3'] < df1.loc[i, 'time_2'])

    matching_df2_indices = s[s].index.tolist()

    for idx in matching_df2_indices:
        # 逐行合并，效率低下
        output_df = pd.concat([output_df, 
                               pd.concat([df1.loc[[i]], df2.loc[[idx]]], axis=1)], 
                              ignore_index=True)

# print(output_df) # 打印结果

这种方法存在严重的性能问题：

1. 迭代开销： 嵌套循环在Python中本身就比较慢。
2. DataFrame操作： 频繁的 df.loc 访问和 pd.concat（尤其是 append，在Pandas 2.0后已弃用并推荐使用 concat）操作会创建大量中间DataFrame，导致内存碎片和性能下降。

优化方案：利用NumPy广播机制

为了大幅提升性能，我们可以采用NumPy的广播（Broadcasting）机制。广播允许NumPy在不同形状的数组之间执行算术运算，而无需显式地复制数据。通过将DataFrame的时间列转换为NumPy数组，我们可以一次性完成所有行之间的比较，生成一个布尔矩阵，然后根据这个矩阵高效地重构结果。

核心思想

1. 将 df1 的 time_1 和 time_2 列转换为二维NumPy数组，形状为 (N, 1)。
2. 将 df2 的 time_3 列转换为一维NumPy数组，形状为 (M,)。
3. 利用NumPy的广播特性，对 (N, 1) 数组与 (M,) 数组进行比较操作。例如，(N, 1)
4. 将多个比较结果组合成一个最终的 (N, M) 布尔矩阵，表示 df1 的第 i 行与 df2 的第 j 行是否匹配。
5. 使用 numpy.nonzero() 获取布尔矩阵中所有 True 值的坐标 (x, y)，其中 x 是 df1 的行索引，y 是 df2 的行索引。
6. 根据这些坐标，使用 df.iloc 批量选择 df1 和 df2 中对应的行，并通过 pd.concat 合并它们。

详细步骤与示例代码

import pandas as pd
import numpy as np

# 1. 准备示例数据 (与上述相同)
data1 = {
    'time_1': pd.to_datetime(['2023-10-01 04:02:00', '2023-10-01 04:03:00']),
    'time_2': pd.to_datetime(['2023-10-01 08:29:00', '2023-10-01 08:49:00']),
    'dummy_data': [-245.669907, -1772.948571]
}
df1 = pd.DataFrame(data1)

data2 = {
    'time_3': pd.to_datetime([
        '2023-10-01 06:21:13.238024', '2023-10-01 06:47:19.796628',
        '2023-10-01 07:37:06.438740', '2023-10-01 08:16:16.995256',
        '2023-10-01 08:33:53.081095'
    ]),
    'dummy_data2': [-131.367901, -236.277444, 5.915493, -134.032433, -103.733212]
}
df2 = pd.DataFrame(data2)

# 确保DataFrame的索引是唯一的，如果不是，可以使用 reset_index(drop=True)
# 否则，iloc[x] 或 iloc[y] 可能无法正确对应原始DataFrame的行。
df1 = df1.reset_index(drop=True)
df2 = df2.reset_index(drop=True)

# 2. 转换为NumPy数组并进行形状调整
# .to_numpy() 将 Pandas Series 转换为 NumPy 数组
# [:, None] 将一维数组转换为二维列向量，例如 (N,) 变为 (N, 1)
t1 = df1["time_1"].to_numpy()[:, None]  # 形状 (N, 1)
t2 = df1["time_2"].to_numpy()[:, None]  # 形状 (N, 1)
t3 = df2["time_3"].to_numpy()          # 形状 (M,)

# 3. 执行广播比较
# (N, 1) 形状的 t1 与 (M,) 形状的 t3 进行比较，结果是 (N, M) 的布尔矩阵
# 例如，t1 < t3 会比较 df1 的每一行 time_1 与 df2 的所有 time_3
# 同样，t3 < t2 会比较 df2 的所有 time_3 与 df1 的每一行 time_2
# 两个布尔矩阵通过 & 运算符进行逻辑与操作
match_matrix = (t1 < t3) & (t3 < t2)

# 4. 获取匹配的行索引
# .nonzero() 返回一个元组，包含所有 True 值的坐标。
# x 是 df1 中匹配行的索引数组，y 是 df2 中匹配行的索引数组。
x, y = match_matrix.nonzero()

# 5. 重构结果 DataFrame
# df1.iloc[x] 批量选择 df1 中所有匹配的行
# df2.iloc[y] 批量选择 df2 中所有匹配的行
# reset_index(drop=True) 确保合并后的索引是连续的
result_df = pd.concat(
    [
        df1.iloc[x].reset_index(drop=True),
        df2.iloc[y].reset_index(drop=True),
    ],
    axis=1, # 沿列方向合并
)

print(result_df)

输出结果：

                   time_1              time_2  dummy_data                     time_3  dummy_data2
0 2023-10-01 04:02:00 2023-10-01 08:29:00  -245.669907 2023-10-01 06:21:13.238024  -131.367901
1 2023-10-01 04:02:00 2023-10-01 08:29:00  -245.669907 2023-10-01 06:47:19.796628  -236.277444
2 2023-10-01 04:03:00 2023-10-01 08:49:00 -1772.948571 2023-10-01 06:21:13.238024  -131.367901
3 2023-10-01 04:03:00 2023-10-01 08:49:00 -1772.948571 2023-10-01 06:47:19.796628  -236.277444
4 2023-10-01 04:03:00 2023-10-01 08:49:00 -1772.948571 2023-10-01 08:33:53.081095  -103.733212

注意事项

1. 内存消耗： NumPy广播会创建一个 N * M 大小的布尔矩阵。如果 df1 和 df2 的行数 N 和 M 都非常大，这个矩阵可能会占用大量内存，甚至导致内存溢出（OOM）。在处理超大型数据集时，需要评估这种方法的内存可行性，或者考虑使用Dask等分布式计算框架。

2. 索引处理： 在使用 df.iloc[x] 和 df.iloc[y] 之前，建议先对 df1 和 df2 调用 reset_index(drop=True)。这是为了确保 iloc 能够基于连续的整数位置索引正确地选择行，避免因原始DataFrame的非连续或非零开始索引导致的潜在问题。

3. 条件灵活性： NumPy广播的优势在于可以轻松扩展合并条件。例如，如果除了时间范围匹配外，还需要某个额外的属性也匹配，只需在 match_matrix 的计算中添加更多条件即可：

   # 假设 df1 和 df2 都有一个 'category' 列需要匹配
   category1 = df1['category'].to_numpy()[:, None]
   category2 = df2['category'].to_numpy()
   
   match_matrix = (t1 < t3) & (t3 < t2) & (category1 == category2)
   x, y = match_matrix.nonzero()

4. 区间包容性： 原始问题中 between 方法使用了 inclusive='left'，这意味着 time_1

   • [time_1, time_2) (左闭右开): (t1
   • (time_1, time_2] (左开右闭): `(t1