__lt__ invece di __cmp__

Python 2.x ha due modi per sovraccaricare gli operatori di confronto, __cmp__o gli "operatori di confronto avanzati" come __lt__. Si dice che i ricchi sovraccarichi di confronto siano preferiti, ma perché è così?

Gli operatori di confronto avanzato sono più semplici da implementare ciascuno, ma è necessario implementarne diversi con una logica quasi identica. Tuttavia, se puoi usare l' cmpordinamento integrato e delle tuple, __cmp__diventa abbastanza semplice e soddisfa tutti i confronti:

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

Questa semplicità sembra soddisfare le mie esigenze molto meglio che sovraccaricare tutti e 6 (!) I ricchi confronti. (Tuttavia, puoi ridurlo a "solo" 4 se ti affidi all '"argomento scambiato" / comportamento riflesso, ma a mio modesto parere ciò si traduce in un netto aumento della complicazione.)

Ci sono insidie ​​impreviste di cui devo essere consapevole se solo sovraccarico __cmp__?

Capisco il <, <=, ==, ecc operatori possono essere sovraccaricati per altri scopi, e può restituire qualsiasi oggetto a loro piace. Non sto chiedendo i meriti di tale approccio, ma solo le differenze quando si usano questi operatori per i confronti nello stesso senso in cui intendono per i numeri.

Aggiornamento: come ha sottolineato Christopher , cmpsta scomparendo in 3.x. Esistono alternative che rendono l'implementazione dei confronti facile come sopra __cmp__?

Sì, è facile implementare tutto in termini di, ad esempio, __lt__con una classe mixin (o una metaclasse o un decoratore di classi se i tuoi gusti vanno in questo modo).

Per esempio:

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

Ora la tua classe può definire solo __lt__e moltiplicare ereditare da ComparableMixin (dopo qualsiasi altra base di cui ha bisogno, se ce ne sono). Un decoratore di classi sarebbe abbastanza simile, inserendo semplicemente funzioni simili come attributi della nuova classe che sta decorando (il risultato potrebbe essere microscopicamente più veloce in fase di esecuzione, a un costo altrettanto minuto in termini di memoria).

Ovviamente, se la tua classe ha un modo particolarmente veloce per implementare (ad esempio) __eq__e __ne__, dovrebbe definirli direttamente in modo che le versioni del mixin non siano usate (ad esempio, questo è il caso di dict) - in effetti __ne__potrebbe essere ben definito per facilitare che come:

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

ma nel codice sopra ho voluto mantenere la piacevole simmetria del solo utilizzo <;-). Per quanto riguarda il motivo per cui __cmp__doveva andare, dal momento che abbiamo fatto avere __lt__e amici, perché continuare a un'altra, modo diverso di fare esattamente la stessa cosa in giro? È così tanto peso morto in ogni runtime di Python (Classic, Jython, IronPython, PyPy, ...). Il codice che sicuramente non avrà bug è il codice che non c'è - da cui il principio di Python secondo cui idealmente dovrebbe esserci un modo ovvio per eseguire un'attività (C ha lo stesso principio nella sezione "Spirit of C" di lo standard ISO, btw).

Questo non significa che andiamo fuori del nostro modo di vietare le cose (per esempio, quasi equivalenza tra mixins e decoratori di classe per alcuni usi), ma sicuramente non significa che non mi piace portare in giro codice nei compilatori e / o tempi di esecuzione ridondanti solo per supportare più approcci equivalenti per eseguire esattamente la stessa attività.

Ulteriore modifica: in realtà c'è un modo ancora migliore per fornire il confronto E l'hashing per molte classi, incluso quello nella domanda: un __key__metodo, come ho menzionato nel mio commento alla domanda. Dato che non sono mai riuscito a scrivere il PEP per questo, devi attualmente implementarlo con un Mixin (& c) se ti piace:

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

È un caso molto comune che il confronto di un'istanza con altre istanze si riduca al confronto di una tupla per ciascuna con pochi campi e quindi l'hashing dovrebbe essere implementato esattamente sulla stessa base. Il __key__metodo speciale risolve direttamente la necessità.

Per semplificare questo caso c'è un decoratore di classi in Python 2.7 + / 3.2 +, functools.total_ordering , che può essere utilizzato per implementare ciò che suggerisce Alex. Esempio dai documenti:

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

Questo è coperto da PEP 207 - Rich Comparisons

Inoltre, __cmp__scompare in Python 3.0. (Notare che non è presente su http://docs.python.org/3.0/reference/datamodel.html ma È su http://docs.python.org/2.7/reference/datamodel.html )

(Modificato il 17/6/17 per tenere conto dei commenti.)

Ho provato la risposta di mixin comparabile sopra. Ho avuto problemi con "Nessuno". Ecco una versione modificata che gestisce i confronti di uguaglianza con "Nessuno". (Non ho visto alcun motivo per preoccuparmi dei confronti della disuguaglianza con Nessuno come semantica priva):

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    

Ispirato da Alex Martelli di ComparableMixin& KeyedMixinrisposte, mi si avvicinò con la seguente mixin. Ti consente di implementare un unico _compare_to()metodo, che utilizza confronti basati su chiavi simili a KeyedMixin, ma consente alla tua classe di scegliere la chiave di confronto più efficiente in base al tipo di other. (Nota che questo mixin non aiuta molto per gli oggetti che possono essere testati per l'uguaglianza ma non per l'ordine).

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