Comment fournir une initialisation supplémentaire pour une sous-classe de namedtuple?

Question

Supposons que j'ai un namedtuple comme ceci:

EdgeBase = namedtuple("EdgeBase", "left, right") 

Je veux mettre en œuvre une fonction de hachage personnalisé pour cela, donc je crée la sous-classe suivante:

class Edge(EdgeBase): 
    def __hash__(self): 
     return hash(self.left) * hash(self.right) 

Puisque l'objet est immuable, je veulent la valeur de hachage à calculer une seule fois, donc je fais ceci:

class Edge(EdgeBase): 
    def __init__(self, left, right): 
     self._hash = hash(self.left) * hash(self.right) 

    def __hash__(self): 
     return self._hash 

cela semble fonctionner, mais je ne suis vraiment pas sûr de ubclassing et initialisation en Python, en particulier avec les tuples. Y a-t-il des pièges à cette solution? Y a-t-il une manière recommandée comment faire ceci? Est-ce bien? Merci d'avance.

Answer 1

modifier pour 2017:turns out namedtuple isn't a great idea. attrs est l'alternative moderne.

class Edge(EdgeBase): 
    def __new__(cls, left, right): 
     self = super(Edge, cls).__new__(cls, left, right) 
     self._hash = hash(self.left) * hash(self.right) 
     return self 

    def __hash__(self): 
     return self._hash 

__new__ est ce que vous voulez appeler ici parce que tuples sont immuables. Les objets immuables sont créés dans __new__, puis renvoyés à l'utilisateur au lieu d'être remplis avec les données __init__.

cls doit être passé deux fois à l'appel super sur __new__ parce __new__ est, pour des raisons historiques/impair implicitement un staticmethod.

Answer 2

Le code de la question pourrait bénéficier d'un appel super dans le __init__ au cas où il serait jamais sous-classé dans une situation d'héritage multiple, mais sinon est correct.

class Edge(EdgeBase): 
    def __init__(self, left, right): 
     super(Edge, self).__init__(a, b) 
     self._hash = hash(self.left) * hash(self.right) 

    def __hash__(self): 
     return self._hash 

Alors que tuples sont en lecture seule que les parties tuple de leurs sous-classes sont en lecture seule, d'autres propriétés peuvent être écrites comme d'habitude, qui est ce qui permet l'attribution de _hash, peu importe que ce soit fait dans __init__ ou __new__. Vous pouvez rendre la sous-classe entièrement en lecture seule en définissant __slots__ à(), ce qui présente l'avantage supplémentaire d'économiser de la mémoire, mais vous ne pourrez pas l'affecter à _hash.