__cmp__ 대신 __lt__

Python 2.x에는 비교 연산자를 오버로드하는 두 가지 방법 __cmp__또는 __lt__. 풍부한 비교 과부하가 선호된다고하지만 이것이 왜 그런가요?

풍부한 비교 연산자는 각각을 구현하는 것이 더 간단하지만 거의 동일한 논리로 여러 연산자를 구현해야합니다. 그러나 내장 cmp및 튜플 순서를 사용할 수 있다면 __cmp__매우 간단 해지고 모든 비교를 수행 할 수 있습니다 .

class A(object):
  def __init__(self, name, age, other):
    self.name = name
    self.age = age
    self.other = other
  def __cmp__(self, other):
    assert isinstance(other, A) # assumption for this example
    return cmp((self.name, self.age, self.other),
               (other.name, other.age, other.other))

이 단순함은 풍부한 비교 6 (!)을 모두 오버로드하는 것보다 훨씬 더 내 요구를 충족하는 것 같습니다. (그러나 "교체 된 주장"/ 반영된 행동에 의존한다면 "단지"4로 낮출 수 있지만, 내 겸손한 의견으로는 순전히 합병증이 증가합니다.)

과부하 만 발생하는 경우 알아야 할 예상치 못한 함정이 __cmp__있습니까?

나는 이해 <, <=, ==, 등 사업자가 다른 목적을 위해 오버로드 할 수 있으며, 원하는 개체에게 그들이 반환 할 수 있습니다. 나는 그 접근 방식의 장점에 대해 묻는 것이 아니라 숫자를 의미하는 것과 같은 의미에서 비교를 위해 이러한 연산자를 사용할 때의 차이점에 대해서만 묻습니다.

업데이트 : 크리스토퍼으로 지적 , cmp3.x에서에서 사라지고있다 위와 같이 쉽게 비교를 구현할 수있는 대안이 __cmp__있습니까?

예, 예 __lt__를 들어 mixin 클래스 (또는 메타 클래스, 또는 취향이 그런 식으로 실행되는 경우 클래스 데코레이터)의 관점에서 모든 것을 구현하는 것은 쉽습니다 .

예를 들면 :

class ComparableMixin:
  def __eq__(self, other):
    return not self<other and not other<self
  def __ne__(self, other):
    return self<other or other<self
  def __gt__(self, other):
    return other<self
  def __ge__(self, other):
    return not self<other
  def __le__(self, other):
    return not other<self

이제 클래스는 __lt__ComparableMixin에서 상속을 정의 하고 곱할 수 있습니다 (필요한 다른베이스가있는 경우). 클래스 데코레이터는 데코 레이트하는 새 클래스의 속성과 유사한 함수를 삽입하기 만하면 매우 유사 할 것입니다 (결과는 메모리 측면에서 동일한 분 비용으로 런타임에 미세하게 더 빠를 수 있음).

클래스가 구현하는 몇 가지 특히 빠른 방법 (예)가있는 경우 물론, __eq__그리고 __ne__, 그것은 믹스 인의 버전 (경우에 즉, 예를 들어, 사용하지 않도록 직접 정의해야합니다 dict- 사실) __ne__도 용이하게 정의 될 수있다 다음과 같이 :

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

그러나 위의 코드에서 나는 <;-) 만 사용하는 즐거운 대칭을 유지하고 싶었습니다 . 왜에 관해서는 __cmp__우리가 있기 때문에, 가야했다 했다 가 __lt__친구, 왜, 주위 정확히 같은 일을 할 수있는 다른 방법을 다른 유지? 모든 Python 런타임 (Classic, Jython, IronPython, PyPy, ...)에서 매우 무겁습니다. 이라는 코드 확실히 버그가되지 않습니다이없는 코드입니다 - 거기에이 작업을 수행하기 위해 이상적으로 하나의 확실한 방법이 될한다고 그 파이썬의 원리는 (C는의 "성령 C의"절에 같은 원리를 가지고 어디서 ISO 표준, btw).

이것은 우리가 일을 금지하는 우리의 방법의 외출 의미하지 않는다 (예를 들어, 유지 mixin 어떤 용도 수준의 장식과 거의 동등한),하지만 확실히 않습니다 우리는 컴파일러와 코드를 들고 다니기 싫어한다는 것을 의미 / 또는 정확히 동일한 작업을 수행하는 여러 동등한 접근 방식을 지원하기 위해 중복 적으로 존재하는 런타임.

추가 편집 : 실제로 질문에 대한 __key__의견에서 언급했듯이 질문의 것을 포함하여 많은 클래스에 대한 비교 및 ​​해싱을 제공하는 더 나은 방법이 있습니다 . PEP를 작성 해본 적이 없기 때문에 현재 원하는 경우 Mixin (& c)을 사용하여 구현해야합니다.

class KeyedMixin:
  def __lt__(self, other):
    return self.__key__() < other.__key__()
  # and so on for other comparators, as above, plus:
  def __hash__(self):
    return hash(self.__key__())

인스턴스를 다른 인스턴스와 비교하는 것은 몇 개의 필드가있는 각각의 튜플을 비교하는 것으로 요약되는 매우 일반적인 경우이며 해싱은 정확히 동일한 기준으로 구현되어야합니다. __key__직접해야 할 특별한 방법 주소.

이 경우를 단순화하기 위해 Alex가 제안한 것을 구현하는 데 사용할 수있는 Python 2.7 + / 3.2 +, functools.total_ordering 의 클래스 데코레이터 가 있습니다. 문서의 예 :

@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()))

이것은 PEP 207-Rich Comparisons에서 다룹니다.

또한 __cmp__파이썬 3.0에서는 사라집니다. (참고 그것은에 존재하지 않는다고 http://docs.python.org/3.0/reference/datamodel.html 하지만 켜져 http://docs.python.org/2.7/reference/datamodel.html )

(댓글을 고려하여 17 년 6 월 17 일에 수정 됨)

위의 비슷한 mixin 답변을 시도했습니다. "없음"에 문제가 생겼습니다. 다음은 "None"과 동등 비교를 처리하는 수정 된 버전입니다. (나는 의미가 부족한 None과의 불평등 비교에 신경을 쓸 이유가 없다고 보았다) :

class ComparableMixin(object):

    def __eq__(self, other):
        if not isinstance(other, type(self)): 
            return NotImplemented
        else:
            return not self<other and not other<self

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

    def __gt__(self, other):
        if not isinstance(other, type(self)): 
            return NotImplemented
        else:
            return other<self

    def __ge__(self, other):
        if not isinstance(other, type(self)): 
            return NotImplemented
        else:
            return not self<other

    def __le__(self, other):
        if not isinstance(other, type(self)): 
            return NotImplemented
        else:
            return not other<self    

Alex Martelli의 ComparableMixin& KeyedMixin답변에 영감을 받아 다음 믹스 인을 생각해 냈습니다. 이를 통해 _compare_to()와 유사한 키 기반 비교를 사용 하는 단일 메서드 를 구현할 KeyedMixin수 있지만 클래스는 유형에 따라 가장 효율적인 비교 키를 선택할 수 있습니다 other. (이 믹스 인은 동등성을 테스트 할 수 있지만 순서가 아닌 객체에 대해서는별로 도움이되지 않습니다.)

class ComparableMixin(object):
    """mixin which implements rich comparison operators in terms of a single _compare_to() helper"""

    def _compare_to(self, other):
        """return keys to compare self to other.

        if self and other are comparable, this function 
        should return ``(self key, other key)``.
        if they aren't, it should return ``None`` instead.
        """
        raise NotImplementedError("_compare_to() must be implemented by subclass")

    def __eq__(self, other):
        keys = self._compare_to(other)
        return keys[0] == keys[1] if keys else NotImplemented

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

    def __lt__(self, other):
        keys = self._compare_to(other)
        return keys[0] < keys[1] if keys else NotImplemented

    def __le__(self, other):
        keys = self._compare_to(other)
        return keys[0] <= keys[1] if keys else NotImplemented

    def __gt__(self, other):
        keys = self._compare_to(other)
        return keys[0] > keys[1] if keys else NotImplemented

    def __ge__(self, other):
        keys = self._compare_to(other)
        return keys[0] >= keys[1] if keys else NotImplemented