Python internally calls x.__lt__(y) to obtain a return value when comparing two objects using x < y.
The return value can be any data type because any value can automatically converted to a Boolean by using the bool() built-in function.
If the __lt__() method is not defined, Python will raise a TypeError.
Syntax
__lt__(self, other)
To use the less than operator on custom objects, define the __lt__() “dunder” magic method that takes two arguments: self and other. You can then use attributes of the custom objects to determine if one is less than the other.
The method should return a Boolean True or False — however, this is not required because every object can be automatically converted to a Boolean value using the built-in bool() function.
Let’s have a look at an example next.
Example
In the following code, you compare two persons with each other by using the ageattribute as a decision criterion:
class Person: def __init__(self, age): self.age = age def __lt__(self, other): return self.age < other.age alice = Person(18)
bob = Person(17)
carl = Person(18) print(alice < bob)
# False print(alice < carl)
# False print(bob < alice)
# True
For example, because Alice’s age is 18 years and Bob’s 17 years, the expression alice < bob evaluates to True.
Background Video
Default Implementation of __lt__
The __lt__() dunder method doesn’t have a default implementation. If you try to compare objects using the less than operator <, Python will simply raise a TypeError.
class Person: def __init__(self, age): self.age = age alice = Person(18)
bob = Person(17)
carl = Person(18) print(alice < bob)
Traceback (most recent call last): File "C:\Users\...\code.py", line 10, in <module> print(alice < bob)
TypeError: '<' not supported between instances of 'Person' and 'Person'
TypeError: ‘<‘ not supported between instances of ‘…’ and ‘…’
If you get the TypeError: '<' not supported between instances of '...' and '...', you try to compare two objects using the less than operator x < y for which the __lt__() magic method is not defined.
class Finxter: pass x = Finxter()
y = Finxter() x < y # Python will raise an error!
Output:
Traceback (most recent call last): File "C:\Users\...\code.py", line 8, in <module> x < y # Python will raise an error!
TypeError: '<' not supported between instances of 'Finxter' and 'Finxter'
To fix the error, simply define the __lt__(self, other) method in your class definition and return any object that will then be converted to a Boolean True or False.
class Finxter: def __lt__(self, other): return 42 x = Finxter()
y = Finxter() x < y # Now it works!
# 42
Commutativity of Less Than <
The output of x < y and y < x may be different because the former calls x.__lt__(y) and the latter calls y.__lt__(x). If x and y have different definitions of the dunder method __lt__(), the operation becomes non-commutative.
You can see this in the following example:
class Person: def __lt__(self, other): return False class Human: def __lt__(self, other): return True alice = Person()
bob = Human() print(alice < bob)
# False print(bob < alice)
# True
![[-]](https://www.sickgaming.net/images/revolution/collapse.png "[-]")
