Для записи, канонически правильный и перекрестный переносимый Py2 / Py3 __ne__ будет выглядеть так:

import sys

class ...:
    ...
    def __eq__(self, other):
        ...

    if sys.version_info[0] == 2:
        def __ne__(self, other):
            equal = self.__eq__(other)
            return equal if equal is NotImplemented else not equal

Это работает с любыми __eq__, которые вы можете определить:

• В отличие от not (self == other), не мешает в некоторых раздражающих / сложных случаях, связанных с сравнениями, когда один из задействованных классов не подразумевает, что результат __ne__ совпадает с результатом not на __eq__ (например, ORM SQLAlchemy, где и __eq__, и __ne__ возвращают специальные прокси-объекты, а не True или False, и попытка not результата __eq__ вернет False, а не правильный прокси-объект).
• В отличие от not self.__eq__(other), это правильно делегирует __ne__ другого экземпляра, когда self.__eq__ возвращает NotImplemented (not self.__eq__(other) было бы еще более неправильным, потому что NotImplemented является правдой, поэтому, когда __eq__ не знал, как выполнить сравнение, __ne__ вернет False, подразумевая, что два объекта были равны, хотя на самом деле единственный запрошенный объект понятия не имел, что означало бы, что по умолчанию не равно)

Если ваш __eq__ не использует NotImplemented возвраты, это работает (с бессмысленными накладными расходами), если он иногда использует NotImplemented, это обрабатывает его правильно. А проверка версии Python означает, что если класс import-ed в Python 3, __ne__ остается неопределенным, что позволяет использовать собственный эффективный запасной вариант Python _ 29_ реализация (версия C из вышеперечисленного).

Зачем это нужно

Правила перегрузки Python

Объяснение того, почему вы делаете это вместо других решений, несколько загадочно. В Python есть пара общих правил относительно операторов перегрузки и, в частности, операторов сравнения:

1. (Применимо ко всем операторам) При запуске LHS OP RHS попробуйте LHS.__op__(RHS), а если это вернет NotImplemented, попробуйте RHS.__rop__(LHS). Исключение: если RHS является подклассом класса LHS, сначала проверьте RHS.__rop__(LHS) . В случае операторов сравнения __eq__ и __ne__ являются их собственными "rop" s (так что порядок проверки для __ne__ - LHS.__ne__(RHS), затем RHS.__ne__(LHS), обратный, если RHS является подклассом класса LHS)
2. Помимо идеи «замененного» оператора, между операторами не существует подразумеваемой связи. Даже для экземпляра того же класса LHS.__eq__(RHS), возвращающий True, не подразумевает, что LHS.__ne__(RHS) возвращает False (на самом деле, операторы даже не обязаны возвращать логические значения; ORM, такие как SQLAlchemy, намеренно этого не делают, что позволяет использовать более выразительный синтаксис запроса). В Python 3 реализация по умолчанию __ne__ ведет себя так, но не по контракту; вы можете переопределить __ne__ способами, которые не являются строгими противоположностями __eq__.

Как это применимо к компараторам с перегрузкой

Итак, когда вы перегружаете оператора, у вас есть две задачи:

1. Если вы знаете, как реализовать операцию самостоятельно, сделайте это, используя только свои собственные знания о том, как выполнять сравнение (никогда не делегируйте, неявно или явно, другой стороне операции; это рискует некорректность и / или бесконечная рекурсия, в зависимости от того, как вы это делаете)
2. Если вы не знаете, как реализовать операцию самостоятельно, всегда возвращайте NotImplemented, чтобы Python мог делегировать реализацию другому операнду.

Проблема с not self.__eq__(other)

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

никогда не передает полномочия другой стороне (и неверно, если __eq__ правильно возвращает NotImplemented). Когда self.__eq__(other) возвращает NotImplemented (что является «правдой»), вы молча возвращаетесь False, поэтому A() != something_A_knows_nothing_about возвращает False, когда он должен был проверить, знает ли something_A_knows_nothing_about, как сравнивать с экземплярами A, а если нет, он должен был вернуть True (поскольку, если ни одна из сторон не знает, как сравнивать друг друга, они считаются не равными друг другу). Если A.__eq__ реализован неправильно (возвращает False вместо NotImplemented, когда он не распознает другую сторону), то это "правильно" с точки зрения A, возвращая True (поскольку A не считает это равным, поэтому он не равен), но это могло быть неправильно с точки зрения something_A_knows_nothing_about, так как он никогда даже не спрашивал something_A_knows_nothing_about; A() != something_A_knows_nothing_about заканчивается True, но something_A_knows_nothing_about != A() может False или любое другое возвращаемое значение.

Проблема с not self == other

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

более тонкий. Это будет правильно для 99% классов, включая все классы, для которых __ne__ является логическим обратным __eq__. Но not self == other нарушает оба упомянутых выше правила, что означает, что для классов, где __ne__ не является логическим обратным __eq__, результаты снова несимметричны, потому что один из операндов никогда не запрашивается, если он вообще может реализовать __ne__, даже если другой операнд не может. Простейший пример - это странный класс, который возвращает False для всех сравнений, поэтому оба A() == Incomparable() и A() != Incomparable() возвращают False. При правильной реализации A.__ne__ (та, которая возвращает NotImplemented, когда не знает, как проводить сравнение), связь симметрична; A() != Incomparable() и Incomparable() != A() согласовывают результат (поскольку в первом случае A.__ne__ возвращает NotImplemented, затем Incomparable.__ne__ возвращает False, а во втором Incomparable.__ne__ возвращает False напрямую). Но когда A.__ne__ реализован как return not self == other, A() != Incomparable() возвращает True (поскольку A.__eq__ возвращается, а не NotImplemented, тогда Incomparable.__eq__ возвращает False, а A.__ne__ инвертирует это в True), а Incomparable() != A() возвращает False.

Вы можете увидеть пример этого в действии здесь .

 results = session.query(MyTable).filter(MyTable.fieldname != MyClassWithBadNE())

 results = session.query(MyTable).filter(MyClassWithBadNE() != MyTable.fieldname)

Правильная __ne__ реализация

Реализация специального метода __ne__ в @ ShadowRanger является правильной:

def __ne__(self, other):
    result = self.__eq__(other)
    if result is not NotImplemented:
        return not result
    return NotImplemented

Это также реализация по умолчанию специального метода __ne__ начиная с Python 3.4, поскольку указано в документации Python:

По умолчанию __ne__() делегирует __eq__() и инвертирует результат, если он не NotImplemented.

Также обратите внимание, что возврат значения NotImplemented для неподдерживаемых операндов не зависит от специального метода __ne__. Фактически, все специальные методы сравнения ¹ и специальные числовые методы ² должны возвращать значение NotImplemented для неподдерживаемых операндов, как указано в теге Документация Python:

Не реализованы

Этот тип имеет единственное значение. Это единственный объект с этим значением. Доступ к этому объекту осуществляется через встроенное имя NotImplemented. Числовые методы и методы расширенного сравнения должны возвращать это значение, если они не реализуют операцию для предоставленных операндов. (Интерпретатор затем попробует отраженную операцию или какой-либо другой запасной вариант, в зависимости от оператора.) Его истинное значение истинно.

Пример специальных числовых методов приведен в Python документация:

class MyIntegral(Integral):

    def __add__(self, other):
        if isinstance(other, MyIntegral):
            return do_my_adding_stuff(self, other)
        elif isinstance(other, OtherTypeIKnowAbout):
            return do_my_other_adding_stuff(self, other)
        else:
            return NotImplemented

    def __radd__(self, other):
        if isinstance(other, MyIntegral):
            return do_my_adding_stuff(other, self)
        elif isinstance(other, OtherTypeIKnowAbout):
            return do_my_other_adding_stuff(other, self)
        elif isinstance(other, Integral):
            return int(other) + int(self)
        elif isinstance(other, Real):
            return float(other) + float(self)
        elif isinstance(other, Complex):
            return complex(other) + complex(self)
        else:
            return NotImplemented

¹ Специальные методы сравнения: __lt__, __le__, __eq__, __ne__, __gt__ и __ge__.

² Специальные числовые методы: __add__, __sub__, __mul__, __matmul__, __truediv__, __floordiv__, __mod__, __divmod__, __pow__, __lshift__, __rshift__, __and__, __xor__, __or__ и их __r*__ отраженные и __i*__ на месте аналоги .

Неправильная __ne__ реализация №1

@Falmarri применяет специальный метод __ne__ неверно:

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

Проблема с этой реализацией заключается в том, что она не использует специальный метод __ne__ другого операнда, поскольку он никогда не возвращает значение NotImplemented (выражение not self.__eq__(other) оценивается как значение True или False, в том числе когда его подвыражение self.__eq__(other) оценивается как значение NotImplemented поскольку выражение bool(NotImplemented) оценивается как значение True). Логическое вычисление значения NotImplemented нарушает связь дополнение между операторами сравнения != и ==:

class Correct:

    def __ne__(self, other):
        result = self.__eq__(other)
        if result is not NotImplemented:
            return not result
        return NotImplemented


class Incorrect:

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


x, y = Correct(), Correct()
assert (x != y) is not (x == y)

x, y = Incorrect(), Incorrect()
assert (x != y) is not (x == y)  # AssertionError

Неправильная __ne__ реализация №2

Реализация специального метода __ne__ в @AaronHall также неверна:

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

Проблема с этой реализацией заключается в том, что она напрямую обращается к специальному методу __eq__ другого операнда, минуя специальный метод __ne__ другого операнда, поскольку он никогда не возвращает значение NotImplemented (выражение not self == other возвращается к специальному методу __eq__ из другой операнд и оценивается как значение True или False). Обход метода неверен, поскольку этот метод может иметь побочные эффекты как обновление состояния объекта:

class Correct:

    def __init__(self):
        self.counter = 0

    def __ne__(self, other):
        self.counter += 1
        result = self.__eq__(other)
        if result is not NotImplemented:
            return not result
        return NotImplemented


class Incorrect:

    def __init__(self):
        self.counter = 0

    def __ne__(self, other):
        self.counter += 1
        return not self == other


x, y = Correct(), Correct()
assert x != y
assert x.counter == y.counter

x, y = Incorrect(), Incorrect()
assert x != y
assert x.counter == y.counter  # AssertionError

В математике двоичное отношение R над набором X - это набор упорядоченных пар (x, y) в X ² . Выражение (x, y) в R читается как x и связано с R до y и обозначается xRy.

class X:

    def __operator__(self, other):
        # implementation

1. Он вызывает x.__operator__(y), если класс правого операнда не является потомком класса левого операнда. В этом случае он вызывает y.__operatorT__(x) (позволяя классам переопределять специальный обратный метод сравнения своих предков).
2. Если операнды x и y не поддерживаются (на это указывает возвращаемое значение NotImplemented), он вызывает обратный специальный метод сравнения как 1-й резерв.
3. Если операнды x и y не поддерживаются (на это указывает возвращаемое значение NotImplemented), он вызывает исключение TypeError за исключением операторов сравнения == и !=, для которых он сравнивает, соответственно, идентичность и неидентичность операндов x и y как < em> 2-й запасной вариант (с использованием свойства рефлексивности == и свойства нерефлексивности !=).
4. Возвращает результат.

В CPython это реализовано в коде C, который можно перевести в код Python (с именами eq для ==, ne для !=, lt для <, gt для >, le для <= и ge для >=):

def eq(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__eq__(left)
        if result is NotImplemented:
            result = left.__eq__(right)
    else:
        result = left.__eq__(right)
        if result is NotImplemented:
            result = right.__eq__(left)
    if result is NotImplemented:
        result = left is right
    return result

def ne(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__ne__(left)
        if result is NotImplemented:
            result = left.__ne__(right)
    else:
        result = left.__ne__(right)
        if result is NotImplemented:
            result = right.__ne__(left)
    if result is NotImplemented:
        result = left is not right
    return result

def lt(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__gt__(left)
        if result is NotImplemented:
            result = left.__lt__(right)
    else:
        result = left.__lt__(right)
        if result is NotImplemented:
            result = right.__gt__(left)
    if result is NotImplemented:
        raise TypeError(
            f"'<' not supported between instances of '{type(left).__name__}' "
            f"and '{type(right).__name__}'"
        )
    return result

def gt(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__lt__(left)
        if result is NotImplemented:
            result = left.__gt__(right)
    else:
        result = left.__gt__(right)
        if result is NotImplemented:
            result = right.__lt__(left)
    if result is NotImplemented:
        raise TypeError(
            f"'>' not supported between instances of '{type(left).__name__}' "
            f"and '{type(right).__name__}'"
        )
    return result

def le(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__ge__(left)
        if result is NotImplemented:
            result = left.__le__(right)
    else:
        result = left.__le__(right)
        if result is NotImplemented:
            result = right.__ge__(left)
    if result is NotImplemented:
        raise TypeError(
            f"'<=' not supported between instances of '{type(left).__name__}' "
            f"and '{type(right).__name__}'"
        )
    return result

def ge(left, right):
    if type(left) != type(right) and isinstance(right, type(left)):
        result = right.__le__(left)
        if result is NotImplemented:
            result = left.__ge__(right)
    else:
        result = left.__ge__(right)
        if result is NotImplemented:
            result = right.__le__(left)
    if result is NotImplemented:
        raise TypeError(
            f"'>=' not supported between instances of '{type(left).__name__}' "
            f"and '{type(right).__name__}'"
        )
    return result

Поскольку R = ¬ (¬ R), сравнение xRy эквивалентно дополнительному сравнению ¬ ( х ¬ Ry). ≠ является дополнением к =, поэтому специальный метод __ne__ реализуется в терминах специального метода __eq__ для поддерживаемых операндов по умолчанию, в то время как другие специальные методы сравнения реализуются независимо по умолчанию (факт, что ≤ является объединением ‹и = , а ≥ является объединением ›и = является на удивление не рассматривается, что означает, что в настоящее время специальные методы __le__ и __ge__ должны быть реализованы пользователем), как описано в Документация Python:

По умолчанию __ne__() делегирует __eq__() и инвертирует результат, если он не NotImplemented. Нет никаких других подразумеваемых отношений между операторами сравнения, например, истинность (x<y or x==y) не подразумевает x<=y.

В CPython это реализовано в коде C, который можно перевести в код Python:

def __eq__(self, other):
    return self is other or NotImplemented

def __ne__(self, other):
    result = self.__eq__(other)
    if result is not NotImplemented:
        return not result
    return NotImplemented

def __lt__(self, other):
    return NotImplemented

def __gt__(self, other):
    return NotImplemented

def __le__(self, other):
    return NotImplemented

def __ge__(self, other):
    return NotImplemented

Итак, по умолчанию:

• операция сравнения x operator y вызывает исключение TypeError за исключением операторов сравнения == и !=, для которых она возвращает соответственно значения True и False, если операнды x и y соответственно идентичны и неидентичны, и значения False и True в противном случае;
• вызов специального метода сравнения x.__operator__(y) возвращает значение NotImplemented, за исключением специальных методов сравнения __eq__ и __ne__, для которых он возвращает соответственно значения True и False, если операнды x и y соответственно идентичны и неидентичны, и значение NotImplemented в противном случае.

Если все __eq__, __ne__, __lt__, __ge__, __le__ и __gt__ имеют смысл для класса, тогда просто реализуйте __cmp__ вместо этого. В противном случае делайте то, что делаете, из-за того, что сказал Даниэль ДиПаоло (пока я тестировал его, а не искал;))