__lt__ statt __cmp__

Python 2.x bietet zwei Möglichkeiten, um Vergleichsoperatoren __cmp__oder die "Rich-Vergleichsoperatoren" wie z __lt__. Die reichhaltigen Vergleichsüberladungen sollen bevorzugt werden, aber warum ist das so?

Umfangreiche Vergleichsoperatoren sind einfacher zu implementieren, Sie müssen jedoch mehrere davon mit nahezu identischer Logik implementieren. Wenn Sie jedoch die integrierte Reihenfolge cmpund die Tupelreihenfolge verwenden können , __cmp__wird dies recht einfach und erfüllt alle Vergleiche:

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

Diese Einfachheit scheint meine Bedürfnisse viel besser zu erfüllen, als alle 6 (!) Der reichhaltigen Vergleiche zu überladen. (Sie können es jedoch auf "nur" 4 reduzieren, wenn Sie sich auf das "getauschte Argument" / reflektiertes Verhalten verlassen, aber dies führt meiner bescheidenen Meinung nach zu einer Nettoerhöhung der Komplikationen.)

Gibt es unvorhergesehene Fallstricke, auf die ich aufmerksam gemacht werden muss, wenn ich nur überlastete __cmp__?

Ich verstehe das <, <=, ==, etc. können Betreiber für andere Zwecke überlastet werden und kann zurückkehren , jedes Objekt die sie mögen. Ich frage nicht nach den Vorzügen dieses Ansatzes, sondern nur nach Unterschieden, wenn diese Operatoren für Vergleiche in demselben Sinne verwendet werden, wie sie für Zahlen bedeuten.

Update: Wie Christopher betonte , cmpverschwindet es in 3.x. Gibt es Alternativen, die die Implementierung von Vergleichen so einfach wie oben machen __cmp__?

Ja, es ist einfach, alles zu implementieren, z. B. __lt__mit einer Mixin-Klasse (oder einer Metaklasse oder einem Klassendekorateur, wenn Ihr Geschmack so ist).

Beispielsweise:

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

Jetzt kann Ihre Klasse nur definieren __lt__und das Erben von ComparableMixin multiplizieren (nach allen anderen Basen, die sie benötigt, falls vorhanden). Ein Klassendekorateur wäre ziemlich ähnlich und würde nur ähnliche Funktionen als Attribute der neuen Klasse einfügen, die er dekoriert (das Ergebnis könnte zur Laufzeit mikroskopisch schneller sein, bei gleich geringen Speicherkosten).

Wenn Ihre Klasse eine besonders schnelle Möglichkeit zur Implementierung hat (z. B.) __eq__und __ne__diese direkt definieren sollte, damit die Versionen des Mixins nicht verwendet werden (z. B. für dict), kann dies __ne__möglicherweise zur Erleichterung definiert werden das als:

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

aber im obigen Code wollte ich die erfreuliche Symmetrie <beibehalten, nur zu verwenden ;-). Wie, warum __cmp__, gehen musste , da wir taten haben __lt__und Freunde, halten , warum eine andere, unterschiedliche Art und Weise genau die gleiche Sache um zu tun? Es ist einfach so viel Eigengewicht in jeder Python-Laufzeit (Classic, Jython, IronPython, PyPy, ...). Der Code, der definitiv keine Fehler aufweist, ist der Code, der nicht vorhanden ist - woher Pythons Prinzip, dass es idealerweise einen offensichtlichen Weg geben sollte, eine Aufgabe auszuführen (C hat das gleiche Prinzip im Abschnitt "Spirit of C" von der ISO-Standard übrigens).

Dies bedeutet nicht , dass wir unseren Weg gehen zu verbieten , Dinge (zB in der Nähe von -Äquivalenz zwischen Mixins und Klasse Dekorateure für einige Anwendungen), aber es definitiv tut bedeuten , dass wir nicht wie tragen Code in den Compiler und / oder redundant vorhandene Laufzeiten, nur um mehrere äquivalente Ansätze zu unterstützen, um genau dieselbe Aufgabe auszuführen.

Weitere Bearbeitung: Es gibt tatsächlich eine noch bessere Möglichkeit, Vergleiche UND Hashing für viele Klassen bereitzustellen, einschließlich der in der Frage - eine __key__Methode, wie ich in meinem Kommentar zur Frage erwähnt habe. Da ich nie dazu gekommen bin, das PEP dafür zu schreiben, müssen Sie es derzeit mit einem Mixin (& c) implementieren, wenn Sie es mögen:

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

Es ist ein sehr häufiger Fall, dass Vergleiche einer Instanz mit anderen Instanzen darauf hinauslaufen, ein Tupel für jede mit einigen Feldern zu vergleichen - und dann sollte Hashing auf genau derselben Basis implementiert werden. Die __key__speziellen Methodenadressen, die direkt benötigt werden.

Um diesen Fall zu vereinfachen, gibt es in Python 2.7 + / 3.2 + einen Klassendekorator , functools.total_ordering , mit dem implementiert werden kann, was Alex vorschlägt. Beispiel aus den Dokumenten:

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

Dies wird durch PEP 207 - Rich Comparisons abgedeckt

Auch __cmp__geht in Python 3.0 weg. (Beachten Sie, dass es nicht auf http://docs.python.org/3.0/reference/datamodel.html vorhanden ist, sondern auf http://docs.python.org/2.7/reference/datamodel.html )

(Bearbeitet am 17.06.17, um Kommentare zu berücksichtigen.)

Ich habe die vergleichbare Mixin-Antwort oben ausprobiert. Ich hatte Probleme mit "None". Hier ist eine modifizierte Version, die Gleichheitsvergleiche mit "Keine" behandelt. (Ich sah keinen Grund, mich mit Ungleichheitsvergleichen mit None als nicht semantisch zu beschäftigen):

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    

Inspiriert von Alex Martellis ComparableMixin& KeyedMixinAntworten, habe ich mir das folgende Mixin ausgedacht. Sie können eine einzelne _compare_to()Methode implementieren , die schlüsselbasierte Vergleiche ähnlich wie verwendet KeyedMixin, aber Ihrer Klasse ermöglicht, den effizientesten Vergleichsschlüssel basierend auf dem Typ von auszuwählen other. (Beachten Sie, dass dieses Mixin für Objekte, die auf Gleichheit, aber nicht auf Reihenfolge getestet werden können, nicht viel hilft.)

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