你可以为 Python 中的重载运算符强加对象优先级吗？

Question

假设我有两个 Python 类，它们都定义了 add 和 radd 运算符重载，并且我将一个类的一个实例添加到另一个类的另一个实例。选择的实现取决于添加项目的顺序（Python 首先在 LHS 上查找 add 方法，等等）。

我是否可以定义首选对象实现的优先级？例如，如果 radd 的优先级高于 LHS，我希望在 RHS 上调用 radd。

我真的很想对所有重载的运算符都这样做，所以我最终想要一个更通用的解决方案。

[编辑：添加示例]

例如，我可能有一个自定义数字类型类，我可能希望将 int 静默类型转换为我的自定义类型。因此我需要 add 和 radd （以及所有其他运算符重载与他们的 'r' 表亲）。

接下来，我想要一个通用多项式类，其系数是一些通用数字类型。我还想将事物类型转换为多项式，因此我为它实现了 add 和 radd 函数。但是，如果我在左侧添加一个自定义数字，在右侧添加一个多项式，我希望将其 up 类型转换为多项式，而不是 Python 尝试对其进行类型转换 down 自定义号码类型。因此，我希望调用 radd 而不是 add。

Answer 1

正如您所描述的，没有用于定义“优先级”的内置机制。您可以做的是在魔术方法中实现优先级检查。也就是说，您可以定义对象的__add__ 方法，以便它检查另一个对象的“优先级”（无论如何定义），如果其优先级更高，则调用该对象的__add__（或__radd__）。

请注意，如果您只是希望 LHS __add__ 遵循 RHS __radd__，您可以返回 NotImplemented，这实际上会告诉 Python“就像您刚刚调用的 __add__ 方法没有存在”。

以下是如何在魔术方法上使用装饰器完成此操作的草图：

def deco(op):
    def newOp(self, other):
        if other.precedence > self.precedence:
            return NotImplemented
        return op(self, other)
    return newOp

class Thing(object):
    precedence = 0

    def __init__(self, val):
        self.val = val

    @deco
    def __add__(self, other):
        print "Called", self, "__add__"
        return self.__class__(self.val + other.val)

    def __radd__(self, other):
        print "Called", self, "__radd__"
        return self.__class__(self.val + other.val)

class Weak(Thing):
    precedence = 1

class Strong(Thing):
    precedence = 2

这导致无论操作数的顺序如何，总是调用Strong 版本，因此它总是返回Strong：

>>> Weak(1) + Strong(1)
Called <__main__.Strong object at 0x01F96BF0> __radd__
<__main__.Strong object at 0x01F96BD0>
>>> Strong(1) + Weak(1)
Called <__main__.Strong object at 0x01F96B90> __add__
<__main__.Strong object at 0x01F96250>

Answer 2

如果使用+ 运算符未在第一个项目上实现__add__，Python 将使用__radd__。

foo + bar

将尝试在other、bar 上使用foo 的__add__ 运算符。如果没有实现，它将调用bar的__radd__。

class Foo(object):
    pass

class Bar(object):
    def __radd__(self, other):
        print('Bar.__radd__ was called!')

>>> foo = Foo()
>>> bar = Bar()
>>> foo + bar
Bar.__radd__ was called!

当 Foo 有 __add__ 时，它会获得优先权：

class Foo(object):
    def __add__(self, other):
        print('Foo.__add__ was called!')

>>> foo = Foo()
>>> foo + bar
Foo.__add__ was called!

如果两者都实现了，则不能强制 Python 执行任何特殊操作，优先顺序是预定义的。但是，您可以检查其他人的存在：

class Foo(object):
    def __add__(self, other):
        if hasattr(other, '__radd__'):
            return other.__radd__(self)
        else:
            print('Foo.__add__ was called!')

>>> foo = Foo()
>>> foo + bar
Bar.__radd__ was called!