beginner

Learn What Truthy and Falsy Is in Python: Absolute Beginners Tutorial

12 min read

In Python, every single object carries a hidden boolean identity. When you place a value inside an if statement, Python does not require it to be True or False. Instead, it evaluates the object's inherent "truthiness" and decides which branch to execute. Understanding this behavior is one of the foundations of writing clean, idiomatic Python code.

If you have ever written if my_list: or if not name: and wondered how Python decides which path to take, the answer lies in truth value testing. Python defines a set of rules that determine whether any object behaves like True or False when placed inside a boolean context. This tutorial walks you through exactly how those rules work, which values are considered falsy, and how to avoid the common mistakes that trip up beginners.

What Are Truthy and Falsy Values

A truthy value is any Python object that evaluates to True when used in a boolean context. A falsy value is any object that evaluates to False. Boolean contexts include if statements, while loops, and the operands of the boolean operators and, or, and not.

Here is the simplest way to see this in action:

python 
name = "Ada"
if name:
    print("Name has a value")    # This runs because "Ada" is truthy

name = ""
if name:
    print("This will not print")  # Skipped because "" is falsy

Python does not need the variable to hold an explicit True or False. The string "Ada" is truthy because it contains characters. The empty string "" is falsy because it represents emptiness.

Note

The terms "truthy" and "falsy" are informal. The official Python documentation calls this concept truth value testing. The rules are defined in the Built-in Types section of the standard library reference.

You can use the built-in bool() function to inspect any object's truth value. It applies the same rules Python uses internally when it encounters a value in a boolean context:

python 
print(bool(42))        # True  — non-zero integer
print(bool(0))         # False — zero is falsy
print(bool([1, 2]))    # True  — list has items
print(bool([]))        # False — empty list
print(bool("hello"))   # True  — non-empty string
print(bool(""))        # False — empty string
print(bool(None))      # False — None is always falsy

The Core Rule

The Python documentation states a clear default: an object is considered true unless its class defines a __bool__() method that returns False or a __len__() method that returns zero. This means the vast majority of objects you create or encounter in Python are truthy by default. Falsy objects are the exceptions, not the rule.

code builder click a token to place it

Build the statement that checks if a list has items using truthiness:

your code will appear here...
print(items) len(items) if : == True items

The Complete List of Falsy Values

While there are many truthy objects, the list of built-in falsy values is short and specific. Knowing each one prevents unexpected behavior when your code relies on truthiness checks.

Type
NoneType
Why falsy
Represents the absence of a value. Functions that do not explicitly return something return None. It is the ultimate representation of "nothing."
Type
bool
Why falsy
The boolean constant False is the canonical falsy value. Note that bool is a subclass of int, so False equals the integer 0 in value comparisons.
Type
int, float, complex, Decimal, Fraction
Why falsy
Zero of any numeric type is falsy. This includes integer zero, floating point zero, complex zero, and the zero equivalents from the decimal and fractions modules. Any non-zero number is truthy, including negative numbers.
Type
str, list, tuple, range
Why falsy
A sequence with zero length is falsy. The moment it contains at least one element, it becomes truthy. This is why if my_list: is the idiomatic way to check for a non-empty list.
Type
dict, set, bytes, bytearray
Why falsy
Empty mappings and empty binary sequences follow the same rule as other sequences. An empty dictionary, an empty set, empty bytes, and an empty bytearray all evaluate to False. Once they contain data, they are truthy.
Pro Tip

The simplest mental model for falsy values: a value is falsy when it is "empty" or "zero." None signals the absence of a value, zero represents numeric nothingness, and empty collections have no content. Everything else is truthy.

Here is a single code block that demonstrates each category:

python 
falsy_values = [None, False, 0, 0.0, 0j, "", [], (), {}, set(), range(0), b""]

for value in falsy_values:
    print(f"{str(value):<12} -> bool = {bool(value)}")

# Output:
# None         -> bool = False
# False        -> bool = False
# 0            -> bool = False
# 0.0          -> bool = False
# 0j           -> bool = False
#              -> bool = False
# []           -> bool = False
# ()           -> bool = False
# {}           -> bool = False
# set()        -> bool = False
# range(0, 0)  -> bool = False
# b''          -> bool = False
spot the bug click the line that contains the bug

This function should return "empty" when a list has no items. But it has a truthiness bug. Click the line you think is wrong.

1 def check_list(items):
2 if items == True:
3 return "has items"
4 else:
5 return "empty"
6 check_list([1, 2, 3])
The fix: Replace if items == True with if items. Comparing a list to the boolean True with == will always return False because a list never equals the boolean constant True. The idiomatic approach is to rely on the list's inherent truthiness by writing if items: and letting Python evaluate whether the list is non-empty.

Common Truthy and Falsy Pitfalls

The truthiness system is powerful, but it creates a few traps that catch beginners regularly. The following examples cover the scenarios that cause confusion.

The String Trap

The string "0" is truthy. The string "False" is truthy. Any string that contains at least one character evaluates to True, regardless of what that character represents. Only the empty string "" is falsy.

python 
print(bool("0"))       # True — it is a one-character string
print(bool("False"))   # True — it is a five-character string
print(bool(" "))       # True — a space is still a character
print(bool(""))        # False — this is the only falsy string

The None vs. Zero vs. Empty Trap

A truthiness check with if not x: treats None, 0, "", and [] identically. This becomes a problem when 0 or "" is valid data. Consider a function that returns an age:

python 
def get_age(name):
    ages = {"Selma": 0, "Raj": 25}
    return ages.get(name)  # Returns None if name not found

age = get_age("Selma")

# Bug: treats age 0 the same as "not found"
if not age:
    print("Person not found")  # Prints — but Selma exists!

# Fix: check explicitly for None
if age is None:
    print("Person not found")
else:
    print(f"Age: {age}")       # Prints "Age: 0" — correct
Warning

Use if x is not None whenever 0, False, or an empty collection could be a legitimate value. Truthiness checks are best when you only care about whether something has content.

The Container with Falsy Items Trap

A list that contains falsy values is still truthy, because the list itself is not empty:

python 
print(bool([0]))          # True — list has one item
print(bool([None]))       # True — list has one item
print(bool([False]))      # True — list has one item
print(bool([0, 0, 0]))   # True — list has three items

The truthiness of the container depends on its own length, not on the truthiness of its contents.

Custom Objects and __bool__

When you define your own class, you can control how Python evaluates its truthiness by implementing a __bool__() method. If you do not define one, Python falls back to __len__(). If neither is defined, instances of your class are always truthy.

python 
class Wallet:
    def __init__(self, balance):
        self.balance = balance

    def __bool__(self):
        return self.balance > 0

empty_wallet = Wallet(0)
full_wallet = Wallet(50)

print(bool(empty_wallet))   # False — balance is 0
print(bool(full_wallet))    # True  — balance is positive

if full_wallet:
    print("You can buy something")
How Python resolves the truth value of an object: __bool__ first, then __len__, then default True.

How to Test Truth Values in Python

There are three practical approaches to testing truth values, each suited to a different situation. Choose the one that matches the level of precision your code needs.

  1. Pass the value to the bool() function

    Call bool() with any Python object as its argument. The function returns True if the value is truthy or False if the value is falsy. For example, bool(42) returns True and bool("") returns False. This is useful for inspection and debugging when you want to see exactly how Python treats a value.

  2. Use the value directly in an if statement

    Place the variable or expression directly in an if condition without comparing it to True or False. Python will implicitly call __bool__ or __len__ on the object to determine which branch to execute. Writing if my_list: is more Pythonic than writing if len(my_list) > 0:.

  3. Use explicit checks when falsy values are valid data

    When 0, an empty string, or False could be a legitimate value in your program, compare against None explicitly using is None or is not None instead of relying on truthiness. This prevents the bug where valid falsy data gets treated as missing.

"Any object can be tested for truth value." — Python Documentation, Built-in Types

Python Learning Summary Points

  1. Every Python object has a truth value. Values that evaluate to True are called truthy, and values that evaluate to False are called falsy. The built-in bool() function reveals any object's truth value.
  2. The falsy values in Python are a specific, short list: None, False, numeric zeros (0, 0.0, 0j), and all empty sequences and collections ("", [], (), {}, set(), range(0), b""). Everything else is truthy by default.
  3. Use if x: for simple non-emptiness checks, but switch to if x is not None: when zero or an empty string could be meaningful data. Understanding when to use each pattern prevents subtle logic bugs.
  4. Custom classes can control their truthiness by defining __bool__(). If __bool__() is absent, Python checks __len__(). If neither is defined, the object is always truthy.
  5. Strings like "0", "False", and " " are all truthy because they are non-empty. Only the completely empty string "" is falsy. Truth value testing checks the container, not its content.

Truthy and falsy values are one of the first concepts that separate a beginner from someone who writes clean, idiomatic Python. Once you internalize the rule that "empty and zero mean False, everything else means True," you will start recognizing opportunities to simplify your conditionals and catch subtle bugs before they reach production.

check your understanding question 1 of 5

Frequently Asked Questions

A truthy value is any Python object that evaluates to True when used in a boolean context, such as an if statement or while loop. By default, all objects are truthy unless they fall into one of the specific falsy categories like None, False, zero, or empty collections.

A falsy value is any Python object that evaluates to False in a boolean context. The built-in falsy values include None, the boolean False, numeric zeros like 0, 0.0, and 0j, and empty sequences and collections like empty strings, lists, tuples, dictionaries, sets, ranges, bytes, and bytearrays.

Python's built-in falsy values are: None, False, 0 (integer zero), 0.0 (float zero), 0j (complex zero), Decimal(0), Fraction(0, 1), '' (empty string), [] (empty list), () (empty tuple), {} (empty dictionary), set() (empty set), range(0) (empty range), b'' (empty bytes), and bytearray(b'') (empty bytearray). Custom objects whose __bool__() method returns False or whose __len__() method returns 0 are also falsy.

Use the built-in bool() function to check the truth value of any object. For example, bool(0) returns False because 0 is falsy, while bool(42) returns True because non-zero numbers are truthy. You can also place the value directly in an if statement to test it.

An empty list is falsy. When Python evaluates [] in a boolean context, it returns False because the list has no elements. A list that contains at least one item is truthy, even if that item itself is falsy. For example, bool([]) returns False, but bool([0]) returns True.

The string "0" is truthy. Only an empty string "" is falsy. Any string that contains at least one character is truthy, even if that character represents something that would be falsy as a different type. The strings "0", "False", and " " (a single space) are all truthy.

False is the boolean constant and is one specific falsy value. Falsy is the broader category of all values that evaluate to False in a boolean context. For example, 0 is falsy and 0 == False returns True because they share the same value, but 0 is False returns False because they are different objects. The keyword False is a bool, while 0 is an int.

When Python evaluates an object in a boolean context, it first looks for a __bool__() method on the object's class. If __bool__() is defined, its return value determines the truth value. If __bool__() is not defined, Python falls back to the __len__() method, and the object is falsy if __len__() returns 0. If neither method is defined, the object is always truthy.

Use "if x" when you want to check whether a value has meaningful content, such as whether a list has items or a string has text. Use "if x is not None" when 0, False, or an empty collection could be valid data that you do not want to skip. The explicit None check prevents a subtle bug where a legitimate value like 0 gets treated the same as a missing value.

None represents the absence of a value in Python. Because it signals that nothing meaningful is present, Python treats it as falsy. This makes it convenient to write guard clauses like "if not result" to handle cases where a function returns None, though you should use "if result is None" when you need to distinguish None from other falsy values like 0 or an empty string.

back to top