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__
?