Boilerplate in rich comparison methods

[Steven D'Aprano]

I'm writing a class that implements rich comparisons, and I find myself
writing a lot of very similar code. If the calculation is short and
simple, I do something like this:
class Parrot:
def __eq__(self, other):
return self.plumage() == other.plumage()
def __ne__(self, other):
return self.plumage() != other.plumage()
def __lt__(self, other):
return self.plumage() < other.plumage()
def __gt__(self, other):
return self.plumage() other.plumage()
def __le__(self, other):
return self.plumage() <= other.plumage()
def __ge__(self, other):
return self.plumage() >= other.plumage()

If the comparison requires a lot of work, I'll do something like this:

class Aardvark:
def __le__(self, other):
return lots_of_work(se lf, other)
def __gt__(self, other):
return not self <= other
# etc.

But I can't help feeling that there is a better way. What do others do?

--
Steven.

[Gabriel Genellina]

"Steven D'Aprano" <st***@REMOVE.T HIS.cybersource .com.auescribió en el
mensaje
news:pa******** *************** *****@REMOVE.TH IS.cybersource. com.au...

On Fri, 12 Jan 2007 23:28:06 -0800, Paul Rubin wrote:

>If it's that uniform I think you can just use __cmp__:

Good point -- I had somehow picked up the mistaken idea that __cmp__ was
depreciated in favour of rich comparisons.

If you inherit from a base class that implements rich comparisons, you have
to override all those methods, else your __cmp__ won't be called at all.
Sometimes it may be enough to implement __cmp__ and make all others call it.

--
Gabriel Genellina

[Antoon Pardon]

On 2007-01-13, Steven D'Aprano <st***@REMOVE.T HIS.cybersource .com.auwrote:

I'm writing a class that implements rich comparisons, and I find myself
writing a lot of very similar code. If the calculation is short and
simple, I do something like this:
class Parrot:
def __eq__(self, other):
return self.plumage() == other.plumage()
def __ne__(self, other):
return self.plumage() != other.plumage()
def __lt__(self, other):
return self.plumage() < other.plumage()
def __gt__(self, other):
return self.plumage() other.plumage()
def __le__(self, other):
return self.plumage() <= other.plumage()
def __ge__(self, other):
return self.plumage() >= other.plumage()

Well one thing you could do is write the following class:

Comparators = SomeEnumWith("e q, ne, lt, gt, ge, le, ge")

class GeneralComparat or:
def __eq__(self, other):
return Comparators.eq in self.__compare_ _(self, other)
def __ne__(self, other):
return Comparators.ne in self.__compare_ _(self, other)
def __lt__(self, other):
return Comparators.lt in self.__compare_ _(self, other)
def __le__(self, other):
return Comparators.le in self.__compare_ _(self, other)
def __gt__(self, other):
return Comparators.gt in self.__compare_ _(self, other)
def __ge__(self, other):
return Comparators.ge in self.__compare_ _(self, other)
Then write your Parrot class as follows:

class Parrot (GeneralCompara tor):
def __compare__(sel f, other):
return a set which defines which comparisons should return true.

--
Antoon Pardon