why defining only __lt__ makes > operation possible?

user_18078415 0
Viewed 40
class Node:
    def __init__(self,a,b):
        self._a=a
        self._b=b
    def __lt__(self,other):
        return self._a<other._a


a=Node(1,2)
b=Node(0,4)
print(a>b)

The code above shows True.

class Node:
    def __init__(self,a,b):
        self._a=a
        self._b=b
    def __lt__(self,other):
        return self._a<other._a
    def __eq__(self,other):
        return self._a==other._a

a=Node(1,2)
b=Node(0,4)
print(a>=b)

The code above shows TypeError: '<=' not supported between instances of 'Node' and 'Node.

Why defining only lt makes >(which is gt) operation possible? why defining both lt and eq makes <= impossible?

gt operator-keyword class python
2 Answers

The Python docs dictates:

There are no swapped-argument versions of these methods (to be used when the left argument does not support the operation but the right argument does); rather, __lt__() and __gt__() are each other’s reflection, __le__() and __ge__() are each other’s reflection, and __eq__() and __ne__() are their own reflection.

So if the left-hand-side argument doesn't implement a comparison operator while the right-hand-side implements its reflection, that reflection is called instead. This also explains why Python doesn't combine __lt__() and __eq__() into __le__() — it simply isn't considered.

user_59584550

In the first example you are comparing with >, which uses __lt__. In the second example you are comparing with >=, which is a different comparison, and it uses __ge__.

Have a look at rich comparison at the docs

These are the so-called “rich comparison” methods. The correspondence between operator symbols and method names is as follows: x<y calls x.__lt__(y), x<=y calls x.__le__(y), x==y calls x.__eq__(y), x!=y calls x.__ne__(y), x>y calls x.__gt__(y), and x>=y calls x.__ge__(y).

user_51680110
Related