Pandas DataFrames：高效查找指定时间点之前的最近时间戳及时间差

本教程详细介绍了如何利用 pandas 库中的 `merge_asof` 函数，高效地在两个 dataframe 之间进行时间序列的前向匹配。文章将演示如何查找目标 dataframe 中每个时间戳之前（或相同时间）的最近匹配项，并计算它们之间的时间差（以秒为单位），从而解决复杂的时间数据对齐问题。

在数据分析和处理中，尤其是在处理时间序列数据时，我们经常需要将两个数据集基于时间进行关联。一个常见的需求是，对于一个数据集中的每个时间点，找到另一个数据集中在此时间点之前（或同时）发生的最近事件。这种“前向匹配”场景不能简单地通过常规的合并操作或仅查找“最近”的时间点来实现，因为它明确排除了未来事件。

问题描述：时间序列数据中的前向匹配需求

假设我们有两个 Pandas DataFrame，df 包含主时间序列事件，dflogs 包含日志或辅助事件的时间戳。我们的目标是为 df 中的每个事件，在 dflogs 中找到其发生时间之前或与之相同时间的最接近的事件，并计算两者之间的时间差（以秒为单位）。

考虑以下示例数据：

df DataFrame (主事件):

             datetime
0 2023-11-15 18:00:00
1 2023-11-20 19:00:00
2 2023-11-20 20:00:00
3 2023-11-20 21:00:00

dflogs DataFrame (日志事件):

             datetime
0 2023-11-17 18:00:00
1 2023-11-20 20:00:00

我们期望的输出结果应包含 df 中的原始时间戳，匹配到的 dflogs 中的时间戳，以及它们之间的秒级时间差：

             datetime             logtime      diff
0 2023-11-15 18:00:00                 NaT       NaN  (无前向匹配)
1 2023-11-20 19:00:00 2023-11-17 18:00:00  262800.0  (2023-11-20 19:00:00 - 2023-11-17 18:00:00)
2 2023-11-20 20:00:00 2023-11-20 20:00:00       0.0  (2023-11-20 20:00:00 - 2023-11-20 20:00:00)
3 2023-11-20 21:00:00 2023-11-20 20:00:00    3600.0  (2023-11-20 21:00:00 - 2023-11-20 20:00:00)

直接使用 df.apply() 结合循环或复杂条件判断通常效率低下，尤其是在处理大型数据集时。

解决方案：使用 pd.merge_asof 实现前向合并

Pandas 提供了 pd.merge_asof 函数，专门用于执行“最近邻”合并，它在合并键（通常是时间戳）上进行近似匹配。对于我们这种只查找“之前”或“同时”发生的事件的需求，merge_asof 的 direction='backward' 参数是理想的选择。

direction='backward' 意味着对于左侧 DataFrame 中的每个行，它会在右侧 DataFrame 中查找键值小于或等于当前行的最近匹配项。

首先，我们创建示例数据：

Dreamina

字节跳动推出的AI绘画工具，用简单的文案创作精美的图片

436

查看详情

import pandas as pd

# 创建 df DataFrame
data_df = {
    'datetime': pd.to_datetime([
        '2023-11-15T18:00:00',
        '2023-11-20T19:00:00',
        '2023-11-20T20:00:00',
        '2023-11-20T21:00:00'
    ])
}
df = pd.DataFrame(data_df)

# 创建 dflogs DataFrame
data_dflogs = {
    'datetime': pd.to_datetime([
        '2023-11-17T18:00:00',
        '2023-11-20T20:00:00'
    ])
}
dflogs = pd.DataFrame(data_dflogs)

print("df DataFrame:")
print(df)
print("\ndflogs DataFrame:")
print(dflogs)

输出：

df DataFrame:
             datetime
0 2023-11-15 18:00:00
1 2023-11-20 19:00:00
2 2023-11-20 20:00:00
3 2023-11-20 21:00:00

dflogs DataFrame:
             datetime
0 2023-11-17 18:00:00
1 2023-11-20 20:00:00

接下来，执行 merge_asof 操作：

# 使用 merge_asof 进行前向合并
# 为了区分 df 和 dflogs 中的 'datetime' 列，我们给 dflogs 的 datetime 列重命名为 'logtime'
merged_df = pd.merge_asof(
    df[['datetime']],
    dflogs[['datetime']].assign(logtime=dflogs['datetime']),
    on='datetime',
    direction='backward'
)

print("\n合并结果 (merged_df):")
print(merged_df)

输出：

合并结果 (merged_df):
             datetime             logtime
0 2023-11-15 18:00:00                 NaT
1 2023-11-20 19:00:00 2023-11-17 18:00:00
2 2023-11-20 20:00:00 2023-11-20 20:00:00
3 2023-11-20 21:00:00 2023-11-20 20:00:00

在上述代码中：

• df[['datetime']] 作为左侧 DataFrame。
• dflogs[['datetime']].assign(logtime=dflogs['datetime']) 作为右侧 DataFrame。这里使用 assign 的目的是将 dflogs 中的 datetime 列复制一份并命名为 logtime，这样在合并后，我们既能保留 df 的原始 datetime，又能获取匹配到的 dflogs 的时间戳，方便后续计算。
• on='datetime' 指定了用于匹配的列。
• direction='backward' 是核心，它确保只匹配到当前时间戳之前或相同的时间戳。

计算时间差异

合并完成后，merged_df 中包含了 df 的原始 datetime 和匹配到的 dflogs 的 logtime。现在我们可以轻松计算它们之间的时间差，并将其转换为秒：

# 计算时间差异并转换为秒
merged_df['diff_seconds'] = (merged_df['datetime'] - merged_df['logtime']).dt.total_seconds()

print("\n最终结果 (带时间差):")
print(merged_df)

输出：

最终结果 (带时间差):
             datetime             logtime  diff_seconds
0 2023-11-15 18:00:00                 NaT           NaN
1 2023-11-20 19:00:00 2023-11-17 18:00:00      262800.0
2 2023-11-20 20:00:00 2023-11-20 20:00:00           0.0
3 2023-11-20 21:00:00 2023-11-20 20:00:00        3600.0

merged_df['datetime'] - merged_df['logtime'] 会得到一个 Timedelta 对象。通过 .dt.total_seconds() 方法，我们可以将其转换为总秒数。对于没有匹配项的行（如 2023-11-15 18:00:00），logtime 将是 NaT (Not a Time)，计算出的 diff_seconds 将是 NaN (Not a Number)。

注意事项与最佳实践

1. 数据类型: 确保用于合并的列（本例中的 datetime）是 Pandas datetime 类型。如果不是，需要使用 pd.to_datetime() 进行转换。
2. 排序: pd.merge_asof 要求用于匹配的 on 列在两个 DataFrame 中都必须是已排序的（升序）。如果数据未排序，请务必在合并前使用 .sort_values() 进行排序，否则结果可能不准确。

   df = df.sort_values('datetime')
   dflogs = dflogs.sort_values('datetime')

   登录后复制
3. 性能: merge_asof 是高度优化的 C 实现，对于大型数据集，其性能远优于 Python 循环或 apply 方法。
4. 处理 NaT 值: 当左侧 DataFrame 中的时间戳在右侧 DataFrame 中没有符合 direction 条件的匹配项时，匹配到的列将填充 NaT。在计算时间差时，这会导致 NaN。根据具体需求，可能需要对这些 NaN 值进行填充（例如，用 0 或其他默认值），或将其过滤掉。
5. tolerance 参数: merge_asof 还有一个 tolerance 参数，可以指定匹配的最大时间容忍度。例如，tolerance=pd.Timedelta('1 hour') 将只匹配在1小时内的事件。本例中我们不需要此参数，因为我们希望找到的是“最近”的。
6. by 参数: 如果需要按其他分类列（例如用户ID、设备ID）进行分组匹配，可以使用 by 参数。例如，pd.merge_asof(..., on='datetime', by='user_id', direction='backward')。

总结

pd.merge_asof 结合 direction='backward' 为在 Pandas DataFrame 中执行前向时间序列匹配提供了一个强大且高效的解决方案。它简化了复杂的逻辑，使得从海量时间数据中提取特定时间关系变得轻而易举。掌握这一工具对于进行时间序列分析、日志关联、事件溯源等任务至关重要。

以上就是Pandas DataFrames：高效查找指定时间点之前的最近时间戳及时间差的详细内容，更多请关注php中文网其它相关文章！