Python lt: Implementing __lt__ for Custom Object Sorting
python **lt**: Learn how Python's `__lt__` method defines less-than behavior, enables custom sorting, and avoids common comparison pitfalls.

python lt requires a clear understanding of the core syntax, runtime behavior, and practical implementation patterns demonstrated in the examples below.
When you write a < b in Python, the interpreter looks for a method named __lt__ on the left operand. For built-in types like integers and strings, that method is implemented in C. For your own classes, Python provides a default fallback, but it almost never does what you want. Understanding python lt—the less-than comparison and its underlying dunder method—is essential for building objects that sort, compare, and order correctly.
What __lt__ Does and When Python Calls It
The __lt__ method is the Python protocol for the less-than operator. It should accept one argument (the right operand) and return a boolean indicating whether self is less than that operand. Python invokes it in several contexts:
- The explicit expression
x < y - Sorting via
sorted()orlist.sort() - Functions like
min()andmax() - Bisect module operations that rely on ordering
If __lt__ is not defined, Python falls back to a default implementation that compares objects by their memory address. This is rarely meaningful for domain objects. For example, two Person instances with the same age and name would not compare as equal, and sorting them would produce an arbitrary order.
Implementing __lt__ for a Custom Class
Consider a simple Person class that should sort by age. The implementation is straightforward:
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __lt__(self, other):
if not isinstance(other, Person):
return NotImplemented
return self.age < other.ageReturning NotImplemented when other is not a Person tells Python to try the reflected operation on the right operand. This avoids raising an unhelpful AttributeError and allows mixed-type comparisons to fail gracefully. The method returns a plain boolean, which is what Python expects.
How __lt__ Affects Sorting and sorted()
When you call sorted(people), Python repeatedly invokes __lt__ to determine the relative order of elements. The sort algorithm (Timsort) performs many comparisons, so the efficiency and correctness of __lt__ directly influence both performance and the final order.
Here is how it works in practice:
people = [
Person("Alice", 30),
Person("Bob", 25),
Person("Charlie", 35),
]
sorted_people = sorted(people)
for p in sorted_people:
print(p.name, p.age)This prints Bob, Alice, Charlie because __lt__ compares ages. If you later change the attribute used in the comparison, the sort order changes accordingly. The key point is that __lt__ defines the natural ordering of your class, and any operation that relies on ordering uses it.
Common Mistakes and Edge Cases
Several pitfalls appear frequently when implementing __lt__.
Returning a non-boolean value. While Python accepts truthy values, it is better to return an explicit bool. Returning None or an integer can lead to subtle bugs when the result is used in boolean contexts.
Ignoring type compatibility. If other is of a different type, returning NotImplemented is safer than assuming attribute existence. For example, comparing a Person to an int should not silently compare ages; it should signal that the operation is not supported.
Inconsistent with __eq__. If you implement __lt__ but not __eq__, sorting may work, but equality checks will use the default identity comparison. This inconsistency can break algorithms that expect a < b and a == b to be mutually exclusive. Always implement __eq__ alongside __lt__ to maintain a consistent ordering contract.
Mutability during sorting. If an object's comparison attributes change after it is placed in a sorted container, the container's invariants break. This is a general problem with mutable keys, not specific to __lt__, but it is worth remembering.
Performance Considerations for Comparison-Intensive Operations
Sorting a list of N elements typically performs O(N log N) comparisons. If __lt__ is slow, sorting becomes slow. Keep the method cheap: avoid repeated attribute lookups, complex calculations, or I/O inside it.
For example, if you compare by a computed property that is expensive to derive, precompute it once and store it as an attribute. Alternatively, use a key function in sorted() to avoid calling __lt__ repeatedly on the same object. The key function is called once per element, whereas __lt__ is called many times.
# Less efficient: __lt__ recomputes a derived value each time
class Order:
def __init__(self, items):
self.items = items
def __lt__(self, other):
return sum(self.items) < sum(other.items)
# More efficient: precompute the total and compare that
class Order:
def __init__(self, items):
self.items = items
self.total = sum(items)
def __lt__(self, other):
return self.total < other.totalIn the second version, the sum is computed once at construction, not on every comparison. This matters when sorting large collections.
Using functools.total_ordering to Reduce Boilerplate
Implementing all six comparison methods (__lt__, __le__, __gt__, __ge__, __eq__, __ne__) is tedious. The functools.total_ordering decorator lets you define only __lt__ and __eq__, and it fills in the rest based on those two.
from functools import total_ordering
@total_ordering
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __lt__(self, other):
if not isinstance(other, Person):
return NotImplemented
return self.age < other.age
def __eq__(self, other):
if not isinstance(other, Person):
return NotImplemented
return self.age == other.ageNow p1 <= p2, p1 > p2, and p1 >= p2 all work. The decorator adds a small overhead because it generates the missing methods dynamically, but it is negligible for most applications. It also enforces consistency because all methods are derived from the same pair.
When to Avoid Custom __lt__
Defining __lt__ is not always the best choice. If the ordering is only needed for one specific sort operation, a key function is simpler and more explicit:
sorted(people, key=lambda p: p.age)This avoids modifying the class and keeps the comparison logic local. Similarly, if your class is a data container, consider using a dataclass with order=True:
from dataclasses import dataclass
@dataclass(order=True)
class Person:
name: str
age: intThis generates all comparison methods automatically, comparing fields in the order they are defined. It is concise and less error-prone than hand-writing __lt__.
Custom __lt__ becomes necessary when the natural ordering is an essential property of the type—for example, a custom numeric type, a range, or a priority queue element. In those cases, implementing it directly gives you full control over the comparison logic and allows the object to be used interchangeably with built-in types in sorting and ordering contexts.
When you do implement it, keep the method small, return NotImplemented for incompatible types, and pair it with __eq__ to maintain a coherent ordering contract. These practices ensure that python lt behaves predictably across sorting, searching, and any other comparison-based algorithm.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.