How to Check if a List is Empty in Python

There are several effective ways to check if a list is empty in Python. The most straightforward approach is to use the list’s boolean value in a conditional statement, which evaluates to False for empty lists and True for non-empty lists. Another common method is to explicitly compare the list’s length to zero using the len() function.

Contents

• Common Methods to Check for Empty Lists
• Detailed Comparison of Approaches
• Best Practices and Recommendations
• Common Pitfalls and Edge Cases
• Performance Considerations

Common Methods to Check for Empty Lists

Boolean Evaluation Method

The most Pythonic way to check if a list is empty is to rely on Python’s truthiness rules. Empty sequences (including lists) evaluate to False in boolean contexts.

a = []

if not a:
    print("The list is empty")

This approach is concise and readable, following the principle of “flat is better than nested” from The Zen of Python.

Length Comparison Method

You can explicitly check the length of the list using the len() function:

a = []

if len(a) == 0:
    print("The list is empty")

While functional, this method is more verbose than the boolean evaluation approach.

Direct Comparison Method

Another approach is to compare the list directly to an empty list:

a = []

if a == []:
    print("The list is empty")

This method works but is generally not recommended for readability reasons.

Detailed Comparison of Approaches

Here’s a comparison of the most common methods:

Boolean Evaluation - Recommended Approach

The boolean evaluation method is the most Pythonic and widely recommended approach:

def process_data(data):
    if not data:
        return "No data available"
    return process_non_empty_data(data)

# Examples
empty_list = []
non_empty_list = [1, 2, 3]

print(process_data(empty_list))      # Output: "No data available"
print(process_data(non_empty_list))  # Output: processed data

Length Comparison - Explicit Alternative

When you need to be more explicit about your intentions, the length comparison can be useful:

def validate_list(items):
    if len(items) == 0:
        raise ValueError("List cannot be empty")
    return items

# This approach makes your intent very clear

Best Practices and Recommendations

Use Boolean Evaluation for Most Cases

# Good - concise and Pythonic
if my_list:
    # Process non-empty list
    pass

# Good - explicit negation
if not my_list:
    # Handle empty list
    pass

Consider Readability in Context

While boolean evaluation is preferred, sometimes explicit checks can improve readability:

# More readable when context is complex
if len(user_permissions) == 0:
    deny_access()

Handle None Lists Safely

If your list might be None rather than empty, handle it explicitly:

# Safe handling for both None and empty lists
if not my_list:  # This handles None, empty list, empty dict, etc.
    # Handle case
    pass

# More specific check if you only want to check for empty lists
if my_list is not None and len(my_list) == 0:
    # Handle only empty lists, not None
    pass

Common Pitfalls and Edge Cases

None vs Empty List

Be aware of the difference between None and an empty list:

empty_list = []
none_list = None

# Both evaluate to False in boolean context
if not empty_list:  # True
if not none_list:   # True

# Differentiate if needed
if empty_list is None:   # False
if none_list is None:    # True

if len(empty_list) == 0: # True (will error on None)
if len(none_list) == 0:  # TypeError: object of type 'NoneType' has no len()

Other Falsy Types

Remember that boolean evaluation works for other falsy types too:

# All these evaluate to False
if not []:      # Empty list
if not "":      # Empty string
if not 0:       # Zero
if not None:    # None
if not False:   # False

# Use explicit checks when you need to distinguish
if isinstance(my_list, list) and not my_list:
    # This is definitely an empty list, not other falsy values
    pass

Performance Considerations

Boolean Evaluation vs Length Check

For checking emptiness, boolean evaluation is slightly faster:

import timeit

# Boolean evaluation - faster
timeit.timeit('not a', setup='a = []', number=1000000)
# Result: ~0.1 seconds for 1M iterations

# Length check - slightly slower
timeit.timeit('len(a) == 0', setup='a = []', number=1000000)
# Result: ~0.15 seconds for 1M iterations

The difference is minimal for most use cases, but the boolean approach is both faster and more readable.

Large Lists

For very large lists, the len() function is O(1) in Python (lists store their length), so performance differences are negligible. The choice should be based on readability and Pythonic style.

Conclusion

Checking if a list is empty in Python is straightforward with several valid approaches. The most Pythonic and recommended method is to use boolean evaluation (if not my_list:), which is concise, readable, and follows Python’s truthiness principles. While other methods like length comparison work well, they are generally less preferred unless explicitness is required for clarity.

Sources

1. Python Documentation - Truth Value Testing
2. PEP 8 - Style Guide for Python Code
3. The Zen of Python
4. Python Documentation - Sequence Types
5. Real Python - Python Lists