如何用纯 Python 实现代数表达式简化（不依赖 SymPy）-Python教程-PHP中文网

如何用纯 python 实现代数表达式简化（不依赖 sympy）

本文介绍一种不借助 SymPy 等符号计算库、仅使用 Python 原生能力（ast 解析 + 递归求值 + 正则预处理）安全简化含变量的代数表达式的方法，重点解决括号嵌套、运算符优先级与变量隔离问题。

本文介绍一种不借助 SymPy 等符号计算库、仅使用 Python 原生能力（`ast` 解析 + 递归求值 + 正则预处理）安全简化含变量的代数表达式的方法，重点解决括号嵌套、运算符优先级与变量隔离问题。

在不引入第三方符号计算库（如 SymPy）的前提下，对形如 (24*x + 1 + 9) / (((8 * 6 * 2) + 1) * y) = 3 + 9 + (3 * (8 + 6)) * 18.56 的混合代数方程进行简化，核心挑战在于：既要安全地数值化常量子表达式，又要完整保留含变量项的结构（如 24*x、97*y），且不能因盲目 eval() 引发代码注入或语法错误。

直接使用正则表达式（如 r'\(?([-+/*]?\d+\.\d+|\d+[-+/*]?)+\)?'）解析数学表达式是不可靠的——它无法正确匹配嵌套括号、忽略运算符绑定关系，导致碎片化匹配（如将 3 + 9 + (3 * (8 + 6)) * 18.56 错分为 ['9+', '3*', '6', '*18.56']）。正则适用于词法识别（如提取变量名、分离数字/符号），但不适用于语法解析。

✅ 推荐方案：结合 ast 模块 + 安全常量折叠（Constant Folding）

Python 的 ast（Abstract Syntax Tree）模块可将字符串形式的表达式安全地解析为语法树，无需 eval 即可遍历并识别哪些子节点完全由数字、运算符和括号构成（即“纯常量子树”），然后递归求值；而含 ast.Name（变量）的节点则原样保留。

python学习

Python 编程学习助手 skill，面向零基础用户。当用户表达以下意图时触发： - 学习 Python 基础概念（变量、数据类型、循环、函数、类等） - 请求 Python 练习题或测验 - 请求审查或调试 Python 代码 - 请求 Python 项目实战指导（爬虫、数据分析、Web 开发等入门项目） - 泛化表述如"教我 Python""我想学编程""Python 怎么写""帮我学 Python" 此 skill

下载

以下是实现关键逻辑的精简示例：

import ast
import operator

# 支持的二元运算符映射
BIN_OP_MAP = {
    ast.Add: operator.add,
    ast.Sub: operator.sub,
    ast.Mult: operator.mul,
    ast.Div: operator.truediv,
    ast.USub: operator.neg,  # 一元负号
}

def simplify_constant_expr(expr_str: str) -> str:
    """安全简化表达式中的纯常量部分，保留变量结构"""
    try:
        node = ast.parse(expr_str, mode='eval')
        simplified_node = _fold_constants(node.body)
        return ast.unparse(simplified_node) if hasattr(ast, 'unparse') else _ast_to_str(simplified_node)
    except Exception:
        return expr_str  # 解析失败时返回原串（降级处理）

def _fold_constants(node):
    if isinstance(node, ast.BinOp):
        left = _fold_constants(node.left)
        right = _fold_constants(node.right)
        if isinstance(left, ast.Constant) and isinstance(right, ast.Constant):
            op = BIN_OP_MAP.get(type(node.op))
            if op:
                try:
                    result = op(left.value, right.value)
                    return ast.Constant(value=result)
                except:
                    pass
        return ast.BinOp(left=left, op=node.op, right=right)
    elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
        operand = _fold_constants(node.operand)
        if isinstance(operand, ast.Constant):
            return ast.Constant(value=-operand.value)
        return ast.UnaryOp(op=node.op, operand=operand)
    elif isinstance(node, ast.Constant):
        return node
    elif isinstance(node, ast.Name):  # 变量：原样保留
        return node
    else:
        # 其他节点（如 Call、Attribute）暂不处理，避免误操作
        return node

# 辅助函数：兼容旧版 Python 的 ast.unparse 替代（简化版）
def _ast_to_str(node):
    if isinstance(node, ast.Constant):
        return str(node.value)
    elif isinstance(node, ast.Name):
        return node.id
    elif isinstance(node, ast.BinOp):
        op_map = {ast.Add: '+', ast.Sub: '-', ast.Mult: '*', ast.Div: '/'}
        op_sym = op_map.get(type(node.op), '?')
        return f"({_ast_to_str(node.left)} {op_sym} {_ast_to_str(node.right)})"
    elif isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
        return f"-{_ast_to_str(node.operand)}"
    return "??"

使用示例：

# 分别处理等式左右两侧
left_expr = "(24*x + 1 + 9) / (((8 * 6 * 2) + 1) * y)"
right_expr = "3 + 9 + (3 * (8 + 6)) * 18.56"

simplified_left = simplify_constant_expr(left_expr)  # → "(24*x + 10)/(97*y)"
simplified_right = simplify_constant_expr(right_expr)  # → "791.52"

print(f"{simplified_left} = {simplified_right}")  
# 输出：(24*x + 10)/(97*y) = 791.52

⚠️ 注意事项：