如何为700万行Pandas DataFrame高效实现带通配符的瀑布式规则匹配

场景说明 #

现有两个数据框：

• tbl_df：约700万行，包含col1-col6共6列；
• rules_df：约20条规则，部分单元格用*作为通配符，匹配成功后返回对应value。

rules_df示例：

col1 col2 col3 col4 value
Rule1 E    *     P   *     1
Rule2 B    *     P   *     2
Rule3 S    *     P   *     3
Rule4 *    O     C   *     4
Rule5 F    *     C   S     5
Rule6 E    *     *   *     6

tbl_df示例行：

col1 col2 col3 col4  col5 col6 
E    X     P   A      S   M
E    X     P   A      S   M    
B    Y     P   E      T   N      
S    X     P   E      T   M   
M    O     C   A      T   N   
F    X     C   S      T   N  
E    Z     M   X      S   N  

需求：为tbl_df每行匹配对应value，采用最严格优先的瀑布式匹配——即精度越高（非*列数越多）的规则优先匹配，同精度规则按原顺序优先，匹配到第一条符合规则后停止。

当前考虑遍历rules_df实现，希望找到更高效的方案（如Numpy向量操作、C底层实现）。

高效解决方案 #

核心思路 #

避免脚本层面的逐行循环，利用底层C实现的向量操作框架（如R的data.table、Python的Numpy），同时按规则优先级排序，减少不必要的计算。

方案1：R + data.table（底层C实现） #

data.table专为大数据处理优化，筛选、赋值操作均为C底层实现，速度远快于基础R循环。

library(data.table)

# 转换为data.table格式
setDT(tbl_df)
setDT(rules_df)

# 计算规则优先级：非*列数越多，优先级越高
rules_df[, priority := rowSums(.SD != "*"), .SDcols = c("col1", "col2", "col3", "col4")]
# 按优先级降序、原规则顺序升序排序（保证瀑布式匹配逻辑）
setorder(rules_df, -priority, .I)

# 初始化结果列
tbl_df[, value := NA_integer_]

# 按优先级依次匹配，匹配到的行不再参与后续规则检查
for (i in seq_len(nrow(rules_df))) {
  current_rule <- rules_df[i]
  # 构建匹配条件：非*列需完全相等，*列直接匹配
  match_cond <- Reduce("&", lapply(c("col1", "col2", "col3", "col4"), function(col) {
    if (current_rule[[col]] == "*") TRUE else tbl_df[[col]] == current_rule[[col]]
  }))
  # 给未匹配的行赋值
  tbl_df[is.na(value) & match_cond, value := current_rule$value]
  # 提前终止：所有行已匹配完成
  if (!any(is.na(tbl_df$value))) break
}

方案2：Python + Numpy（向量化操作） #

Numpy的向量操作基于C实现，可批量处理700万行数据，避免Python层面的循环开销。

import numpy as np
import pandas as pd

# 提取匹配所需列并转换为Numpy数组
tbl_cols = tbl_df[["col1", "col2", "col3", "col4"]].to_numpy()
rule_cols = rules_df[["col1", "col2", "col3", "col4"]].to_numpy()
rule_values = rules_df["value"].to_numpy()

# 计算规则优先级：非*列的数量
priority = (rule_cols != "*").sum(axis=1)
# 按优先级降序、原索引升序排序，确定匹配顺序
match_order = np.lexsort((np.arange(len(rule_cols)), -priority))

# 初始化结果数组
result = np.full(len(tbl_cols), fill_value=np.nan, dtype=int)

# 按优先级依次匹配
for rule_idx in match_order:
    current_rule = rule_cols[rule_idx]
    # 生成批量匹配布尔矩阵：非*列匹配对应值，*列全为True
    matches = np.all(np.where(current_rule != "*", tbl_cols == current_rule, True), axis=1)
    # 给未匹配的行赋值
    result[np.isnan(result) & matches] = rule_values[rule_idx]
    # 提前终止：所有行已匹配完成
    if not np.any(np.isnan(result)):
        break

# 将结果赋值回原DataFrame
tbl_df["value"] = result

效率说明 #

两种方案均通过底层C操作替代脚本层循环，700万行数据的处理时间可控制在数分钟内（远快于纯R/Python循环）。同时，按优先级排序后，高优先级规则先匹配，匹配成功的行不再参与后续检查，进一步减少计算量。

内容的提问来源于stack exchange，提问作者user3376169