Accès à la comparaison int originale à partir de la classe dérivée int avec opérateur de comparaison surchargé

Question

J'ai une classe dérivée int avec un opérateur de comparaison surchargé.

Dans le corps des méthodes surchargées, j'ai besoin d'utiliser l'opérateur d'origine.

L'exemple de jouet:

>>> class Derived(int): 
...  def __eq__(self, other): 
...   return super(Derived, self).__eq__(other) 

fonctionne très bien avec Python 3.3+, mais échoue avec Python 2.7 à l'exception AttributeError: 'super' object has no attribute '__eq__'.

Je peux penser à plusieurs walkarrounds, que je trouve pas très propre:

return int(self) == other 

nécessite la création d'un nouvel objet int juste pour comparer, tandis que

try: 
    return super(Derived, self).__eq__(other) 
except AttributeError: 
    return super(Derived, self).__cmp__(other) == 0 

divise le flux de contrôle à base sur la version Python, que je trouve terriblement en désordre (donc inspecte la version Python explicitement).

Comment puis-je accéder à la comparaison de nombres entiers d'une manière élégante en travaillant avec Python 2.7 et 3.3+?

Answer 1

Je crois que vous devez définir le __eq__ dans le int avant de définir la classe. Par exemple:

int = 5 
def int.__eq__(self, other): 
    return self.real == other 
IntDerived = Derived(int) 

Cela devrait donner à la classe super un attribut __eq__.

---

ÉDITÉE

---

L'idée principale a fonctionné, mais il a été porté à mon attention que le code ne fonctionne pas. Donc: amélioration de code:

class Derived(int): 
    def __eq__(self, other): 
     return self.real == other 

Int = 5 
D = Derived(Int) 
D.__eq__(4) #Output: False 
D.__eq__(5) #Output: True 

Answer 2

Python 2 et 3 sont significativement différents les uns des autres, donc je pense que vous devriez mordre la balle et vérifier les versions. C'est normal si vous essayez d'écrire du code qui fonctionne sur les deux (tôt ou tard dans mon expérience, vous trouverez quelque chose que vous devez corriger). Pour éviter tout impact sur les performances, vous pouvez faire quelque chose comme:

from six import PY2 

class Derived(int): 
    if PY2: 
     def __eq__(self, other): 
      return super(Derived, self).__cmp__(other) == 0 
    else: 
     def __eq__(self, other): 
      return super(Derived, self).__eq__(other) 

C'est ce que je ferais. Si je voulais vraiment sous-classe int ...

Si vous ne voulez vraiment pas, peut-être vous pouvez essayer:

class Derived(int): 
    def __eq__(self, other): 
     return (self^other) == 0 

Évidemment, si vous vous souciez de la performance que vous aurez à faire un peu de profilage avec le reste de votre code et savoir si l'un d'eux est significativement pire ...

Answer 3

à l'aide hasattr évite la création d'un nouvel objet int, attrapant une exception ou le contrôle explicitement pour la version Python.

Le code ci-dessous fonctionne sur Python 2.7 et 3.3+:

class Derived(int): 
    def __eq__(self, other): 
     return super(Derived, self).__cmp__(other) == 0 if hasattr(Derived, "__cmp__") else super(Derived, self).__eq__(other) 

Answer 4

Les deux versions mettent en œuvre une méthode __xor__, vous pouvez essayer ceci:

class Derived(int): 
    def __eq__(self, other): 
     return not super(Derived, self).__xor__(other)