要实现类似 Excel 中 `IIF(condition, true_value, false_value)` 这样的逻辑判断函数，并支持用户输入字符串形式的表达式（如 `"IIF(A>B, A, B)"`），其中 `A` 和 `B` 是用户定义的变量（例如通过字典传入），我们需要： 1. **安全地解析和求值**用户输入的表达式（⚠️绝不能用 `eval()` 直接执行任意代码，存在严重安全风险）； 2. **识别并提取 IIF 调用结构**（支持嵌套，如 `IIF(A>B, IIF(C>D, C, D), B)`）； 3. **递归/迭代地展开 IIF**，将条件、真值、假值分别解析为 Python 可计算的表达式； 4. **在受控环境中求值**：使用 `ast.literal_eval` 处理字面量，结合 `operator` 模块或自定义安全运算符，配合变量环境（`locals` 字典）进行安全计算。 ✅ 推荐方案：**使用 `ast` 模块进行语法树解析 + 白名单操作符 + 受限 `eval`（带自定义 `__builtins__` 空白环境）**，这是最安全、可扩展、且能处理嵌套 IIF 的方式。 --- ### ✅ 完整可运行解决方案（安全、支持嵌套、支持变量） ```python import ast import operator # 安全支持的二元运算符映射 BIN_OPS = { ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.FloorDiv: operator.floordiv, ast.Mod: operator.mod, ast.Pow: operator.pow, ast.Lt: operator.lt, ast.Le: operator.le, ast.Eq: operator.eq, ast.NotEq: operator.ne, ast.Gt: operator.gt, ast.Ge: operator.ge, ast.And: lambda x, y: x and y, ast.Or: lambda x, y: x or y, } # 安全支持的一元运算符（如 -x, not x） UNARY_OPS = { ast.USub: operator.neg, ast.Not: operator.not_, } def _safe_eval(node, env): """安全递归求值 AST 节点，仅允许字面量、变量、白名单运算符、IIF 调用""" if isinstance(node, ast.Constant): # Python 3.6+; for older, also handle ast.Num, ast.Str, etc. return node.value elif isinstance(node, ast.Name): if node.id in env: return env[node.id] else: raise NameError(f"Undefined variable: {node.id}") elif isinstance(node, ast.BinOp): left = _safe_eval(node.left, env) right = _safe_eval(node.right, env) op_func = BIN_OPS.get(type(node.op)) if op_func is None: raise ValueError(f"Unsupported binary operator: {type(node.op).__name__}") return op_func(left, right) elif isinstance(node, ast.UnaryOp): operand = _safe_eval(node.operand, env) op_func = UNARY_OPS.get(type(node.op)) if op_func is None: raise ValueError(f"Unsupported unary operator: {type(node.op).__name__}") return op_func(operand) elif isinstance(node, ast.BoolOp): # and/or with multiple values: convert to left-associative chain values = [_safe_eval(v, env) for v in node.values] op_func = BIN_OPS.get(type(node.op)) if op_func is None: raise ValueError(f"Unsupported boolean operator: {type(node.op).__name__}") result = values[0] for v in values[1:]: result = op_func(result, v) return result elif isinstance(node, ast.Compare): left = _safe_eval(node.left, env) result = True for op, right_node in zip(node.ops, node.comparators): right = _safe_eval(right_node, env) op_func = BIN_OPS.get(type(op)) if op_func is None: raise ValueError(f"Unsupported comparison operator: {type(op).__name__}") if not op_func(left, right): result = False break left = right # chained comparison: a < b < c → (a<b) and (b<c) return result elif isinstance(node, ast.Call): # 仅支持 IIF 函数调用 if not isinstance(node.func, ast.Name) or node.func.id != 'IIF': raise ValueError(f"Only IIF() is allowed as function call, got {ast.unparse(node.func) if hasattr(ast, 'unparse') else repr(node.func)}") if len(node.args) != 3: raise ValueError("IIF() must have exactly 3 arguments: condition, true_value, false_value") cond = _safe_eval(node.args[0], env) if cond: return _safe_eval(node.args[1], env) else: return _safe_eval(node.args[2], env) else: raise ValueError(f"Unsupported AST node type: {type(node).__name__}") def iif_eval(expr: str, env: dict): """ 安全求值 IIF 表达式字符串，如 "IIF(A>B, A, B)" 或嵌套 "IIF(A>B, IIF(C>0, C, 0), B)" Args: expr: 字符串表达式（只含 IIF、变量、数字、比较/算术运算符） env: 变量字典，如 {'A': 5, 'B': 3, 'C': -1} Returns: 计算结果（任意类型，取决于表达式） Raises: ValueError / NameError / etc. on unsafe/malformed input """ try: tree = ast.parse(expr.strip(), mode='eval') return _safe_eval(tree.body, env) except SyntaxError as e: raise ValueError(f"Invalid syntax in expression '{expr}': {e}") except Exception: raise # ✅ 使用示例 if __name__ == "__main__": # 示例1：基础 IIF print(iif_eval("IIF(A > B, A, B)", {"A": 10, "B": 5})) # → 10 # 示例2：取小值 print(iif_eval("IIF(A < B, A, B)", {"A": 10, "B": 5})) # → 5 # 示例3：嵌套 IIF（三数取最大） expr = "IIF(A > B, IIF(A > C, A, C), IIF(B > C, B, C))" print(iif_eval(expr, {"A": 7, "B": 2, "C": 9})) # → 9 # 示例4：混合运算 print(iif_eval("IIF(X * 2 > Y, X + 1, Y - 1)", {"X": 4, "Y": 7})) # 4*2=8 > 7 → 4+1 = 5 ``` --- ### 🔍 解释说明： | 组件 | 说明 | |------|------| | **`ast.parse(..., mode='eval')`** | 将字符串安全转为 AST（抽象语法树），不执行任何代码，仅结构分析。比 `eval()` 安全万倍。 | | **白名单运算符 (`BIN_OPS`, `UNARY_OPS`)** | 显式控制哪些操作允许（如 `+`, `<`, `and`），拒绝 `exec`, `import`, `getattr` 等危险操作。 | | **`IIF` 特殊处理** | 在 `_safe_eval` 中识别 `ast.Call` 且函数名为 `'IIF'`，强制三参数，递归求值各分支。支持任意深度嵌套。 | | **变量查表 (`env`)** | 所有 `Name` 节点从传入字典中查找，未定义则报错，杜绝污染全局/内置命名空间。 | | **无 `eval` / `exec` / `__import__`** | 整个流程不调用任何动态执行函数，完全基于 AST 遍历，满足生产级安全要求。 | ⚠️ 注意：该方案**不支持函数调用（除 IIF 外）**、**不支持列表/字典字面量复杂结构**（如 `[A,B]`）、**不支持 lambda 或复杂语句**——这正是安全性的体现。如需扩展，可在白名单中谨慎添加（如 `ast.List`, `ast.Dict`, `ast.Tuple` 等），但必须严格校验其元素是否也安全。 ---