In Python, come posso chiamare la super-classe quando si tratta di una namedtuple una tantum?

Question

Quindi, ho un gran numero di messaggi di classi di payload per un'API seriale, ognuno dei quali ha un numero di campi immutabili, un metodo di analisi e alcuni metodi che sono condivisi. Il modo in cui sto strutturando questo è che ognuno erediterà da un namedtuple per i comportamenti del campo e riceverà i metodi comuni da una classe genitore. Tuttavia, sto avendo qualche difficoltà con i costruttori:

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) 

Questo funziona, ma ottengo il seguente avviso:

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

Se rimuovo **kwargs dalla chiamata, sembra ancora funzionare, ma perché? In che modo questi argomenti vengono passati al costruttore per essere passati alla namedtuple? È garantito questo o un risultato casuale di come viene stabilito il mro?

Se volevo stare lontano da Super, e farlo alla vecchia maniera, c'è un modo in cui posso accedere a namedtuple per chiamare il suo costruttore? Preferirei non doverlo fare:

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

Sembra un po 'prolisso e inutile.

Qual è la mia migliore linea d'azione qui?

Answer 1

Per cominciare, namedtuple(whatever) eredita da tuple, che è immutabile, e tipi immutabili non si preoccupano con __init__, perché per il momento __init__ è chiamato l'oggetto è già costruito. Se si desidera passare argomenti alla classe base namedtuple, è necessario sostituire invece __new__.

È possibile visualizzare la definizione del risultato di namedtuple() passando un argomento verbose=true; Lo trovo educativo.

Answer 2

Sono disponibili tre classi di base: Payload, la namedtuple DifferentialSpeed_ e la classe di base comune object. Nessuno dei primi due ha una funzione __init__, tranne quella ereditata da object. namedtuple non ha bisogno di un __init__, poiché l'inizializzazione delle classi immutabili viene eseguita da __new__, che viene richiamato prima dell'esecuzione di __init__.

Dal super(DifferentialSpeed, self).__init__ risolve alla prossima __init__ nella catena di chiamate, la prossima __init__ è object.__init__, il che significa che si sta passando argomenti per quella funzione. Non si aspetta nulla - non c'è motivo di passare argomenti a object.__init__.

(ha usato per accettare e silenziosamente ignorare gli argomenti che il comportamento è andando via -. È andato in Python. 3 - che è il motivo per cui si ottiene un DeprecationWarning)

è possibile attivare il problema in modo più chiaro con l'aggiunta di una funzione Payload.__init__ che non accetta argomenti. Quando provi a passare insieme a `* kwargs, si genera un errore.

La cosa corretta da fare in questo caso è quasi certamente rimuovere l'argomento **kwargs e chiamare semplicemente super(DifferentialSpeed, self).__init__().Non prende argomenti; DifferentialSpeed sta passando Payloadproprio argomenti che Payload e funzioni più in basso nella catena di chiamata, non sapere nulla.

Answer 3

Come altri hanno sottolineato, le tuple sono un tipo immutabile, che deve essere inizializzato nel loro __new__() invece del loro metodo __init__() - quindi è necessario aggiungere il primo nella sottoclasse (e sbarazzarsi di quest'ultimo). Di seguito è riportato come questo verrà applicato al codice di esempio. L'unica altra modifica era l'aggiunta di una dichiarazione from import... all'inizio.

Nota:cls deve essere passato due volte nel super() chiamata in __new__() perché è un metodo statico anche se è speciale con carter in modo da non dover dichiarare di essere uno.

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)