__cmp__ yerine __lt__

Python 2.x, karşılaştırma operatörlerini __cmp__veya "zengin karşılaştırma operatörlerini" aşırı yüklemenin iki yolu vardır __lt__. Zengin karşılaştırma aşırı yüklemelerinin tercih edildiği söyleniyor, ama bu neden böyle?

Zengin karşılaştırma operatörlerinin her birini uygulamak daha kolaydır, ancak birkaçını neredeyse aynı mantıkla uygulamalısınız. Bununla birlikte, yerleşik cmpve tuple sıralamayı kullanabilirseniz, __cmp__oldukça basitleşir ve tüm karşılaştırmaları yerine getirir:

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

Bu basitlik, ihtiyaçlarımı zengin karşılaştırmaların 6'sını (!) Aşırı yüklemekten çok daha iyi karşılıyor gibi görünüyor. (Bununla birlikte, "değiş tokuş edilen argümana" / yansıyan davranışa güvenirseniz, bunu "sadece" 4'e indirebilirsin, ancak bu mütevazi görüşüme göre net bir karmaşıklık artışı ile sonuçlanır.)

Sadece aşırı yükleme yaparsam farkına varmam gereken öngörülemeyen tuzaklar var __cmp__mı?

Anlıyorum <, <=, ==vb operatörler başka amaçlar için aşırı yüklenebilir ve benzeri herhangi bir nesneyi onlar dönebilir. Bu yaklaşımın yararlarını sormuyorum, sadece bu operatörleri karşılaştırmalar için kullanırken aynı anlamıyla sayılar için kullandıkları farklılıklar hakkında soruyorum.

Güncelleme: Christopher olarak işaret , cmp3.x yok oluyor Karşılaştırma yapmayı yukarıdakiler kadar kolaylaştıran alternatifler var __cmp__mı?

Evet, her şeyi, örneğin __lt__bir mixin sınıfı (veya bir metasınıf veya zevkiniz bu şekilde çalışıyorsa bir sınıf dekoratörü ) açısından uygulamak kolaydır .

Örneğin:

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

Artık sınıfınız, __lt__ComparableMixin'den devralmayı sadece tanımlayabilir ve çoğaltabilir (eğer varsa, diğer temellerden sonra). Bir sınıf dekoratörü, süslediği yeni sınıfın niteliklerine benzer işlevler ekleyerek oldukça benzer olacaktır (sonuç, çalışma zamanında mikroskobik olarak daha hızlı, bellek açısından eşit derecede dakika maliyetinde olabilir).

Elbette, sınıfınızın özellikle hızlı bir uygulama yolu varsa (örneğin) __eq__ve __ne__bunları doğrudan mixin sürümlerinin kullanılmaması için tanımlaması gerekir (örneğin, durum böyledir dict) - aslında __ne__kolaylaştırmak için iyi tanımlanabilir bunun gibi:

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

ancak yukarıdaki kodda sadece <;-) kullanmanın hoş simetrisini korumak istedim . Neden olarak __cmp__biz bu yana, gitmek zorunda yaptılar var __lt__ve arkadaşlar, niçin, etrafında tam olarak aynı şeyi yapmak için farklı bir yol başka tutmak? Her Python çalışma zamanında (Classic, Jython, IronPython, PyPy, ...) çok fazla ağırlık var. Bu kod kesinlikle hata olmaz yoktur koddur - Orada bir görevi gerçekleştirmek için ideal bir açık yolu olması gerektiğini Python'un ilkesi (C "Ruh C" bölümünde aynı ilke edinmiştir nereden ISO standardı, btw).

Bu bir şeyleri yasaklamak için yolumuza çıkmak anlamına gelmez (örneğin Mixins ve bazı kullanımlar için sınıf dekoratörler arasındaki yakın denklik), ama kesinlikle yok biz derleyici ve kod taşımak sevmiyorum demek oluyor / veya tamamen aynı görevi gerçekleştirmek için birden çok eşdeğer yaklaşımı desteklemek için fazladan var olan çalışma zamanları.

Daha fazla düzenleme: Aslında soruda bulunanlar da dahil olmak üzere birçok sınıf için karşılaştırma VE karma sağlamanın daha iyi bir yolu var - soruya __key__yaptığım yorumda bahsettiğim bir yöntem. PEP'i hiçbir zaman onun için yazmaya fırsat bulamadığım için, şu anda onu bir Mixin (& c) ile uygulamalısınız, eğer isterseniz:

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

Bir örneğin diğer örneklerle karşılaştırmalarının, her biri için birkaç alanı olan bir demeti karşılaştırmaya indirgenmesi çok yaygın bir durumdur - ve daha sonra, hashing tamamen aynı temelde uygulanmalıdır. __key__Doğrudan gerek özel yöntem adresleri.

Bu durumu basitleştirmek için , Alex'in önerdiği şeyi uygulamak için kullanılabilecek Python 2.7 + / 3.2 +, functools.total_ordering'de bir sınıf dekoratörü vardır . Dokümanlardan örnek:

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

Bu, PEP 207 - Zengin Karşılaştırmalar kapsamındadır

Ayrıca __cmp__python 3.0'da ortadan kalkar. ( Http://docs.python.org/3.0/reference/datamodel.html adresinde bulunmadığını, ancak http://docs.python.org/2.7/reference/datamodel.html adresinde olduğunu unutmayın )

(Yorumları dikkate almak için 17.06.2017 tarihinde düzenlendi.)

Yukarıdaki karşılaştırılabilir mixin cevabını denedim. "Yok" ile başım belaya girdi. Burada, "Yok" ile eşitlik karşılaştırmalarını ele alan değiştirilmiş bir sürüm bulunmaktadır. (Anlambilimden yoksun olarak Yok ile eşitsizlik karşılaştırmalarıyla uğraşmak için hiçbir neden görmedim):

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'nin ComparableMixinve KeyedMixinyanıtlarından esinlenerek , aşağıdaki karışımı oluşturdum. _compare_to()Benzer anahtar tabanlı karşılaştırmalar kullanan tek bir yöntem uygulamanıza KeyedMixinizin verir, ancak sınıfınızın türüne göre en verimli karşılaştırma anahtarını seçmesine olanak tanır other. (Bu karışımın, eşitlik açısından test edilebilen ancak düzen için test edilemeyen nesneler için fazla yardımcı olmadığını unutmayın).

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