How Does Truthiness Work in Python?

Python decides truthiness with one simple rule, and all of the surprising cases come from the same place. An empty container is falsy, but a container that holds falsy things is truthy.

cases = {
    '0': 0,
    '0.0': 0.0,
    'empty string': '',
    'empty list': [],
    'empty tuple': (),
    'empty dict': {},
    'empty set': set(),
    'empty range': range(0),
    'None': None,
    'False': False,
}

for label in cases:
    value = cases[label]
    print(label, '->', bool(value))

# These are the cases that people get wrong.
print(bool('0'))        # True, it is a non-empty string
print(bool([0]))        # True, the list holds a zero
print(bool([False]))    # True
print(bool((None,)))    # True, it is a one-element tuple

The first block prints False for every entry, because each of those values is empty, or zero, or None. The second block prints True for all four, and that is the part you should explain out loud. Truthiness is about emptiness and not about the contents. A list that holds a single zero is not empty, so it is truthy.

The mechanism underneath is worth stating, because it is how you implement the rule for your own classes. bool() looks for a __bool__ method first, and it uses the return value of that method. If there is no __bool__, it looks for __len__, and it treats a length of zero as False. If the object has neither method, then the object is truthy by default. That is why a custom class with a __len__ that returns 0 is falsy inside an if statement even though it has no __bool__ at all.

The practical consequence is that if value: is a test for emptiness and not a test for presence. If a function can legitimately return an empty list, an empty string, or a zero, then you need an explicit test such as if value is not None:, otherwise those legitimate results get treated as a failure.

There are three steps, and they are applied in order. Python first looks for a __bool__ method on the object and it uses the return value of that method. If the object has no __bool__, it looks for __len__, and it treats a length of zero as false and anything else as true. If the object has neither of those methods, then the object is truthy.

For the built-in types this gives you the list you already know. None and False are falsy, zero of any numeric type is falsy, and every empty container is falsy, which covers the empty string, the empty bytes, the empty list, the empty tuple, the empty dictionary, the empty set, and an empty range. Everything else is truthy.

To test for an empty container explicitly, the usual form is if not value:, and you should use it when you genuinely mean empty or missing. If you mean empty and only empty, then use len(value) == 0, because that reads more precisely and it works for anything that supports the length protocol. Comparing with == [] does work for lists, but it is worse for two reasons. It does not generalise to other container types, and it raises an error if the value happens to be an object whose __eq__ does not expect a list.

The distinction that matters most in real work is the difference between emptiness and absence. If a function returns None to signal a failure and an empty list to signal a successful search that found nothing, then if result: collapses two different situations into one. Write if result is not None: and the two cases stay separate.

One last detail for interviews. The same rule applies in every boolean context and not just in if. It applies in while, in and and or, in a conditional expression, and in the arguments of any function that expects a boolean. Python does not turn the result into a real bool for you, and that is why functions such as any(), all() and bool() exist.