The best answers to the question “How do I check if a list is empty?” in the category Dev.

__QUESTION__:

For example, if passed the following:

```
a = []
```

How do I check to see if `a`

is empty?

__ANSWER__:

The pythonic way to do it is from the PEP 8 style guide.

For sequences, (strings, lists, tuples), use the fact that empty sequences are false:

`# Correct: if not seq: if seq: # Wrong: if len(seq): if not len(seq):`

__ANSWER__:

```
if not a:
print("List is empty")
```

Using the implicit booleanness of the empty `list`

is quite pythonic.

__ANSWER__:

_{This is the first google hit for “python test empty array” and similar queries, plus other people seem to be generalizing the question beyond just lists, so I thought I’d add a caveat for a different type of sequence that a lot of people might use.}

# Other methods don’t work for NumPy arrays

You need to be careful with NumPy arrays, because other methods that work fine for `list`

s or other standard containers fail for NumPy arrays. I explain why below, but in short, the preferred method is to use `size`

.

### The “pythonic” way doesn’t work: Part 1

The “pythonic” way fails with NumPy arrays because NumPy tries to cast the array to an array of `bool`

s, and `if x`

tries to evaluate all of those `bool`

s at once for some kind of aggregate truth value. But this doesn’t make any sense, so you get a `ValueError`

:

```
>>> x = numpy.array([0,1])
>>> if x: print("x")
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
```

### The “pythonic” way doesn’t work: Part 2

But at least the case above tells you that it failed. If you happen to have a NumPy array with exactly one element, the `if`

statement will “work”, in the sense that you don’t get an error. However, if that one element happens to be `0`

(or `0.0`

, or `False`

, …), the `if`

statement will incorrectly result in `False`

:

```
>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x
```

But clearly `x`

exists and is not empty! This result is not what you wanted.

### Using `len`

can give unexpected results

For example,

```
len( numpy.zeros((1,0)) )
```

returns 1, even though the array has zero elements.

### The numpythonic way

As explained in the SciPy FAQ, the correct method in all cases where you know you have a NumPy array is to use `if x.size`

:

```
>>> x = numpy.array([0,1])
>>> if x.size: print("x")
x
>>> x = numpy.array([0,])
>>> if x.size: print("x")
... else: print("No x")
x
>>> x = numpy.zeros((1,0))
>>> if x.size: print("x")
... else: print("No x")
No x
```

If you’re not sure whether it might be a `list`

, a NumPy array, or something else, you could combine this approach with the answer @dubiousjim gives to make sure the right test is used for each type. Not very “pythonic”, but it turns out that NumPy intentionally broke pythonicity in at least this sense.

If you need to do more than just check if the input is empty, and you’re using other NumPy features like indexing or math operations, it’s probably more efficient (and certainly more common) to force the input *to be* a NumPy array. There are a few nice functions for doing this quickly — most importantly `numpy.asarray`

. This takes your input, does nothing if it’s already an array, or wraps your input into an array if it’s a list, tuple, etc., and optionally converts it to your chosen `dtype`

. So it’s very quick whenever it can be, and it ensures that you just get to assume the input is a NumPy array. We usually even just use the same name, as the conversion to an array won’t make it back outside of the current scope:

```
x = numpy.asarray(x, dtype=numpy.double)
```

This will make the `x.size`

check work in all cases I see on this page.

__ANSWER__:

I prefer it explicitly:

```
if len(li) == 0:
print('the list is empty')
```

This way it’s 100% clear that `li`

is a sequence (list) and we want to test its size. My problem with `if not li: ...`

is that it gives the false impression that `li`

is a boolean variable.