Элегантные способы поддержки эквивалентности («равенства») в классах Python

Вам не нужно переопределять и __eq__, и __ne__, вы можете переопределить только __cmp__, но это повлияет на результат ==,! ==, <,> и так далее.

is проверяет идентичность объекта. Это означает, что is b будет True в случае, когда a и b оба содержат ссылку на один и тот же объект. В python вы всегда держите ссылку на объект в переменной, а не на фактическом объекте, поэтому, по сути, для того, чтобы a is b было истинным, объекты в них должны находиться в одной и той же области памяти. Как и, что наиболее важно, зачем вам отменять такое поведение?

Обновлено: я не знал, что __cmp__ был удален из python 3, поэтому избегайте этого.

Я думаю, что вам нужны два термина: равенство (==) и личность (is). Например:

>>> a = [1,2,3]
>>> b = [1,2,3]
>>> a == b
True       <-- a and b have values which are equal
>>> a is b
False      <-- a and b are not the same list object

То, как вы описываете, - это то, как я всегда это делал. Поскольку он полностью универсален, вы всегда можете разбить эту функциональность на класс миксина и унаследовать ее от классов, в которых вы хотите эту функциональность.

class CommonEqualityMixin(object):

    def __eq__(self, other):
        return (isinstance(other, self.__class__)
            and self.__dict__ == other.__dict__)

    def __ne__(self, other):
        return not self.__eq__(other)

class Foo(CommonEqualityMixin):

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

С наследованием нужно быть осторожным:

>>> class Foo:
    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.__dict__ == other.__dict__
        else:
            return False

>>> class Bar(Foo):pass

>>> b = Bar()
>>> f = Foo()
>>> f == b
True
>>> b == f
False

Проверяйте типы более строго, например:

def __eq__(self, other):
    if type(other) is type(self):
        return self.__dict__ == other.__dict__
    return False

Кроме того, ваш подход будет работать нормально, для этого существуют специальные методы.

Тест is будет проверять идентичность с помощью встроенной функции id (), которая по существу возвращает адрес памяти объекта и, следовательно, не является перегружаемой.

Однако в случае проверки равенства класса вы, вероятно, захотите быть немного более строгим в своих тестах и ​​сравнивать только атрибуты данных в своем классе:

import types

class ComparesNicely(object):

    def __eq__(self, other):
        for key, value in self.__dict__.iteritems():
            if (isinstance(value, types.FunctionType) or 
                    key.startswith("__")):
                continue

            if key not in other.__dict__:
                return False

            if other.__dict__[key] != value:
                return False

         return True

Этот код будет сравнивать только элементы данных, не являющиеся функциями вашего класса, а также пропускать что-либо частное, что обычно является тем, что вы хотите. В случае с обычными старыми объектами Python у меня есть базовый класс, который реализует __init__, __str__, __repr__ и __eq__, поэтому мои объекты POPO не несут бремя всей этой дополнительной (и в большинстве случаев идентичной) логики.

Это не прямой ответ, но он казался достаточно актуальным, чтобы его можно было добавить, поскольку он иногда избавляет от многословной скуки. Вырезано прямо из документации ...

functools.total_ordering (cls)

Учитывая класс, определяющий один или несколько методов упорядочивания с расширенными возможностями сравнения, этот декоратор класса предоставляет все остальное. Это упрощает работу, связанную с указанием всех возможных операций расширенного сравнения:

Класс должен определять один из __lt__(), __le__(), __gt__() или __ge__(). Кроме того, класс должен предоставить метод __eq__().

Новое в версии 2.7

@total_ordering
class Student:
    def __eq__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) ==
                (other.lastname.lower(), other.firstname.lower()))
    def __lt__(self, other):
        return ((self.lastname.lower(), self.firstname.lower()) <
                (other.lastname.lower(), other.firstname.lower()))

Рассмотрим эту простую задачу:

class Number:

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


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

n1 == n2 # False -- oops

Итак, Python по умолчанию использует идентификаторы объектов для операций сравнения:

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

Кажется, что переопределение функции __eq__ решает проблему:

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

В Python 2 всегда не забывайте также переопределить функцию __ne__, поскольку документация утверждает:

There are no implied relationships among the comparison operators. The truth of x==y does not imply that x!=y is false. Accordingly, when defining __eq__(), one should also define __ne__() so that the operators will behave as expected.

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


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

В Python 3 в этом больше нет необходимости, поскольку документация утверждает:

By default, __ne__() delegates to __eq__() and inverts the result unless it is NotImplemented. There are no other implied relationships among the comparison operators, for example, the truth of (x<y or x==y) does not imply 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

Примечание: Python 2 имеет два типа классов:

• Классы классический стиль (или Старый стиль), которые наследуют нет от object и объявлены как class A:, class A(): или class A(B):, где B - класс классического стиля;

• Классы новый стиль, которые наследуются от object и объявлены как class A(object) или class A(B):, где B - это класс нового стиля. В Python 3 есть только классы нового стиля, которые объявлены как class A:, class A(object): или class A(B):.

Для классов классического стиля операция сравнения всегда вызывает метод первого операнда, а для классов нового стиля всегда вызывает метод операнда подкласса, независимо от порядка операндов.

Итак, если Number - это класс в классическом стиле:

• n1 == n3 вызывает n1.__eq__;
• n3 == n1 вызывает n3.__eq__;
• n1 != n3 вызывает n1.__ne__;
• n3 != n1 вызывает n3.__ne__.

И если Number - это класс нового стиля:

• как n1 == n3, так и n3 == n1 называют n3.__eq__;
• как n1 != n3, так и n3 != n1 называют n3.__ne__.

Чтобы исправить проблему некоммутативности операторов == и != для классов классического стиля Python 2, методы __eq__ и __ne__ должны возвращать значение NotImplemented, когда тип операнда не поддерживается. документация определяет значение NotImplemented как:

Numeric methods and rich comparison methods may return this value if they do not implement the operation for the operands provided. (The interpreter will then try the reflected operation, or some other fallback, depending on the operator.) Its truth value is true.

В этом случае оператор делегирует операцию сравнения отраженный метод операнда Другие. документация определяет отраженные методы как:

There are no swapped-argument versions of these methods (to be used when the left argument does not support the operation but the right argument does); rather, __lt__() and __gt__() are each other’s reflection, __le__() and __ge__() are each other’s reflection, and __eq__() and __ne__() are their own reflection.

Результат выглядит так:

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 NotImplemented:
        return NotImplemented
    return not x

Возвращение значения NotImplemented вместо False является правильным решением даже для классов нового стиля, если коммутативность операторов == и != желательно, когда операнды не связаны между собой (без наследования).

Мы уже на месте? Не совсем. Сколько у нас уникальных номеров?

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

Наборы используют хеши объектов, и по умолчанию Python возвращает хеш идентификатора объекта. Попробуем отменить это:

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

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

Конечный результат выглядит так (я добавил несколько утверждений в конце для проверки):

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

Из этого ответа: https://stackoverflow.com/a/30676267/541136 Я продемонстрировал это, хотя правильно определять __ne__ в терминах __eq__ - вместо

def __ne__(self, other):
    return not self.__eq__(other)

вы должны использовать:

def __ne__(self, other):
    return not self == other

Вместо использования подклассов / миксинов я предпочитаю использовать декоратор общего класса.

def comparable(cls):
    """ Class decorator providing generic comparison functionality """

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

    def __ne__(self, other):
        return not self.__eq__(other)

    cls.__eq__ = __eq__
    cls.__ne__ = __ne__
    return cls

Применение:

@comparable
class Number(object):
    def __init__(self, x):
        self.x = x

a = Number(1)
b = Number(1)
assert a == b

Это включает комментарии к ответу Алгориаса и сравнивает объекты по одному атрибуту, потому что меня не волнует весь dict. hasattr(other, "id") должен быть истинным, но я знаю, что это потому, что я установил его в конструкторе.

def __eq__(self, other):
    if other is self:
        return True

    if type(other) is not type(self):
        # delegate to superclass
        return NotImplemented

    return other.id == self.id