如何用纯函数实现含多逻辑运算符的复杂条件表达式求值？

问题概述 #

我需要把所有条件运算都用函数形式重写，把运算符和参数都设为变量（比如单个4>5用operator.gt(4,5)实现）。现在要把这个方式扩展到支持包含AND、OR以及多层嵌套的复杂表达式，比如：

data = {'val1':1,'val2':2,'val3':3,'val4':4,'val5':5,'val6':6}
output = (((data['val1'] > 0.5) & (data['val2'] == 2)) | (data['val3'] >= 2))&(data['val4'] >= 3)

之前的实现只能处理纯AND的条件列表，没法应对OR和嵌套场景，现在需要一个能适配的方案，我可以调整输入表达式的格式来配合。

解决方案 #

核心思路是把逻辑表达式定义成树形结构——叶子节点是单个比较条件，非叶子节点是AND/OR逻辑组合，包含若干子节点（可以是叶子或其他组合节点）。这样不管嵌套多少层、混合多少逻辑运算符都能处理。

1. 建立运算符与operator函数的映射 #

先把常用比较、逻辑运算符对应到operator模块的函数：

import operator

op_mapping = {
    # 比较运算符
    ">": operator.gt,
    ">=": operator.ge,
    "<": operator.lt,
    "<=": operator.le,
    "==": operator.eq,
    "!=": operator.ne,
    # 逻辑运算符
    "AND": operator.and_,
    "OR": operator.or_
}

2. 定义树形结构的表达式 #

把目标嵌套表达式转换成树形结构，比如上面的示例表达式可以写成：

expression_tree = {
    "type": "AND",
    "children": [
        {
            "type": "OR",
            "children": [
                {
                    "type": "AND",
                    "children": [
                        {"op1": "val1", "operation": ">", "op2": 0.5},
                        {"op1": "val2", "operation": "==", "op2": 2}
                    ]
                },
                {"op1": "val3", "operation": ">=", "op2": 2}
            ]
        },
        {"op1": "val4", "operation": ">=", "op2": 3}
    ]
}

• 叶子节点：单个比较条件，包含op1（data的key或直接值）、operation（运算符）、op2（data的key或直接值）
• 组合节点：包含type（AND/OR）和children（子节点列表）

3. 递归解析表达式树的函数 #

写一个递归函数，遍历这个树形结构，逐层计算结果：

def eval_logical_expression(data, expr_node):
    # 处理单个比较条件（叶子节点）
    if "operation" in expr_node:
        # 优先从data中取op1/op2的值，没有的话直接用传入的常量
        arg1 = data.get(expr_node["op1"], expr_node["op1"])
        arg2 = data.get(expr_node["op2"], expr_node["op2"])
        return op_mapping[expr_node["operation"]](arg1, arg2)
    
    # 处理逻辑组合节点（AND/OR）
    elif "type" in expr_node:
        logic_func = op_mapping[expr_node["type"]]
        # 递归计算所有子节点的结果
        child_results = [eval_logical_expression(data, child) for child in expr_node["children"]]
        
        # 累积逻辑运算结果
        final_result = child_results[0]
        for res in child_results[1:]:
            final_result = logic_func(final_result, res)
        return final_result
    
    else:
        raise ValueError("表达式节点格式无效")

4. 测试验证 #

用给定的data测试这个函数：

data = {'val1':1,'val2':2,'val3':3,'val4':4,'val5':5,'val6':6}
result = eval_logical_expression(data, expression_tree)
print(result)  # 输出：True

短路运算优化 #

上面的实现会计算所有子节点的结果，如果需要短路（比如AND遇到第一个False就停止计算，OR遇到第一个True就停止），可以把逻辑组合的处理改成这样：

elif expr_node["type"] == "AND":
    return all(eval_logical_expression(data, child) for child in expr_node["children"])
elif expr_node["type"] == "OR":
    return any(eval_logical_expression(data, child) for child in expr_node["children"])

这样效率更高，而且符合Python原生逻辑运算的短路特性。

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