Python 2.x heeft twee manieren om vergelijkingsoperatoren te overbelasten, __cmp__ of de "rijke vergelijkingsoperatoren" zoals __lt__. Er wordt gezegd dat de uitgebreide vergelijkings-overloads de voorkeur hebben, maar waarom is dit zo?
Rich-vergelijkingsoperatoren zijn elk eenvoudiger te implementeren, maar u moet er meerdere implementeren met bijna identieke logica . Als u echter de ingebouwde cmp en tuple-volgorde kunt gebruiken, wordt __cmp__ vrij eenvoudig en voldoet aan alle vergelijkingen:
klasse 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) # aanname hiervoor voorbeeld return cmp((self.name, self.age, self.other), (other.name, other.age, other.other)) Deze eenvoud lijkt aan mijn behoeften te voldoen veel beter dan alle 6 (!) van de rijke vergelijkingen te overbelasten. (U kunt het echter terugbrengen tot "slechts" 4 als u vertrouwt op het "verwisselde argument"/gereflecteerd gedrag, maar dat leidt naar mijn bescheiden mening tot een netto toename van complicaties.)
< strong>Zijn er onvoorziene valkuilen waar ik op moet letten als ik __cmp__ alleen maar overbelast?
Ik begrijp de < , <=, ==, enz. operators kunnen voor andere doeleinden worden overbelast en kunnen elk gewenst object retourneren. Ik vraag niet naar de voordelen van die aanpak, maar alleen naar verschillen bij het gebruik van deze operatoren voor vergelijkingen in dezelfde zin als voor getallen.
Update: As Christopher gewezen, cmp verdwijnt bij 3.x. Zijn er alternatieven die het implementeren van vergelijkingen net zo eenvoudig maken als de bovenstaande __cmp__?