Итак, у меня есть большое количество классов полезной нагрузки для последовательного API, каждый из которых имеет ряд неизменяемых полей, метод синтаксического анализа и некоторые общие методы. Способ, которым я структурирую это, состоит в том, что каждый из них будет наследовать от namedtuple для поведения полей и получать общие методы из родительского класса. Однако у меня возникают трудности с конструкторами:
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?
Если бы я хотел держаться подальше от супер и делать это по-старому, есть ли способ получить доступ к namedtuple, чтобы вызвать его конструктор? Я бы предпочел не делать этого:
DifferentialSpeed_ = namedtuple('DifferentialSpeed_',
'left_speed right_speed left_accel right_accel')
class DifferentialSpeed(Payload, DifferentialSpeed_):
Кажется, многословный и ненужный.
Какой мой лучший курс действий здесь?
Во-первых, namedtuple(whatever) наследует от tuple, который неизменен, а неизменяемые типы не беспокоят __init__, потому что к моменту времени __init__ вызывается, объект уже построен. Если вы хотите передать аргументы базовому классу namedtuple, вместо этого вам придется переопределить __new__.
Вы можете увидеть определение результата namedtuple(), передав аргумент verbose=true; Я нахожу это образовательным.
У вас есть три базовых класса: Payload, ваш namedtuple DifferentialSpeed_ и общий базовый класс object. Ни один из первых двух не имеет функции __init__ вообще, кроме той, что унаследована от object. namedtuple не требуется __init__, так как инициализация неизменяемых классов выполняется с помощью __new__, который вызывается до запуска __init__.
Так как super(DifferentialSpeed, self).__init__ переходит к следующему __init__ в цепочке вызовов, следующий __init__ равен object.__init__, что означает, что вы передаете аргументы этой функции. Он не ожидает никаких - нет причин передавать аргументы object.__init__.
(Он использовал, чтобы принимать и молча игнорировать аргументы. Это поведение уходит - оно появилось в Python 3 - вот почему вы получаете сообщение об изнашивании.)
Вы можете более четко определить проблему, добавив функцию Payload.__init__, которая не принимает аргументов. Когда вы пытаетесь пройти вдоль `* kwargs, это вызовет ошибку.
Правильная вещь в этом случае - почти наверняка удалить аргумент **kwargs и просто вызвать super(DifferentialSpeed, self).__init__(). Он не принимает никаких аргументов; DifferentialSpeed передает Payload свои собственные аргументы, которые Payload и функционируют дальше по цепочке вызовов, ничего не знают о.
Как указывали другие, кортежи являются неизменяемым типом, который должен быть инициализирован в их __new__() вместо их метода __init__() - поэтому вам нужно добавить первое в свой подкласс (и избавиться от последний). Ниже описано, как это применимо к вашему примеру кода. Единственное другое изменение заключалось в добавлении инструкции from import... в начало.
Примечание. cls должен быть передан дважды в вызове super() в __new__(), потому что это статический метод, хотя он имеет специальную обложку, поэтому вам не нужно его объявлять быть одним.
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)