How to Check if a List is Empty in Python: Type Flexibility and More

Written by Jeremy Grifski in Code Last Updated June 7, 2020
How to Check if a List Is Empty in Python Featured Image

Once again, welcome back to another issue of the How to Python series. Today, we’re going to learn how to check if a list is empty in Python.

In short, the best way to check if a list is empty is to take advantage of that list’s type flexibility. For example, the statement if my_list will return true if the list is not empty. Of course, there are other ways to check if a list is empty like verifying its length and comparing it directly to another empty list.

If that’s all you needed, help grow the site by visiting my list of ways to support The Renegade Coder. Otherwise, drop down below for more details which include a video summary, several solutions with details, performance metrics, and even a social media challenge (see #RenegadePythonOpens in a new tab. on Twitter).

Table of Contents

1 Video Summary
2 Problem Introduction
3 Solutions
3.1 Check if a List is Empty by its Length
3.2 Check if a List is Empty by Direct Comparison
3.3 Check if a List is Empty by its Type Flexibility
4 Performance
5 Challenge
6 A Little Recap

Video Summary

https://youtu.be/k1lE5QxNAM4

If reading isn’t your thing, you can check out this YouTube video which covers mostly the same content. Honestly, you can probably read this article faster, but I appreciate the views!

If you decide to check out the video, I recommend hopping over to YouTubeOpens in a new tab. where you can access the timestamps for each solution. While you’re there, why not toss the video a like?

Problem Introduction

So far, we’ve played a lot with data structures like lists and dictionaries. In terms of lists, we’ve learned how to sum elements of two lists, and we’ve even learned how to convert two lists into a dictionary. However, in all this list manipulation, we’ve never actually discussed how to check if a list is empty.

Before we talk about that, I want to preface with a quick warning. In this article, we’re talking about native Python lists—not numpy lists (as the following commenter learned the hard way).

At any rate, detecting an empty list is an important skill to learn as a Python developer. It allows us to handle errors that can occur when attempting to manipulate an empty list. For example, we all know what happens when we try to index an empty list:

Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 17:26:49) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> my_list = list()
>>> my_list[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

If we happen to have a function that does some indexing, maybe it’s a good idea to add a protective check for an empty list. After all, handling edge cases is an important skill to learn for any coder.

Solutions

When it comes to checking if a list is empty in Python, there are a handful of solutions such as:

  • Verifying the list’s length is zero
  • Comparing the list directly to another empty list
  • Checking that the list is empty by its type flexibility (preferred method)

Be sure to weigh the pros and cons of each solution before making your decision.

Check if a List is Empty by its Length

Alright, so the first method for checking if a list is empty is to verify that the length of the list is zero. As someone who learned Java first, I find this solution very intuitive. Take a look:

my_list = list()
if len(my_list) == 0:
    pass  # the list is empty

In this example, we create a list called my_list which is empty. Then, we run the len() method on it which should return zero. If all goes well, we’ll compare zero with zero to prove that the list empty.

If we were to run this solution on a few cases, we’d find that it actually works great:

>>> my_list = list()
>>> if len(my_list) == 0:
        print("The list is empty")
    else:
        print("The list is not empty")

"The list is empty"

>>> my_list = ["red", "yellow", "green"]
>>> if len(my_list) == 0:
        print("The list is empty")
    else:
        print("The list is not empty")

"The list is not empty"

>>> my_list = ()
>>> if len(my_list) == 0:
        print("The list is empty")
    else:
        print("The list is not empty")

"The list is empty"

Unfortunately, the drawback of this method is that it isn’t very pythonic. After all, the Python community is very strict about its idioms, so it’s probably a good idea to avoid this method if possible.

Check if a List is Empty by Direct Comparison

Another solution, as mentioned by vorsprung on dev.to, is to compare a list directly to an empty list:

my_list = list()
if my_list == []:
    pass  # the list is empty

Once again, we create an empty list. Then, we compare that list directly to an empty list using the == operator. If all goes well, we’ll be able to prove that my_list is empty.

If we were to try this solution with a few inputs, we’d find that it works great for some inputs but not others:

>>> my_list = list()
>>> if my_list == []:
        print("The list is empty")
    else:
        print("The list is not empty")
	
"The list is empty"

>>> my_list = [1, 2, 3]
>>> if my_list == []:
        print("The list is empty")
    else:
        print("The list is not empty")
	
"The list is not empty"

>>> my_list = ()
>>> if my_list == []:
        print("The list is empty")
    else:
        print("The list is not empty")
	
"The list is not empty"  # Uh oh!

Clearly, this solution works alright, but it’s not considered pythonic. After all, Python has two different types of list-like collections: tuples and lists. Tuples are immutable lists, and comparing an empty tuple to an empty list, () == [], would return false.

In other words, if you don’t know what type of collection you’re dealing with, this is not a good solution. Instead, you should leverage the following type flexibility solution.

Check if a List is Empty by its Type Flexibility

Dynamic typing is a fun feature of Python because it allows a variable to assume many forms. While someone with a static typing background might find this frustrating, others will find that dynamic typing in Python has its perks. Among those perks is the fact that empty sequences evaluate to falseOpens in a new tab. according to the PEP 8 standard.

So, what does that mean in terms of code? Well, it means we can treat a list like a boolean. For example:

my_list = list()
if not my_list:
    pass  # the list is empty

In this example, we create an empty list. Then, we check if the list is empty by checking if it’s not a populated sequence. As a result, we can pass any sequence here—not just lists—and get the result we expect.

Now, this may not seem very intuitive, but it is a part of the accepted PEP 8 standard. In other words, this is the method we should use in production code. Always check if a list is empty by its type flexibility.

Performance

In terms of performance, there is a clear winner. That said, to prove that, we’ll need to setup a few strings for testing:

setup = "my_list = list()"

length = """
if len(my_list) == 0:
    pass
"""

direct = """
if my_list == []:
    pass
"""

flex = """
if not my_list:
    pass
"""

With these strings, we’re able to leverage the timeit library as follows:

>>> import timeit
>>> min(timeit.repeat(stmt=length, setup=setup, repeat=10))
0.06464349999998831
>>> min(timeit.repeat(stmt=direct, setup=setup, repeat=10))
0.03562890000000607
>>> min(timeit.repeat(stmt=flex, setup=setup, repeat=10))
0.016961899999955676

Here, we’ve used the repeat() function to run the test 10 times before pulling out a lower bound run time. In this case, the direct comparison method is about twice as fast as checking the length. That said, the type flexibility method is even faster still.

For the sake of completeness, we’ll need to run these tests on a list that isn’t empty. As a result, we’ll have to update the setup variable to something like the following:

setup = "my_list = [1, 5, 6, -4, 12, 3, 1, 1, 0]"

Then, if we rerun our tests, we can observe any changes in execution time:

>>> min(timeit.repeat(stmt=length, setup=setup, repeat=10))
0.06420660000003409
>>> min(timeit.repeat(stmt=direct, setup=setup, repeat=10))
0.03376020000007429
>>> min(timeit.repeat(stmt=flex, setup=setup, repeat=10))
0.012936999999965337

As it turns out, run times are about the same. In other words, the recommended type flexibility idiom performs the best in both cases. For reference, these tests were performed using Windows 10 and Python 3.7.3. If you want to learn more about performance testing in Python, check out my article titled How to Performance Test Python Code.

Challenge

Like most of the articles in this series, I thought it would be fun to take what we learned a step further. In other words, now that we know how to check if a list is empty, let’s try to stretch our knowledge a bit.

Our challenge today takes this idea of “emptiness” a bit further. In particular, let’s try applying it to a different data structure: the dictionary. How can we write a program which detects if a dictionary is empty?

Try writing a bit of code that behaves something like the following pseudocode:

emptiness_detection(my_dict)  # true iff empty

As always, if you come up with a solution, feel free to share it on Twitter using the hashtag #RenegadePython. If I see it, I’ll give it a share!

In the meantime, here’s my solution:

Apparently, type flexibility still works! I wonder if there are any other ways to solve this problem.

A Little Recap

Today’s topic is how to check if a list is empty in Python. As always, in this section, we do a little recap of the solutions we’ve shared above:

my_list = list()

# Check if a list is empty by its length
if len(my_list) == 0:
    pass  # the list is empty

# Check if a list is empty by direct comparison
if my_list == []:
    pass  # the list is empty

# Check if a list is empty by its type flexibility **preferred method**
if not my_list:
    pass  # the list is empty

And with that, we’re finished. Once again, thanks for stopping by. Hopefully, this was helpful! If so, you might get some value out of my list of Python Code Snippets for Everyday Problems.

Otherwise, consider subscribing to The Renegade Coder to get more content like this straight to your inbox—plus a handful of other benefits like access to the blog. If you just want the weekly newsletter, drop your email into the signup formOpens in a new tab..

In the meantime, check out some of these other awesome Python articles:

In addition, check out some of these Python books on Amazon (ad):

Thanks again for your support!

How to Python (41 Articles)—Series Navigation

The How to Python tutorial series strays from the usual in-depth coding articles by exploring byte-sized problems in Python. In this series, students will dive into unique topics such as How to Invert a Dictionary, How to Sum Elements of Two Lists, and How to Check if a File Exists.

Each problem is explored from the naive approach to the ideal solution. Occasionally, there’ll be some just-for-fun solutions too. At the end of every article, you’ll find a recap full of code snippets for your own use. Don’t be afraid to take what you need!

If you’re not sure where to start, I recommend checking out our list of Python Code Snippets for Everyday Problems. In addition, you can find some of the snippets in a Jupyter notebook format on GitHubOpens in a new tab.,

If you have a problem of your own, feel free to ask. Someone else probably has the same problem. Enjoy How to Python!

← Previous Post: [#5] [#7]: Next Post →

Jeremy Grifski

Jeremy grew up in a small town where he enjoyed playing soccer and video games, practicing taekwondo, and trading Pokémon cards. Once out of the nest, he pursued a Bachelors in Computer Engineering with a minor in Game Design. After college, he spent about two years writing software for a major engineering company. Then, he earned a master's in Computer Science and Engineering. Today, he pursues a PhD in Engineering Education in order to ultimately land a teaching gig. In his spare time, Jeremy enjoys spending time with his wife, playing Overwatch and Phantasy Star Online 2, practicing trombone, watching Penguins hockey, and traveling the world.

Recent Posts