Python 中 dict 类的动态运算符重载

Question

我有一个动态重载基本算术运算符的类，如下所示...

import operator

class IshyNum:
    def __init__(self, n):
        self.num=n
        self.buildArith()

    def arithmetic(self, other, o):
        return o(self.num, other)

    def buildArith(self):
        map(lambda o: setattr(self, "__%s__"%o,lambda f: self.arithmetic(f, getattr(operator, o))), ["add", "sub", "mul", "div"])

if __name__=="__main__":
    number=IshyNum(5)
    print number+5
    print number/2
    print number*3
    print number-3

但是如果我将类更改为从字典继承（class IshyNum(dict):），它就不起作用。我需要明确地 def __add__(self, other) 或其他任何内容才能使其正常工作。为什么？

Answer 1

答案可以在 Python 的两种类型的类中找到。

您提供的第一个代码片段使用遗留的“旧式”类（您可以看出，因为它没有子类化任何内容 - 冒号之前没有任何内容）。它的语义很奇特。特别是，您可以向实例添加特殊方法：

class Foo:
   def __init__(self, num):
      self.num = num
      def _fn(other):
         return self.num + other.num
      self.__add__ = _fn

并获得有效响应：

>>> f = Foo(2)
>>> g = Foo(1)
>>> f + g
3

但是，子类化 dict 意味着您正在生成一个新样式的类。并且运算符重载的语义是不同的：

class Foo (object):
   def __init__(self, num):
      self.num = num
      def _fn(other):
         return self.num + other.num
      self.__add__ = _fn
>>> f = Foo(2)
>>> g = Foo(1)
>>> f + g
Traceback ...
TypeError: unsupported operand type(s) for +: 'Foo' and 'Foo'

要使其适用于新式类（包括 dict 的子类或您会发现的任何其他类型），您必须确保特殊方法是在类上定义的。您可以通过元类来做到这一点：

class _MetaFoo(type):
    def __init__(cls, name, bases, args):
        def _fn(self, other):
            return self.num + other.num
        cls.__add__ = _fn

class Foo(object):
    __metaclass__ = _MetaFoo
    def __init__(self, num):
        self.num = num

>>> f = Foo(2)
>>> g = Foo(1)
>>> f+g
3

此外，语义差异意味着在第一种情况下，我可以使用一个参数定义本地 add 方法（它使用的 self 是从周围的范围捕获的，其中它已定义），但对于新式类，Python 期望显式传入两个值，因此内部函数有两个参数。

正如之前的评论者提到的，如果可能的话，最好避免旧式类并坚持使用新式类（旧式类在 Python 3+ 中已被删除）。不幸的是，在这种情况下，旧式类恰好适合您，而新式类将需要更多代码。

---

编辑：

您还可以按照最初尝试的方式通过在类而不是实例上设置方法来完成此操作：

class Foo(object):
    def __init__(self, num):
        self.num = num
setattr(Foo, '__add__', (lambda self, other: self.num + other.num))
>>> f = Foo(2)
>>> g = Foo(1)
>>> f+g
3

恐怕我有时会在元类中思考，更简单的解决方案会更好:)

Answer 2

一般来说，永远不要在实例上设置 __ 方法——它们仅在类上受支持。 （在本例中，问题在于它们恰好适用于旧式类。不要使用旧式类）。

您可能想要使用元类，而不是您在这里所做的奇怪的事情。

这是元类教程： http://www.voidspace.org.uk/python /articles/metaclasses.shtml

Answer 3

我不明白你想要完成什么，但我几乎可以肯定你正在以错误的方式去做。我的一些观察：

• 我不明白你为什么要尝试动态生成这些算术方法。您不对它们执行任何特定于实例的操作，因此我不明白为什么您不只是在类上定义它们。

  • 它们起作用的唯一原因是因为 IshyNum 是一个旧式类；这不是一件好事，因为旧式类早已被弃用，而且不如新式类好。 （稍后我将解释为什么您应该对此特别感兴趣。）

  • 如果您想自动化为多个方法执行相同操作的过程（在这种情况下可能不值得），您可以在类定义块之后立即执行此操作。

    • 不要使用map来做到这一点。 map 用于制作列表；用它来治疗副作用是愚蠢的。只需使用普通的 for 循环即可。
• 在使用组合时自动将多个方法引用到同一属性，请使用 __getattr__ 并重定向到该属性的方法。

• 不要继承dict。继承内置类型并没有什么好处。事实证明它比它的价值更令人困惑，而且你不能重复使用太多。

  • 如果您上面的代码与您帖子中的内容很接近，那么您真的不想继承dict。如果不是，请尝试发布您的真实用例。

这是您真正想知道的：

• 当您继承 dict 时，您正在创建一个 新式类。 IshyNum 是一个旧式类，因为它不继承 object （或其子类之一）。

  十年来，新式类一直是 Python 的旗舰类，并且是您想要使用的类。在这种情况下，它们实际上会导致您的技术不再起作用。不过，这很好，因为您发布的代码中没有理由在每个实例级别上设置魔术方法，也没有理由想要这样做。

Answer 4

对于新式类，Python 在执行加法时不会检查实例中的 __add__ 方法，而是检查类。问题是您将 __add__ 方法（以及所有其他方法）作为绑定方法绑定到实例，而不是作为未绑定方法绑定到类。 （这对于其他特殊方法也是如此，您只能将它们附加到类，而不是实例）。因此，您可能希望使用元类来实现此功能（尽管我认为这是一件非常尴尬的事情，因为显式地阐明这些方法更具可读性）。无论如何，这是一个元类的示例：

import operator

class OperatorMeta(type):
    def __new__(mcs, name, bases, attrs):
        for opname in ["add", "sub", "mul", "div"]:
            op = getattr(operator, opname)
            attrs["__%s__" % opname] = mcs._arithmetic_func_factory(op)
        return type.__new__(mcs, name, bases, attrs)

    @staticmethod
    def _arithmetic_func_factory(op):
        def func(self, other):
            return op(self.num, other)
        return func

class IshyNum(dict):
    __metaclass__ = OperatorMeta

    def __init__(self, n):
        dict.__init__(self)
        self.num=n

if __name__=="__main__":
    number=IshyNum(5)
    print number+5
    print number/2
    print number*3
    print number-3