Uzyskiwanie dostępu do oryginalnego porównania int z klasy pochodnej pochodzącej z przeciążonego operatora porównania

Question

Posiadam klasę pochodną z operatorem porównania przeciążenia.

W ciele przeciążonych metod muszę użyć oryginalnego operatora.

Przykład zabawki:

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

współpracuje z Pythonie 3.3+, ale nie Pythona 2,7 z wyjątkiem AttributeError: 'super' object has no attribute '__eq__'.

mogę myśleć o kilku walkarrounds, które nie znajdując bardzo czysty:

return int(self) == other 

wymaga stworzenia nowej int obiektu po prostu go porównać, a

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

dzieli przepływ sterowania w oparciu w wersji Pythona, którą uważam za strasznie niechlujną (tak samo dokładnie sprawdzam wersję Pythona).

Jak uzyskać dostęp do oryginalnego porównania liczb całkowitych w elegancki sposób, pracując z Pythonem w wersji 2.7 i 3.3+?

Answer 1

Uważam, że przed zdefiniowaniem klasy należy zdefiniować __eq__ w int. Na przykład:

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

To powinno dać klasa super atrybut __eq__.

---

EDITED

---

Główną ideą pracował, ale została ona wniesiona do mojej uwagi, że kod nie działa. Tak: ulepszony kod:

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 i 3 znacznie się od siebie różnią, więc myślę, że powinieneś zagryźć bullet i sprawdzić wersje. Tego można się spodziewać tylko wtedy, gdy próbujesz napisać kod, który działa na obu (prędzej czy później w moim doświadczeniu znajdziesz coś, co musisz załatać). Aby uniknąć wpływu na wydajność, możesz zrobić coś takiego:

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) 

To właśnie zrobię. Gdybym naprawdę chciał podklasy int ...

Jeśli naprawdę nie chcesz, być może można spróbować:

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

Oczywiście jeśli zależy Ci na wydajności trzeba będzie zrobić kilka profili z Reszta kodu i dowiedz się, czy którykolwiek z nich jest znacznie gorszy ...

Answer 3

użyciu hasattr unika tworzenia nowego int obiekt, łowienie wyjątek lub jawnie sprawdzanie wersji Pythona.

Poniższy kod działa zarówno w Pythonie 2.7, jak i 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

Obie wersje zaimplementować metodę __xor__, można spróbować to:

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