如何在类型类测试中循环遍历运算符以批量执行断言逻辑？

当然可以实现！这种通过循环统一维护测试逻辑的思路非常赞，能帮你避免重复代码，后续修改也更高效。下面给你两种可行的方案：

方法一：使用operator模块（推荐） #

Python标准库中的operator模块提供了与内置运算符对应的函数，比如operator.add对应+、operator.sub对应-，完全可以用来动态调用不同的运算逻辑。

步骤示例： #

1. 首先确保你的自定义类实现了对应的运算符（包括反向运算符，比如__radd__，因为你是用2 + my_type这种左操作数为内置类型的写法）：

class MyType:
    def __init__(self, num):
        self.num_atr = num
    
    # 处理 my_type + 2 的情况
    def __add__(self, other):
        return self.num_atr + other
    # 处理 2 + my_type 的情况
    def __radd__(self, other):
        return other + self.num_atr
    
    def __sub__(self, other):
        return self.num_atr - other
    def __rsub__(self, other):
        return other - self.num_atr
    
    def __mul__(self, other):
        return self.num_atr * other
    def __rmul__(self, other):
        return other * self.num_atr
    
    def __truediv__(self, other):
        return self.num_atr / other
    def __rtruediv__(self, other):
        return other / self.num_atr
    
    def __floordiv__(self, other):
        return self.num_atr // other
    def __rfloordiv__(self, other):
        return other // self.num_atr

2. 编写动态遍历运算符的测试用例：

import operator

def test_my_type_operators():
    my_type = MyType(5)
    # 把运算符符号和对应的operator函数配对，方便出错时排查
    test_ops = [
        ("+", operator.add),
        ("-", operator.sub),
        ("*", operator.mul),
        ("/", operator.truediv),
        ("//", operator.floordiv)
    ]
    
    for op_symbol, op_func in test_ops:
        # 用operator函数替代运算符语法
        left_result = op_func(2, my_type)
        right_result = op_func(2, my_type.num_atr)
        # 断言时带上运算符符号，方便定位问题
        assert left_result == right_result, \
            f"测试失败：运算符 {op_symbol}，{2} {op_symbol} my_type 不等于 {2} {op_symbol} {my_type.num_atr}"

这种方式的优点是安全、符合Pythonic风格，没有代码注入风险，而且可读性强。

方法二：使用eval（简洁但需注意安全） #

如果你追求极致简洁，也可以用eval执行动态生成的表达式字符串，但要注意：eval会执行任意字符串代码，所以只在你能完全控制输入内容的场景下使用（比如测试用例里的固定运算符）。

代码示例： #

def test_my_type_operators_eval():
    my_type = MyType(5)
    operators = ["+", "-", "*", "/", "//"]
    
    for op in operators:
        # 生成左右两边的表达式字符串
        left_expr = f"2 {op} my_type"
        right_expr = f"2 {op} my_type.num_atr"
        # 用eval执行表达式
        left_result = eval(left_expr)
        right_result = eval(right_expr)
        # 断言并提示错误信息
        assert left_result == right_result, \
            f"测试失败：运算符 {op}，{left_expr} 不等于 {right_expr}"

这种写法更贴近你原本想要的“运算符语法”，但安全性不如operator模块，不推荐在生产代码中使用，测试场景下可以考虑。

关键提醒：无论用哪种方法，都必须确保你的自定义类实现了对应的反向运算符（比如__radd__、__rsub__），否则2 + my_type这种写法会触发TypeError，因为内置类型不知道如何与你的自定义类进行运算。

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