Python <= Operator (__le__): Syntax and Custom Types
Understand Python's <= operator, its __le__ implementation, chaining behavior, and custom class and sorting use.

The <= operator in Python compares two values and returns True when the left operand is less than or equal to the right operand. This operator is implemented by the __le__ method on the left operand, or by the reflected __ge__ method on the right operand when needed. Understanding how <= behaves across built-in types and how to implement __le__ for custom classes is essential for writing correct and maintainable comparisons.
Basic Usage with Numbers and Strings
For numeric types, <= performs the expected arithmetic comparison. For strings, it compares lexicographically using Unicode code points. Both behaviors are built into the language and require no extra code.
print(3 <= 5) # True
print(5 <= 5) # True
print('apple' <= 'banana') # True
print('apple' <= 'apple') # TrueThe result is a bool for these built-in types. When the operands are of incompatible types, such as an int and a str, Python raises a TypeError because the comparison is not defined for those types.
Chaining Comparisons
Python supports chaining comparison operators. The expression a <= b <= c is evaluated as a <= b and b <= c, but b is evaluated only once. This is useful for range checks.
x = 5
if 0 <= x <= 10:
print('x is between 0 and 10')Chaining works with any comparison operator, and the short-circuit behavior applies: if the first comparison fails, the second is not evaluated.
How <= Works for Custom Classes
When you define a class, you can control how <= behaves by implementing the __le__ method. The method takes self and other and normally returns a bool, or NotImplemented to signal that the comparison is not supported for the given operand type.
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __le__(self, other):
if isinstance(other, Point):
return (self.x, self.y) <= (other.x, other.y)
return NotImplemented
p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1 <= p2) # TrueReturning NotImplemented tells Python to try the reflected comparison on the other operand. If both sides return NotImplemented, Python raises TypeError.
Sorting Custom Classes
list.sort() and sorted() use the < operator (__lt__) to compare items, so a __le__ implementation alone is not enough for sorting. For lists of numbers or strings, the default behavior works. For custom objects, implement the comparison methods. Instead of writing all six comparison dunders, you can use functools.total_ordering to fill in the rest from __le__ and __eq__.
from functools import total_ordering
@total_ordering
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __le__(self, other):
if isinstance(other, Person):
return self.age <= other.age
return NotImplemented
def __eq__(self, other):
if isinstance(other, Person):
return self.age == other.age
return NotImplemented
people = [Person('Alice', 30), Person('Bob', 25)]
people.sort()
print([p.name for p in people]) # ['Bob', 'Alice']In this example, total_ordering derives the missing comparison methods, including __lt__, from __le__ and __eq__.
Common Mistakes and Edge Cases
A frequent mistake is assuming <= performs a deep comparison on lists or dictionaries. For lists, <= compares element-wise and returns True if the left list is a prefix of the right list or if the first differing element is smaller. This is not the same as subset or containment.
print([1, 2] <= [1, 2, 3]) # True
print([1, 3] <= [1, 2]) # FalseAnother edge case is comparing None with numbers. None <= 5 raises TypeError because the types are incompatible. Also, floating-point comparisons can behave unexpectedly due to precision, but that is inherent to IEEE 754.
Performance and Implementation Notes
The <= operator is a fast built-in operation for primitive types. For custom classes, the method call overhead is minimal but can matter in tight loops. For sorting large collections of custom objects, implementing __lt__ directly is often better than relying on total_ordering, because list.sort() uses < and avoids the extra method calls generated by the decorator.
The operator module exposes the same comparison as a function: operator.le(a, b) is equivalent to a <= b.
import operator
print(operator.le(3, 5)) # TrueFor built-in types this returns a bool, so it is not a comparator for the removed cmp argument in Python 3. If you are adapting a comparator-based function, use functools.cmp_to_key with a function that returns -1, 0, or 1.
When to Implement __le__ vs Other Comparison Methods
The decision to implement __le__ depends on the ordering semantics you need. If your class represents a total order, implement all six methods or use total_ordering. If only a partial order is needed, implement only the methods that make sense. For example, a set-like class might implement <= to mean subset, which is not a total order.
class CustomSet:
def __init__(self, items):
self.items = set(items)
def __le__(self, other):
if isinstance(other, CustomSet):
return self.items.issubset(other.items)
return NotImplementedThis gives <= a different meaning than the default, and it is important to document that behavior for other developers.
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.