Check If a List is Empty in Python

As a developer, while working on a large data-cleaning project in Python, I had to make sure my code handled empty lists properly. The issue was simple: I needed to check whether a list was empty before performing any operations on it.

If you’ve been coding in Python for a while, you know how often lists show up in real-world projects. From analyzing sales data to managing user inputs in web applications, lists are everywhere. However, one common mistake I see developers make is not checking if a list is empty before using it. This can easily lead to runtime errors or unexpected results.

In this tutorial, I’ll share four simple and Pythonic ways to check if a list is empty. These are methods I personally use in my projects, and I’ll walk you through each one step-by-step.

Table of Contents

Method 1 – Use the not Operator in Python

The not operator is one of the most Pythonic ways to check if a list is empty. It’s clean, readable, and fast. When you use not on a list, Python automatically checks its truth value. An empty list evaluates to False, while a non-empty list evaluates to True.

Here’s how it works:

# Let's say we have a list of sales transactions
sales_data = []

# Check if the list is empty
if not sales_data:
    print("The sales_data list is empty.")
else:
    print("The sales_data list has records.")

In this example, since sales_data is empty, the output will be:

The sales_data list is empty.

You can refer to the screenshot below to see the output.

This method is my go-to approach because it’s concise and follows Python’s philosophy of simplicity. If you’re checking lists frequently in your code, using not keeps your code clean and readable.

Method 2 – Use Python’s len() Function

Another common way to check if a list is empty in Python is by using the len() function.

The len() function returns the number of elements in a list. So, if the length is 0, that means the list is empty.

Here’s an example:

# List of registered users in a system
registered_users = []

if len(registered_users) == 0:
    print("No users are currently registered.")
else:
    print("There are registered users in the system.")

You can refer to the screenshot below to see the output.

In this code, len(registered_users) returns 0, so the condition is True, and the message confirms the list is empty.

While this method works perfectly fine, it’s slightly more verbose than using not. Still, it’s great for beginners who want an explicit check.

Method 3 – Use Python’s bool() Function

Python’s bool() function converts a value into a Boolean (True or False). When you pass a list to bool(), it returns False if the list is empty and True otherwise.

Here’s an example:

# List of temperature readings
temperature_readings = [72, 75, 78]

# Convert list to boolean
if bool(temperature_readings):
    print("Temperature readings are available.")
else:
    print("No temperature readings found.")

You can refer to the screenshot below to see the output.

In this scenario, since the list contains values, bool(temperature_readings) returns True. This method is useful when you want to make your condition more explicit, especially in complex logic where readability matters.

Method 4 – Use Comparison with an Empty List

Another simple and clear approach is to compare your list directly with an empty list []. This method is advantageous for beginners to understand.

Here’s how you can do it:

# List of pending orders
pending_orders = []

if pending_orders == []:
    print("There are no pending orders.")
else:
    print("Some orders are still pending.")

You can refer to the screenshot below to see the output.

This method explicitly checks if the list is equal to []. While it’s perfectly valid, it’s not as efficient as using not it because it involves creating a new empty list for comparison. Still, it’s a good method for clarity in simple scripts.

Bonus Tip – Check for Empty Lists in Functions

In real-world Python applications, you often need to check for empty lists inside functions.

Here’s how you can safely handle that scenario:

def calculate_average(scores):
    if not scores:
        print("No scores available to calculate the average.")
        return None
    return sum(scores) / len(scores)

# Example usage
student_scores = []
average = calculate_average(student_scores)

In this example, the function checks if the list of scores is empty before performing any calculations. This prevents a ZeroDivisionError and makes your code more robust.

This approach is especially useful in data analysis or API-based applications where lists might sometimes be empty.

Performance Comparison Between Methods

You might wonder which of these methods is the fastest.

In most practical cases, the performance difference is negligible. However, if you’re working with very large lists or performance-critical code, it’s good to know that the not operator is slightly faster.

Here’s a quick benchmark:

import timeit

# Test list
test_list = []

# Measure time for each method
print("Using 'not':", timeit.timeit("not test_list", globals=globals(), number=1000000))
print("Using len():", timeit.timeit("len(test_list) == 0", globals=globals(), number=1000000))
print("Using bool():", timeit.timeit("bool(test_list)", globals=globals(), number=1000000))
print("Using comparison:", timeit.timeit("test_list == []", globals=globals(), number=1000000))

From my tests, the not operator consistently performs the fastest, followed closely by bool(). So, if performance is a concern, go with the not operator; it’s both efficient and Pythonic.

Common Mistakes to Avoid

While checking if a list is empty seems simple, here are a few mistakes I’ve seen developers make:

Using if list == None:
This checks if the list object is None, not if it’s empty. A list can exist but still be empty.
Using if len(list):
This works, but it’s less readable than if not list.
Forgetting to handle empty lists in loops:
Always check before iterating. Otherwise, your loop might run zero times without you realizing it.

By avoiding these mistakes, you’ll write cleaner, more reliable Python code.

Real-World Example – Check Empty Lists in Data Processing

Let’s look at a practical example where checking for empty lists is essential.

Suppose you’re developing a Python program to process daily sales data from multiple stores in the USA. Each store’s data is stored as a list of transactions.

Here’s how you might handle empty lists safely:

stores_data = {
    "New York": [1200, 1500, 1300],
    "California": [],
    "Texas": [900, 1100]
}

for store, data in stores_data.items():
    if not data:
        print(f"No sales data available for {store}.")
    else:
        avg_sales = sum(data) / len(data)
        print(f"Average sales for {store}: ${avg_sales:.2f}")

This script checks if each store’s list is empty before calculating the average sales. It’s a simple example, but it reflects how important it is to handle empty lists correctly in real-world Python applications.

While there are several ways to check if a list is empty in Python, my personal favorite is using the not operator. It’s clean, fast, and perfectly aligns with Python’s readability philosophy. That said, the len() and bool() methods are also great options when you want to make your code more explicit.

Remember, small checks like these can save you from big debugging headaches later. So, next time you’re writing Python code that deals with lists, make sure to handle empty lists gracefully.