在Python中，当超类是一次性命名元组时，如何调用它？

Question

因此，我有大量用于串行 API 的消息有效负载类，每个类都有许多不可变字段、一个解析方法和一些共享方法。我构建此结构的方式是，每个都将从字段行为的命名元组继承，并从父类接收通用方法。但是，我在构造函数方面遇到了一些困难：

class Payload:
    def test(self):
        print("bar")

class DifferentialSpeed(Payload, namedtuple('DifferentialSpeed_', 
    'left_speed right_speed left_accel right_accel')):
    __slots__ = ()
    def __init__(self, **kwargs):
        super(DifferentialSpeed, self).__init__(**kwargs)
        # TODO: Field verification
        print("foo")

    @classmethod
    def parse(self, raw):
        # Dummy for now
        return self(left_speed = 0.0, right_speed = 0.1,
                    left_accel = 0.2, right_accel = 0.3)

    def __str__(self):
        return "Left Speed: %fm/s\nRight Speed: %fm/s\n"\
            "Left Acceleration: %fm/s^2\nRight Acceleration: %fm/s^2" % (
            self.left_speed, self.right_speed, self.left_accel, self.right_accel)


payload = DifferentialSpeed.parse('dummy')
print(payload)

这可以工作，但我收到以下警告：

DeprecationWarning: object.__init__() takes no parameters
  super(DifferentialSpeed, self).__init__(**kwargs)

如果我从调用中删除 **kwargs ，它似乎仍然可以工作，但为什么呢？构造函数的这些参数如何传递给namedtuple？这是有保证的，还是 mro 建立的随机结果？

如果我想远离 super，并以旧的方式进行操作，是否有某种方法可以访问namedtuple 来调用其构造函数？我宁愿不必这样做：

DifferentialSpeed_ = namedtuple('DifferentialSpeed_', 
    'left_speed right_speed left_accel right_accel')
class DifferentialSpeed(Payload, DifferentialSpeed_):

似乎有点冗长且不必要。

我在这里最好的行动方针是什么？

Answer 1

对于初学者来说，namedtuple(whatever)继承自tuple，它是不可变的，并且不可变类型不会打扰__init__，因为到时候__init__ 被称为对象已经被构造。如果您想将参数传递给 namedtuple 基类，则必须重写 __new__ 。

通过传入verbose=true参数可以看到namedtuple()结果的定义；我觉得它很有教育意义。

Answer 2

您有三个基类：Payload、namedtuple DifferentialSpeed_ 和公共基类object。除了从 object 继承的函数之外，前两个都没有 __init__ 函数。 namedtuple 不需要 __init__，因为不可变类的初始化是由 __new__ 完成的，它在 __init__ 之前调用代码> 已运行。

由于 super(DifferentialSpeed, self).__init__ 解析为调用链中的下一个 __init__，因此下一个 __init__ 是 object.__init__，这意味着您正在向该函数传递参数。它不需要任何东西——没有理由将参数传递给object.__init__。

（它过去接受并默默地忽略参数。这种行为已经消失了——它在 Python 3 中消失了——这就是为什么你会收到 DeprecationWarning。）

你可以通过添加 Payload.__init__< 来更清楚地触发问题。 /code> 不带参数的函数。当您尝试传递`*kwargs时，它会引发错误。

在这种情况下，正确的做法几乎肯定是删除 **kwargs 参数，然后调用 super(DifferentialSpeed, self).__init__()。它不需要任何论证； DifferentialSpeed 正在向 Payload 传递其自己的参数，而 Payload 以及调用链下游的函数对此一无所知。

Answer 3

正如其他人指出的那样，元组是一种不可变类型，必须在其 __new__() 而不是其 __init__() 方法中初始化 - 因此您需要添加前者在你的子类中（并摆脱后者）。以下是如何将其应用于您的示例代码。唯一的其他更改是在开头添加 from import... 语句。

注意： cls 必须在 __new__() 中的 super() 调用中传递两次，因为它是静态的方法，尽管它是特殊情况，因此您不必将其声明为一种。

from collections import namedtuple

class Payload:
    def test(self):
        print("bar")

class DifferentialSpeed(Payload, namedtuple('DifferentialSpeed_',
    'left_speed right_speed left_accel right_accel')):
    #### NOTE: __new__ instead of an __init__ method ####
    def __new__(cls, **kwargs):
        self = super(DifferentialSpeed, cls).__new__(cls, **kwargs)
        # TODO: Field verification
        print("foo")
        return self

    @classmethod
    def parse(self, raw):
        # Dummy for now
        return self(left_speed = 0.0, right_speed = 0.1,
                    left_accel = 0.2, right_accel = 0.3)

    def __str__(self):
        return "Left Speed: %fm/s\nRight Speed: %fm/s\n"\
            "Left Acceleration: %fm/s^2\nRight Acceleration: %fm/s^2" % (
            self.left_speed, self.right_speed, self.left_accel, self.right_accel)


payload = DifferentialSpeed.parse('dummy')
print(payload)