Python, __ne__()기반으로 연산자를 구현해야 __eq__합니까?

짧은 답변 : 구현하지 마십시오.하지만 필요한 경우 사용 ==하지 말고__eq__

Python 3에서는 기본적으로 !=의 부정이므로을 ==작성할 필요도 __ne__없으며 문서는 더 이상 작성에 대한 의견이 없습니다.

일반적으로 Python 3 전용 코드의 경우 내장 객체와 같은 부모 구현을 가리지 않으면 코드를 작성하지 마십시오.

즉, Raymond Hettinger의 의견 을 염두에 두십시오 .

이 __ne__메서드 는 수퍼 클래스에 아직 정의되지 않은 __eq__경우에만
자동으로 따릅니다 __ne__. 따라서 내장에서 상속하는 경우 둘 다 재정의하는 것이 가장 좋습니다.

Python 2에서 작동하는 코드가 필요한 경우 Python 2에 대한 권장 사항을 따르십시오. 그러면 Python 3에서 정상적으로 작동합니다.

파이썬 2에서 파이썬 자체가 자동으로 다른 측면에서 어떤 동작을 구현하지 않습니다 – 따라서를 정의해야 __ne__측면에서 ==대신의 __eq__. EG

class A(object):
    def __eq__(self, other):
        return self.value == other.value

    def __ne__(self, other):
        return not self == other # NOT `return not self.__eq__(other)`

증거보기

• 구현 __ne__()__eq__및 기반 연산자
• __ne__Python 2에서 전혀 구현하지 않음

아래 데모에서 잘못된 동작을 제공합니다.

긴 답변

문서 파이썬 2는 말합니다 :

비교 연산자 간에는 암시 적 관계가 없습니다. 의 진실은 x==y그것이 x!=y거짓 임을 의미하지 않습니다 . 따라서 정의 할 때 연산자가 예상대로 작동하도록 __eq__()정의 __ne__()해야합니다.

즉 , __ne__의 역으로 정의 __eq__하면 일관된 동작을 얻을 수 있습니다.

이 문서 섹션은 Python 3 용으로 업데이트되었습니다 .

기본적 으로는를 __ne__()위임 __eq__()하고 결과가 아닌 경우 결과를 반전합니다 NotImplemented.

과에서 “새로운 기능”섹션 , 우리는이 동작이 변경된 참조 :

• !=이제를 반환 ==하지 않는 ==한의 반대를 반환합니다 NotImplemented.

구현__ne__== 을 위해 __eq__메서드를 직접 사용하는 대신 연산자 를 사용하여self.__eq__(other) 하위 클래스가 NotImplemented검사 된 유형에 대해 반환 하면 Python이 other.__eq__(self) 문서에서 다음 을 적절하게 검사 합니다 .

그만큼 NotImplemented객체

이 유형에는 단일 값이 있습니다. 이 값을 가진 단일 개체가 있습니다. 이 개체는 기본 제공 이름을 통해 액세스됩니다.
NotImplemented . 숫자 메서드 및 풍부한 비교 메서드는 제공된 피연산자에 대한 연산을 구현하지 않는 경우이 값을 반환 할 수 있습니다. (그런 다음 인터프리터는 연산자에 따라 반영된 작업 또는 다른 폴백을 시도합니다.) 진실 값은 참입니다.

그들은, 파이썬 검사 동일한 형태가 아닌 경우 풍부한 비교 연산자가 주어진 경우,이 경우 other서브 타입이며,이 정의 된 연산자를 갖는 경우, 사용 other(위한 역 제의 방법을 <, <=, >=및 >). 경우 NotImplemented반환, 다음 은 그 반대의 방법을 사용합니다. ( 동일한 방법을 두 번 확인 하지 않습니다 .) ==연산자를 사용하면이 논리가 발생할 수 있습니다.

기대

__ne__클래스의 사용자는 A.의 모든 인스턴스에 대해 다음 함수가 동일 할 것으로 기대하기 때문에 의미 상 동등성 검사 측면에서 구현해야합니다 .

def negation_of_equals(inst1, inst2):
    """always should return same as not_equals(inst1, inst2)"""
    return not inst1 == inst2

def not_equals(inst1, inst2):
    """always should return same as negation_of_equals(inst1, inst2)"""
    return inst1 != inst2

즉, 위의 두 함수는 항상 동일한 결과를 반환 해야합니다 . 그러나 이것은 프로그래머에 따라 다릅니다.

다음을 __ne__기반으로 정의 할 때 예상치 못한 동작의 시연 __eq__:

먼저 설정 :

class BaseEquatable(object):
    def __init__(self, x):
        self.x = x
    def __eq__(self, other):
        return isinstance(other, BaseEquatable) and self.x == other.x

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

class ComparableRight(BaseEquatable):
    def __ne__(self, other):
        return not self == other

class EqMixin(object):
    def __eq__(self, other):
        """override Base __eq__ & bounce to other for __eq__, e.g.
        if issubclass(type(self), type(other)): # True in this example
        """
        return NotImplemented

class ChildComparableWrong(EqMixin, ComparableWrong):
    """__ne__ the wrong way (__eq__ directly)"""

class ChildComparableRight(EqMixin, ComparableRight):
    """__ne__ the right way (uses ==)"""

class ChildComparablePy3(EqMixin, BaseEquatable):
    """No __ne__, only right in Python 3."""

동일하지 않은 인스턴스를 인스턴스화합니다.

right1, right2 = ComparableRight(1), ChildComparableRight(2)
wrong1, wrong2 = ComparableWrong(1), ChildComparableWrong(2)
right_py3_1, right_py3_2 = BaseEquatable(1), ChildComparablePy3(2)

예상되는 동작 :

(참고 : 아래 각 항목의 모든 두 번째 주장은 동일하므로 이전 항목과 논리적으로 중복되지만 하나가 다른 항목의 하위 클래스 일 때 순서가 중요하지 않음 을 보여주기 위해 포함합니다 . )

이러한 인스턴스는 다음으로 __ne__구현되었습니다 ==.

assert not right1 == right2
assert not right2 == right1
assert right1 != right2
assert right2 != right1

Python 3에서 테스트하는 이러한 인스턴스도 올바르게 작동합니다.

assert not right_py3_1 == right_py3_2
assert not right_py3_2 == right_py3_1
assert right_py3_1 != right_py3_2
assert right_py3_2 != right_py3_1

그리고 이것들이 다음과 같이 __ne__구현 되었음을 __eq__상기하십시오. 이것은 예상되는 동작이지만 구현은 올바르지 않습니다.

assert not wrong1 == wrong2         # These are contradicted by the
assert not wrong2 == wrong1         # below unexpected behavior!

예상치 못한 동작 :

이 비교는 위의 비교 ( not wrong1 == wrong2) 와 모순 됩니다.

>>> assert wrong1 != wrong2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

과,

>>> assert wrong2 != wrong1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

__ne__Python 2에서 건너 뛰지 마십시오.

__ne__Python 2에서 구현 을 건너 뛰지 않아야한다는 증거는 다음과 같은 동등한 객체를 참조하세요.

>>> right_py3_1, right_py3_1child = BaseEquatable(1), ChildComparablePy3(1)
>>> right_py3_1 != right_py3_1child # as evaluated in Python 2!
True

위의 결과는 False!

Python 3 소스

에 대한 기본 CPython 구현 __ne__은 다음 위치 typeobject.c에 있습니다object_richcompare .

case Py_NE:
    /* By default, __ne__() delegates to __eq__() and inverts the result,
       unless the latter returns NotImplemented. */
    if (Py_TYPE(self)->tp_richcompare == NULL) {
        res = Py_NotImplemented;
        Py_INCREF(res);
        break;
    }
    res = (*Py_TYPE(self)->tp_richcompare)(self, other, Py_EQ);
    if (res != NULL && res != Py_NotImplemented) {
        int ok = PyObject_IsTrue(res);
        Py_DECREF(res);
        if (ok < 0)
            res = NULL;
        else {
            if (ok)
                res = Py_False;
            else
                res = Py_True;
            Py_INCREF(res);
        }
    }
    break;

하지만 기본값 __ne__은 __eq__?

더 높은 수준 ( PyObject_RichCompare )이 덜 효율적 이기 때문에 __ne__C 수준에서 Python 3의 기본 구현 세부 정보를 사용 __eq__하므로 처리해야합니다.==NotImplemented .

경우 __eq__올바르게 구현, 다음의 부정은 ==또한 올 – 그것은 우리가 우리의 낮은 수준의 구현 세부 사항을 피할 수 있습니다 __ne__.

사용은 ==우리의 낮은 수준의 논리를 유지하기 위해 우리를 허용 한 곳, 그리고 피 주소 NotImplemented에 __ne__.

==반환 될 수 있다고 잘못 가정 할 수 있습니다 NotImplemented.

실제로 __eq__ID를 확인하는 의 기본 구현과 동일한 논리를 사용합니다 (아래의 do_richcompare 및 증거 참조).

class Foo:
    def __ne__(self, other):
        return NotImplemented
    __eq__ = __ne__

f = Foo()
f2 = Foo()

그리고 비교 :

>>> f == f
True
>>> f != f
False
>>> f2 == f
False
>>> f2 != f
True

공연

내 말을 믿지 말고 더 성능이 좋은 것을 보자.

class CLevel:
    "Use default logic programmed in C"

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

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

def c_level():
    cl = CLevel()
    return lambda: cl != cl

def high_level_python():
    hlp = HighLevelPython()
    return lambda: hlp != hlp

def low_level_python():
    llp = LowLevelPython()
    return lambda: llp != llp

이러한 성능 수치가 스스로를 대변한다고 생각합니다.

>>> import timeit
>>> min(timeit.repeat(c_level()))
0.09377292497083545
>>> min(timeit.repeat(high_level_python()))
0.2654011140111834
>>> min(timeit.repeat(low_level_python()))
0.3378178110579029

이것은 low_level_python그렇지 않으면 C 레벨에서 처리 될 파이썬에서 로직을 수행 한다고 생각할 때 의미가 있습니다 .

일부 비평가에 대한 응답

다른 답변자는 다음과 같이 씁니다.

Aaron Hall의 메서드 구현 not self == other은 ( is ) __ne__절대 반환 할 수 없기 때문에 올바르지 않으므로 우선 순위가 있는 메서드는 우선 순위가없는 메서드로 대체 될 수 없습니다 .NotImplementednot NotImplementedFalse__ne____ne__

데 __ne__결코 돌아 가기 NotImplemented가 잘못된하지 않습니다. 대신 NotImplemented.NET과의 동등성 검사를 통해 우선 순위를 처리 ==합니다. ==올바르게 구현 되었다고 가정하면 완료됩니다.

not self == other이전에는 __ne__메서드 의 기본 Python 3 구현 이었지만 버그였으며 ShadowRanger가 발견 한대로 2015 년 1 월 Python 3.4에서 수정되었습니다 (문제 # 21408 참조).

글쎄, 이것을 설명합시다.

앞서 언급했듯이 Python 3은 기본적 __ne__으로 먼저 self.__eq__(other)반환 여부 NotImplemented(싱글 톤)를 확인하여 처리합니다. 이 경우 확인하고 반환 해야합니다 is. 그렇지 않으면 역을 반환해야합니다. 다음은 클래스 믹스 인으로 작성된 논리입니다.

class CStyle__ne__:
    """Mixin that provides __ne__ functionality equivalent to
    the builtin functionality
    """
    def __ne__(self, other):
        equal = self.__eq__(other)
        if equal is NotImplemented:
            return NotImplemented
        return not equal

이것은 C 레벨 Python API의 정확성을 위해 필요하며 Python 3에서 도입되어

• __ne__문제 21408 을 종결하는 이 패치 의 방법 하고
• __ne__여기에서 제거 된 후속 정리 의 방법

불필요한. __ne__자체 검사를 구현하는 방법 과 __eq__직접 또는 통해 위임하는 방법을 포함하여 모든 관련 방법이 제거 되었으며 가장 일반적인 방법이었습니다.====

대칭이 중요합니까?

우리의 끊임없는 비평가는 무엇보다 대칭을 중요시 하는 NotImplemented에서 취급하는 사례를 만드는 병리학적인 예를 제공합니다 __ne__. 명확한 예를 들어 스틸 맨의 주장을 들어 보자.

class B:
    """
    this class has no __eq__ implementation, but asserts
    any instance is not equal to any other object
    """
    def __ne__(self, other):
        return True

class A:
    "This class asserts instances are equivalent to all other objects"
    def __eq__(self, other):
        return True

>>> A() == B(), B() == A(), A() != B(), B() != A()
(True, True, False, True)

따라서이 논리에 의해 대칭을 유지하려면 __ne__Python 버전에 관계없이 복잡한을 작성해야합니다 .

class B:
    def __ne__(self, other):
        return True

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

>>> A() == B(), B() == A(), A() != B(), B() != A()
(True, True, True, True)

분명히 우리는 이러한 인스턴스가 동일하고 동일하지 않다는 사실을 신경 쓰지 말아야합니다.

나는 대칭이 합리적인 코드의 가정과 문서의 조언을 따르는 것보다 덜 중요하다고 제안합니다.

그러나 A가를 현명하게 구현 __eq__했다면 여기에서 내 방향을 따를 수 있고 여전히 대칭을 가질 수 있습니다.

class B:
    def __ne__(self, other):
        return True

class A:
    def __eq__(self, other):
        return False         # <- this boolean changed... 

>>> A() == B(), B() == A(), A() != B(), B() != A()
(False, False, True, True)

결론

Python 2 호환 코드의 경우를 사용 ==하여 __ne__. 더 많은 것 :

• 옳은
• 단순한
• 공연자

Python 3에서만 C 수준에서 저수준 부정을 사용합니다. 훨씬 더 간단하고 성능이 뛰어납니다 (프로그래머가 올바른지 판단 할 책임이 있습니다 ).

다시 말하지만, 고수준 Python에서 저수준 논리를 작성 하지 마십시오 .

답변

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

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

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

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

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

def __ne__(self, other):
    result = self.__eq__(other)

    if result is not NotImplemented:
        return not result

    return NotImplemented

def operator_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 operator_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 operator_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__}' and '{type(right).__name__}'")

    return result


def operator_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__}' and '{type(right).__name__}'")

    return result


def operator_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__}' and '{type(right).__name__}'")

    return result


def operator_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__}' and '{type(right).__name__}'")

    return result

def __eq__(self, other):
    return 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

class A:
    pass


class B:

    def __ne__(self, other):
        return "B.__ne__"


assert (A() != B()) == "B.__ne__"

class A:

    def __eq__(self, other):
        return True


class B:

    def __ne__(self, other):
        return "B.__ne__"


assert (A() != B()) is False

class A:

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


class B:

    def __ne__(self, other):
        return "B.__ne__"


assert (A() != B()) is True

class A:

    def __eq__(self, other):
        return True

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


class B:

    def __ne__(self, other):
        return "B.__ne__"


assert (A() != B()) is False