__lt__ замість __cmp__

У 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__?

Я розумію <, <=, ==і т.д. оператори можуть бути перевантажені для інших цілей, і може повернути будь-який об'єкт , їм подобається. Я не запитую про достоїнства такого підходу, а лише про відмінності при використанні цих операторів для порівнянь у тому ж сенсі, який вони означають для чисел.

Оновлення: як вказував Крістофер , cmpзникає в 3.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, ...). Код, у якому точно не буде помилок, - це код, якого немає - звідки в принципі Python, що в ідеалі повинен бути один очевидний спосіб виконання завдання (C має той же принцип у розділі "Spirit of C" стандарт ISO, btw).

Це не означає, що ми не можемо заборонити речі (наприклад, майже еквівалентність між комбінаціями та декораторами класів для деяких застосувань), але це, безумовно , означає, що нам не подобається переносити код у компіляторах та / або час виконання, який існує надто просто для підтримки декількох еквівалентних підходів до виконання однакових завдань.

Подальше редагування: насправді є ще кращий спосіб порівняння І хешування для багатьох класів, включаючи те, що у запитанні - __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__спеціальному методі адреса , які повинні безпосередньо.

Для спрощення цього випадку в 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 - Різні порівняння

Крім того, __cmp__йде в python 3.0. (Зверніть увагу, що його немає на http://docs.python.org/3.0/reference/datamodel.html, але він є на http://docs.python.org/2.7/reference/datamodel.html )

(Відредаговано 6/17/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    

Натхненний Алекс Мартелл - х ComparableMixinі KeyedMixinвідповіді, я придумав наступний Mixin. Це дозволяє реалізувати єдиний _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