本教程详细介绍了如何在Pandas中高效地合并两个DataFrame，其中一个DataFrame的时间列需要落在另一个DataFrame的两个时间列所定义的区间内。针对传统循环合并的性能瓶颈，文章提出并演示了利用NumPy广播机制进行向量化比较，从而实现显著的性能提升。教程涵盖了数据准备、广播逻辑、结果重构及重要的内存和索引处理注意事项。
在数据分析和处理中，我们经常需要根据复杂的条件来合并（join）或连接（merge）不同的数据集。当合并条件涉及到时间范围匹配时，例如判断一个时间点是否落在一个时间区间内，传统的基于循环的迭代方法往往效率低下，尤其是在处理大型数据集时。本教程将深入探讨如何利用Pandas和NumPy的强大功能，以高性能的方式解决这类时间范围合并问题。
假设我们有两个Pandas DataFrame：
我们的目标是：将 df2 中的每一行与 df1 中的行进行匹配，条件是 df2 的 time_3 值必须严格介于 df1 的 time_1 和 time_2 之间（即 time_1
示例数据结构：
df1 示例：
| time_1 | time_2 | dummy_data |
|---|---|---|
| 2023-10-01 04:02:00 | 2023-10-01 08:29:00 | -245.67 |
| 2023-10-01 04:03:00 | 2023-10-01 08:49:00 | -1772.95 |
df2 示例：
| time_3 | dummy_data2 |
|---|---|
| 2023-10-01 06:21:13.238024 | -131.37 |
| 2023-10-01 06:47:19.796628 | -236.28 |
| 2023-10-01 08:33:53.081095 | -103.73 |
期望的输出结果：
| time_1 | time_2 | dummy_data | time_3 | dummy_data2 |
|---|---|---|---|---|
| 2023-10-01 04:02:00 | 2023-10-01 08:29:00 | -245.67 | 2023-10-01 06:21:13.238024 | -131.37 |
| 2023-10-01 04:02:00 | 2023-10-01 08:29:00 | -245.67 | 2023-10-01 06:47:19.796628 | -236.28 |
| 2023-10-01 04:03:00 | 2023-10-01 08:49:00 | -1772.95 | 2023-10-01 06:21:13.238024 | -131.37 |
| 2023-10-01 04:03:00 | 2023-10-01 08:49:00 | -1772.95 | 2023-10-01 06:47:19.796628 | -236.28 |
| 2023-10-01 04:03:00 | 2023-10-01 08:49:00 | -1772.95 | 2023-10-01 08:33:53.081095 | -103.73 |
一种直观但效率低下的方法是使用嵌套循环遍历 df1 的每一行，然后对 df2 的 time_3 列应用 between 方法，最后通过 append 或 concat 逐行构建结果DataFrame。
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) # 打印结果这种方法存在严重的性能问题：
为了大幅提升性能，我们可以采用NumPy的广播（Broadcasting）机制。广播允许NumPy在不同形状的数组之间执行算术运算，而无需显式地复制数据。通过将DataFrame的时间列转换为NumPy数组，我们可以一次性完成所有行之间的比较，生成一个布尔矩阵，然后根据这个矩阵高效地重构结果。
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
内存消耗： NumPy广播会创建一个 N * M 大小的布尔矩阵。如果 df1 和 df2 的行数 N 和 M 都非常大，这个矩阵可能会占用大量内存，甚至导致内存溢出（OOM）。在处理超大型数据集时，需要评估这种方法的内存可行性，或者考虑使用Dask等分布式计算框架。
索引处理： 在使用 df.iloc[x] 和 df.iloc[y] 之前，建议先对 df1 和 df2 调用 reset_index(drop=True)。这是为了确保 iloc 能够基于连续的整数位置索引正确地选择行，避免因原始DataFrame的非连续或非零开始索引导致的潜在问题。
条件灵活性： 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()
区间包容性： 原始问题中 between 方法使用了 inclusive='left'，这意味着 time_1
以上就是Pandas基于时间范围高效合并DataFrame的指南的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
136
收藏
