如何用Python正则表达式化简多元二次方程？

一、你的正则表达式问题所在 #

你写的正则r'\(?([-+/*]?\d+\.\d+|\d+[-+/*]?)+\)?'存在几个核心缺陷：

• 无法处理嵌套括号：正则是线性匹配逻辑，没法识别(3 * (8 + 6))这类嵌套结构，导致内部的(8+6)被拆碎，无法完整匹配纯数字表达式单元
• 匹配逻辑割裂：交替分支[-+/*]?\d+\.\d+和\d+[-+/*]?会把数字和运算符强行拆分，比如3 + 9会被识别成9+，漏掉前面的3
• 未覆盖完整表达式：正则没有把带括号的完整数字运算作为一个整体匹配，只能抓取零散的片段，自然无法交给eval正确计算

二、无需第三方库的方程化简思路 #

核心逻辑是保留变量项，单独化简所有纯数字运算部分，具体步骤如下：

1. 标记并隔离变量项 #

先用正则识别方程中的变量项（比如24*x、y、a1），替换成临时占位符，避免后续eval计算时出错：

• 用正则r'(\d*\*?[a-zA-Z]+\d*)'匹配所有变量形式（涵盖单独变量、带系数的变量、带数字后缀的变量）
• 给每个变量分配唯一占位符（如VAR_0、VAR_1），同时记录变量与占位符的映射关系

2. 递归化简纯数字运算 #

对替换变量后的临时字符串，优先处理嵌套括号，再计算剩余纯数字运算：

• 反复查找最内层括号\(([^()]+)\)，用eval计算括号内的结果并替换原括号，直到没有嵌套括号
• 拆分等式左右两侧，分别化简纯数字部分，处理分数、加减乘除等运算

3. 还原变量项并整理格式 #

把化简后的字符串里的占位符换回原变量，再去掉多余的括号，得到最终的化简方程

代码实现示例 #

import re

def simplify_equation(equation):
    # 1. 识别并替换变量为占位符
    var_pattern = re.compile(r'(\d*\*?[a-zA-Z]+\d*)')
    vars_list = var_pattern.findall(equation)
    placeholders = [f"VAR_{i}" for i in range(len(vars_list))]
    
    temp_eq = equation
    for var, ph in zip(vars_list, placeholders):
        temp_eq = temp_eq.replace(var, ph)
    
    # 2. 递归化简括号内的数字运算
    def simplify_numeric_part(s):
        # 先处理嵌套括号
        while True:
            inner_match = re.search(r'\(([^()]+)\)', s)
            if not inner_match:
                break
            inner_expr = inner_match.group(1)
            try:
                result = eval(inner_expr)
                # 整数转字符串时去掉小数位
                result_str = str(int(result)) if result.is_integer() else str(result)
                s = s.replace(inner_match.group(0), result_str)
            except:
                break
        
        # 处理等式左右两侧的纯数字运算
        if '=' not in s:
            return s
        
        left, right = s.split('=', 1)
        
        # 化简单个部分（支持分数形式）
        def process_segment(seg):
            if '/' in seg:
                numerator, denominator = seg.split('/', 1)
                # 化简分子
                num_eval = eval(numerator) if re.fullmatch(r'[\d+\-*/.]+', numerator) else numerator
                num_str = str(int(num_eval)) if isinstance(num_eval, float) and num_eval.is_integer() else str(num_eval)
                # 化简分母
                den_eval = eval(denominator) if re.fullmatch(r'[\d+\-*/.]+', denominator) else denominator
                den_str = str(int(den_eval)) if isinstance(den_eval, float) and den_eval.is_integer() else str(den_eval)
                # 保留必要括号
                num_part = f"({num_str})" if '+' in num_str or '-' in num_str else num_str
                den_part = f"({den_str})" if '+' in den_str or '-' in den_str else den_str
                return f"{num_part}/{den_part}"
            else:
                if re.fullmatch(r'[\d+\-*/.]+', seg):
                    res = eval(seg)
                    return str(int(res)) if res.is_integer() else str(res)
                return seg
        
        left_simplified = process_segment(left)
        right_simplified = process_segment(right)
        return f"{left_simplified} = {right_simplified}"
    
    simplified_temp = simplify_numeric_part(temp_eq)
    
    # 3. 还原变量项
    final_eq = simplified_temp
    for var, ph in zip(vars_list, placeholders):
        final_eq = final_eq.replace(ph, var)
    
    # 去掉不必要的括号（比如(24*x)这类）
    final_eq = re.sub(r'\((\d+\*[a-zA-Z]+)\)', r'\1', final_eq)
    return final_eq

# 测试示例
test_eq = "(24*x + 1 + 9) / (((8 * 6 * 2) + 1) * y) = 3 + 9 + (3 * (8 + 6)) * 18.56"
print(simplify_equation(test_eq))
# 输出：(24*x+10)/(97*y) = 791.52

三、注意事项 #

• 该方法仅处理纯数字运算的化简，不涉及变量项的合并（比如2x+3x不会自动变成5x），如果需要同类项合并，可额外添加识别同类变量的逻辑
• 注意eval的安全性：如果方程来源不可信，不要直接使用eval，可以自己实现简单的四则运算解析器
• 对于极端复杂的嵌套括号，递归替换的方式能保证最内层先被计算，避免运算顺序错误

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