在混用原生Python与SymPy类型的代码中，如何避免不精确除法？

问题背景 #

代码中变量和函数参数同时包含原生Python数值类型（int、float）与SymPy类型（sympy.core.numbers.Integer、sympy.core.numbers.Rational、sympy.core.symbol.Symbol等），使用除法/时会出现不符合预期的行为：

• 原生int运算返回float而非精确的分数形式
• 将float转换为SymPy Rational时，会得到浮点数的近似值而非精确分数

示例代码与问题案例 #

import sympy

def MyAverageOfThreeNumbers(a, b, c):
    return (a + b + c) / 3

# 正常情况
print(MyAverageOfThreeNumbers(0, 1, 2))  # 1.0
print(type(MyAverageOfThreeNumbers(0, 1, 2)))  # <class 'float'>

print(MyAverageOfThreeNumbers(sympy.Integer(0), 1, 2))  # 1
print(type(MyAverageOfThreeNumbers(sympy.Integer(0), 1, 2)))  # <class 'sympy.core.numbers.One'>

x = sympy.symbols("x")
print(MyAverageOfThreeNumbers(x, 1, 2))  # x/3 + 1
print(type(MyAverageOfThreeNumbers(x, 1, 2)))  # <class 'sympy.core.add.Add'>

# 问题情况
print(MyAverageOfThreeNumbers(1, 1, 2))  # 1.3333333333333333（预期为4/3）
print(type(MyAverageOfThreeNumbers(1, 1, 2)))  # <class 'float'>（预期为sympy.core.numbers.Rational）

print(sympy.Rational(MyAverageOfThreeNumbers(1, 1, 2)))  # 6004799503160661/4503599627370496（预期为4/3）

已尝试的方案（存在缺陷） #

• 每次使用/时确保至少一个操作数为SymPy类型：手动操作易遗漏，代码冗余
• 用辅助函数替代/：需要全局替换所有/，审计成本高
• 函数开头转换所有参数为SymPy类型：需逐个处理参数，扩展性差

需求可行性分析 #

1. 全局重载/运算符（标准Python中不可行） #

Python的运算符重载基于对象实例的方法，无法全局替换/的行为。原生int、float的__truediv__方法是内置实现，无法直接修改。

替代方案：自动转换参数为SymPy类型

使用装饰器自动将函数参数转换为SymPy类型（通过sympy.sympify()），确保后续运算使用SymPy的精确除法逻辑：

import sympy
from functools import wraps

def sympify_args(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 将所有位置参数和关键字参数转换为SymPy类型
        sym_args = [sympy.sympify(arg) for arg in args]
        sym_kwargs = {k: sympy.sympify(v) for k, v in kwargs.items()}
        return func(*sym_args, **sym_kwargs)
    return wrapper

@sympify_args
def MyAverageOfThreeNumbers(a, b, c):
    return (a + b + c) / 3

# 测试
print(MyAverageOfThreeNumbers(1, 1, 2))  # 4/3
print(type(MyAverageOfThreeNumbers(1, 1, 2)))  # <class 'sympy.core.numbers.Rational'>

2. 禁止使用/运算符（可行） #

可以通过静态检测或运行时代码改写两种方式实现：

静态检测（编译时）

使用静态代码分析工具（如flake8）编写自定义插件，扫描代码中的/运算符并抛出警告：

# flake8_no_slash.py
import ast
from flake8_plugin_utils import Plugin, Error

class NoSlashPlugin(Plugin):
    name = "no-slash"
    version = "0.1"

    def visit_BinOp(self, node: ast.BinOp) -> None:
        if isinstance(node.op, ast.Div):
            self.report_error(Error(
                code="SL001",
                message="禁止使用/运算符，请使用MySafeDivide替代",
                node=node
            ))

使用方式：

1. 安装依赖：pip install flake8-plugin-utils
2. 运行检测：flake8 --extend-ignore=E501 --plugin flake8_no_slash your_code.py

运行时代码改写

通过AST语法树改写，将代码中所有a / b替换为MySafeDivide(a, b)：

import ast
import importlib.util

def rewrite_module_no_slash(module_path):
    with open(module_path, "r") as f:
        source = f.read()
    
    # 解析代码为AST
    tree = ast.parse(source)
    
    class DivRewriter(ast.NodeTransformer):
        def visit_BinOp(self, node):
            if isinstance(node.op, ast.Div):
                # 将a / b替换为MySafeDivide(a, b)
                return ast.Call(
                    func=ast.Name(id="MySafeDivide", ctx=ast.Load()),
                    args=[node.left, node.right],
                    keywords=[],
                    lineno=node.lineno,
                    col_offset=node.col_offset
                )
            return self.generic_visit(node)
    
    # 改写AST并修复位置信息
    rewritten_tree = DivRewriter().visit(tree)
    ast.fix_missing_locations(rewritten_tree)
    
    # 加载改写后的模块
    spec = importlib.util.spec_from_file_location("rewritten_module", module_path)
    module = importlib.util.module_from_spec(spec)
    exec(compile(rewritten_tree, module_path, "exec"), module.__dict__)
    return module

# 使用示例
import sympy
def MySafeDivide(a, b):
    return sympy.sympify(a) / sympy.sympify(b)

# 加载并改写目标模块
my_module = rewrite_module_no_slash("your_code.py")
print(my_module.MyAverageOfThreeNumbers(1, 1, 2))  # 4/3

总结 #

• 全局重载/运算符在标准Python中无法实现，但通过装饰器自动转换参数为SymPy类型，可实现一致的精确除法行为。
• 禁止使用/运算符是可行的：静态检测适合开发阶段的代码审计，运行时代码改写适合批量处理现有代码。

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