Python Truth Value Testing Explained
Learn how Python decides whether an object is true or false in boolean contexts, and how to define __bool__ and __len__ to control that behavior.

When Python evaluates an object in a boolean context—inside an if, while, or with a logical operator—it does not require the object to be an actual bool. Instead, it applies a truth value test that decides whether the object is considered true or false. This behavior is central to Python's design and appears throughout the standard library and third-party code. Understanding Python's truth value testing helps you write clearer conditionals and design classes that behave predictably.
How Python Decides Truthiness
Python's rule for truth value testing is simple. If __bool__() is defined, its return value decides the object's truthiness. If __bool__ is not defined, Python falls back to __len__(): a length of 0 makes the object false, and a non-zero length makes it true. If neither method is defined, the object is considered true.
The bool() constructor applies this rule explicitly. For example:
print(bool(0)) # False
print(bool(1)) # True
print(bool([])) # False
print(bool([1])) # True
print(bool("")) # False
print(bool("a")) # TrueThese results come from the built-in implementations: numeric zero, empty sequences, and empty containers are falsy. The same logic applies when you use an object in an if statement:
def process(items):
if items:
# items is non-empty
for item in items:
...
else:
# items is empty or falsy
...The Default Truth Value of Custom Objects
For user-defined classes, Python does not assume an object is false unless you tell it otherwise. If a class defines neither __bool__ nor __len__, every instance is considered true, even if the class represents an empty collection or a zero-like value.
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
p = Point(0, 0)
print(bool(p)) # TrueThis default can surprise developers who expect an object with all-zero attributes to be false. To change that behavior, you must implement __bool__ or __len__ explicitly.
Defining bool for Custom Classes
The __bool__ method should return a boolean value that represents the logical state of the object. It is called whenever the object is used in a boolean context. A common pattern is to base the result on internal attributes or state.
class Account:
def __init__(self, balance):
self.balance = balance
def __bool__(self):
return self.balance > 0
acc = Account(100)
if acc:
print("Account has funds")
else:
print("Account is empty")Here, bool(acc) returns True only when the balance is positive. This makes the intent of the condition explicit and keeps the logic in one place. You can also use __bool__ to implement more complex rules, such as checking multiple attributes or validating invariants.
Keep __bool__ efficient and free of side effects. It may be called multiple times during a single expression, and it should not modify the object's state. If the truthiness check is expensive, consider caching the result or restructuring the design.
Using len for Truthiness
If a class defines __len__ but not __bool__, Python uses the length to determine truthiness: a length of zero makes the object false, and any non-zero length makes it true. This is convenient for container-like classes.
class Inventory:
def __init__(self, items):
self.items = items
def __len__(self):
return len(self.items)
inv = Inventory([])
if inv:
print("Inventory has items")
else:
print("Inventory is empty")When both __bool__ and __len__ are defined, __bool__ takes precedence. Python calls __bool__ first and only falls back to __len__ if __bool__ is not defined. This precedence allows you to provide a custom truthiness rule that differs from a simple length check.
Common Falsy Values in Python
Python's built-in falsy values are consistent across types. The following table lists the most common ones:
| Type | Falsy Values | Truthy Values |
|---|---|---|
| Numeric | 0, 0.0, 0j | Any non-zero number |
| Sequence | '', [], () | Any non-empty sequence |
| Mapping | {} | Any non-empty mapping |
| Set | set() | Any non-empty set |
| Boolean | False | True |
| None | None | (no truthy equivalent) |
These values are used implicitly in conditions throughout Python code. For example, checking whether a list is empty is often written as if not items: rather than if len(items) == 0:. The former relies on the truth value test and is idiomatic.
Truth Value Testing in Conditionals and Loops
The truth value test is not limited to if statements. It also applies to while loops, and, or, and not operators, and even to filter() and list comprehensions with a condition.
# While loop with a custom object
while queue:
item = queue.pop()
...
# Logical operators return the operand, not a bool
result = a or b # returns a if truthy, otherwise b
# Conditional expression
status = "active" if user.is_active else "inactive"In and and or expressions, Python evaluates the operands' truth values but returns the actual operand object, not a boolean. This behavior is useful for providing defaults, but it can be confusing when the operand is not a boolean. For example:
name = input_name or "guest"If input_name is an empty string (falsy), the expression returns "guest". If it is non-empty, it returns the original string. This pattern relies on the truth value test and is common in Python.
Performance and Maintainability Considerations
Truth value testing is a frequent operation, so the cost of __bool__ or __len__ can affect performance in hot paths. For built-in types, these methods are implemented in C and are very fast. For custom classes, the method call overhead is small but not zero. If an object is tested repeatedly in a tight loop, consider storing the result in a local variable or restructuring the code to avoid redundant checks.
Maintainability also matters. A well-designed __bool__ should clearly express the object's logical state. Avoid making truthiness depend on external side effects or mutable global state, because that makes behavior unpredictable. If the truthiness rule is complex, document it in the class docstring so other developers understand why if obj: behaves as it does.
Another consideration is compatibility with existing Python idioms. If your class represents a collection, implementing __len__ is often more natural than __bool__, because it also makes the object work with len(). If your class represents a value that can be zero or absent, __bool__ is usually the better choice.
Edge Cases and Pitfalls
One common pitfall is defining both __bool__ and __len__ with inconsistent logic. Since __bool__ takes precedence, a class that returns False from __bool__ but has a non-zero length can be surprising. Ensure the two methods agree on the object's truthiness to avoid confusion.
Another edge case is an object that defines __len__ but not __bool__ and raises an exception for certain states. For example, a class that returns a negative length from __len__ will raise a ValueError when Python calls it for truth testing. Always ensure __len__ returns a non-negative integer.
Finally, remember that truth value testing applies to all objects, including those from third-party libraries. When using a library, check its documentation to understand how its objects behave in boolean contexts. Some libraries, like NumPy, define truthiness for arrays in a way that raises an error when the array has more than one element, because the truth value is ambiguous. This is a deliberate design choice to prevent silent bugs.
Understanding how Python tests truth values lets you write code that behaves consistently and avoids subtle errors. By implementing __bool__ or __len__ deliberately, you give your classes a clear, predictable boolean semantics that other developers can rely on.
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.