__lt__ แทน __cmp__

Python 2.x มีสองวิธีในการโอเวอร์โหลดตัวดำเนินการเปรียบเทียบ__cmp__หรือ "ตัวดำเนินการเปรียบเทียบที่สมบูรณ์" เช่น__lt__. การเปรียบเทียบที่มากเกินไปนั้นเป็นที่ต้องการ แต่เหตุใดจึงเป็นเช่นนั้น

ตัวดำเนินการเปรียบเทียบแบบ Rich นั้นง่ายกว่าในการใช้งานแต่ละตัว แต่คุณต้องใช้ตัวดำเนินการหลายตัวด้วยตรรกะที่เหมือนกัน อย่างไรก็ตามหากคุณสามารถใช้การ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__คลาสมิกซ์อิน (หรือเมตาคลาสหรือมัณฑนากรชั้นเรียนถ้ารสนิยมของคุณเป็นแบบนั้น)

ตัวอย่างเช่น:

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__ควรกำหนดโดยตรงเพื่อไม่ให้ใช้เวอร์ชันของ mixin (เช่นในกรณีนี้dict) - ในความเป็นจริง__ne__อาจถูกกำหนดไว้เพื่ออำนวยความสะดวก นั่นคือ:

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

แต่ในโค้ดด้านบนฉันต้องการคงความสมมาตรที่น่าพอใจไว้ใช้เท่านั้น<;-) ว่าทำไม__cmp__ต้องไปเนื่องจากเราไม่ได้มี__lt__และเพื่อนทำไมให้อีกวิธีที่แตกต่างกันที่จะทำสิ่งเดียวกันรอบ? มันมีน้ำหนักมากในทุกรันไทม์ของ Python (Classic, Jython, IronPython, PyPy, ... ) รหัสที่ไม่มีจุดบกพร่องอย่างแน่นอนคือรหัสที่ไม่มีอยู่ - โดยหลักการของ Python ที่ว่าควรมีวิธีหนึ่งที่ชัดเจนในการทำงาน (C มีหลักการเดียวกันในส่วน "Spirit of C" ของ มาตรฐาน ISO, btw)

นี้ไม่ได้หมายความว่าเราออกไปจากทางของเราที่จะห้ามสิ่ง (เช่นใกล้ความเท่าเทียมระหว่าง mixins และตกแต่งชั้นสำหรับการใช้งานบางส่วน) แต่แน่นอนมันไม่ได้หมายความว่าเราไม่ชอบการดำเนินการประมาณรหัสในการคอมไพเลอร์และ / หรือรันไทม์ที่ซ้ำซ้อนเพียงเพื่อสนับสนุนวิธีการที่เทียบเท่ากันหลายวิธีในการทำงานเดียวกัน

แก้ไขเพิ่มเติม: มีวิธีที่ดีกว่าในการเปรียบเทียบและแฮชสำหรับหลายชั้นเรียนรวมถึงในคำถาม - __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ซึ่งสามารถใช้เพื่อนำสิ่งที่ Alex แนะนำไปใช้ ตัวอย่างจากเอกสาร:

@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__หายไปใน python 3.0 (โปรดทราบว่าไม่มีอยู่ในhttp://docs.python.org/3.0/reference/datamodel.htmlแต่อยู่ในhttp://docs.python.org/2.7/reference/datamodel.html )

(แก้ไขเมื่อวันที่ 17/17 เพื่อนำความคิดเห็นมาพิจารณา)

ฉันลองใช้คำตอบมิกซ์อินที่เทียบเคียงได้ด้านบน ฉันพบปัญหากับ "ไม่มี" นี่คือเวอร์ชันแก้ไขที่จัดการการเปรียบเทียบความเท่าเทียมกับ "ไม่มี" (ฉันไม่เห็นเหตุผลที่จะต้องกังวลกับการเปรียบเทียบอสมการกับไม่มีเพราะขาดความหมาย):

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คำตอบของ Alex Martelli ฉันจึงได้มิกซ์อินดังต่อไปนี้ จะช่วยให้คุณใช้เพียงครั้งเดียว_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