Eleganckie sposoby wspierania równoważności ("equality") w klasach Pythona

Rozważ ten prosty problem:

class Number:

    def __init__(self, number):
        self.number = number


n1 = Number(1)
n2 = Number(1)

n1 == n2 # False -- oops

Tak więc Python domyślnie używa identyfikatorów obiektów do operacji porównywania:

id(n1) # 140400634555856
id(n2) # 140400634555920

Nadpisanie funkcji __eq__ wydaje się rozwiązywać problem:

def __eq__(self, other):
    """Overrides the default implementation"""
    if isinstance(other, Number):
        return self.number == other.number
    return False


n1 == n2 # True
n1 != n2 # True in Python 2 -- oops, False in Python 3

W Python 2 zawsze pamiętaj, aby nadpisać funkcję __ne__, ponieważ dokumentacja stwierdza:

Między operatorami porównania nie istnieją żadne implikowane relacje. Na prawda x==y nie oznacza, że x!=y jest fałsz. Odpowiednio, gdy definiowanie __eq__(), należy również zdefiniować __ne__(), aby operatorzy będą zachowywać się zgodnie z oczekiwaniami.

def __ne__(self, other):
    """Overrides the default implementation (unnecessary in Python 3)"""
    return not self.__eq__(other)


n1 == n2 # True
n1 != n2 # False

W Python 3 , nie jest to już konieczne, ponieważ dokumentacja stwierdza:

Domyślnie, __ne__() deleguje na __eq__() i odwraca wynik chyba że jest NotImplemented. Nie ma innych domniemanych zależności między operatorami porównania, np. prawda z (x<y or x==y) nie oznacza x<=y.

class SubNumber(Number):
    pass


n3 = SubNumber(1)

n1 == n3 # False for classic-style classes -- oops, True for new-style classes
n3 == n1 # True
n1 != n3 # True for classic-style classes -- oops, False for new-style classes
n3 != n1 # False

Uwaga: Python 2 ma dwa rodzaje klas:

• Styl Klasyczny (lub W starym stylu) klasy, które nie dziedziczą od object i które są zadeklarowane jako class A:, class A(): lub class A(B): gdzie B jest klasą w stylu klasycznym;

• nowy-styl klasy, które dziedziczą z object i które są zadeklarowane jako class A(object) lub class A(B):, gdzie B jest klasą nowego stylu. Python 3 ma tylko klasy nowego stylu, które są zadeklarowane jako class A:, class A(object): lub class A(B):.

Dla klasy klasy, operacja porównawcza zawsze wywołuje metodę pierwszego operandu, podczas gdy dla klasy nowego stylu, zawsze wywołuje metodę podklasy operandu, niezależnie od kolejności operandów .

Więc tutaj, jeśli Number jest stylem klasycznym Klasa:

• n1 == n3 wywołania n1.__eq__;
• n3 == n1 wywołania n3.__eq__;
• n1 != n3 wywołania n1.__ne__;
• n3 != n1 połączenia n3.__ne__.

I jeśli Number jest klasą nowego stylu:

• zarówno n1 == n3 jak i n3 == n1 call n3.__eq__;
• zarówno n1 != n3 jak i n3 != n1 zadzwoń n3.__ne__.

Aby rozwiązać problem nieprzemienności operatorów == i != dla klasy 2 w Pythonie, metody __eq__ i __ne__ powinny zwracać NotImplemented wartość, gdy typ operandu nie jest obsługiwany. Dokumentacja definiuje wartość NotImplemented jako:

Metody numeryczne i metody porównawcze rich mogą zwracać tę wartość, jeśli nie realizują operacji dla podanych operandów. (The interpreter spróbuje wtedy operacji odbicia, lub innej w zależności od operatora.) Jego wartość prawdy jest prawdziwa.

W tym przypadku operator przekazuje operację porównania do metoda odbicia zinne operand. Dokumentacja definiuje metody refleksyjne jako:

Nie ma wersji podmienionych argumentów tych metod (do użycia gdy lewy argument nie wspiera operacji, ale prawy argument robi); raczej __lt__() i __gt__() są wzajemnie refleksji, __le__() i __ge__() są wzajemnie odbiciem i __eq__() i __ne__() są ich własnym odbiciem.

Wynik wygląda następująco to:

def __eq__(self, other):
    """Overrides the default implementation"""
    if isinstance(other, Number):
        return self.number == other.number
    return NotImplemented

def __ne__(self, other):
    """Overrides the default implementation (unnecessary in Python 3)"""
    x = self.__eq__(other)
    if x is not NotImplemented:
        return not x
    return NotImplemented

Zwracanie wartości NotImplemented zamiast {[61] } jest właściwe nawet dla klas nowego stylu, jeślikomutatywność operatorów == i != jest pożądana, gdy operandy są niepowiązanych typów (bez dziedziczenia).

Jesteśmy już na miejscu? Niezupełnie. Ile mamy unikalnych numerów?

len(set([n1, n2, n3])) # 3 -- oops

Sets używa skrótów obiektów i domyślnie Python zwraca hash identyfikatora obiektu. Spróbujmy obejść it:

def __hash__(self):
    """Overrides the default implementation"""
    return hash(tuple(sorted(self.__dict__.items())))

len(set([n1, n2, n3])) # 1

Wynik końcowy wygląda tak (dodałem kilka twierdzeń na końcu dla walidacji):

class Number:

    def __init__(self, number):
        self.number = number

    def __eq__(self, other):
        """Overrides the default implementation"""
        if isinstance(other, Number):
            return self.number == other.number
        return NotImplemented

    def __ne__(self, other):
        """Overrides the default implementation (unnecessary in Python 3)"""
        x = self.__eq__(other)
        if x is not NotImplemented:
            return not x
        return NotImplemented

    def __hash__(self):
        """Overrides the default implementation"""
        return hash(tuple(sorted(self.__dict__.items())))


class SubNumber(Number):
    pass


n1 = Number(1)
n2 = Number(1)
n3 = SubNumber(1)
n4 = SubNumber(4)

assert n1 == n2
assert n2 == n1
assert not n1 != n2
assert not n2 != n1

assert n1 == n3
assert n3 == n1
assert not n1 != n3
assert not n3 != n1

assert not n1 == n4
assert not n4 == n1
assert n1 != n4
assert n4 != n1

assert len(set([n1, n2, n3, ])) == 1
assert len(set([n1, n2, n3, n4])) == 2