How can I check whether a numpy array is empty or not?

I used the following code, but this fails if the array contains a zero.

```
if not self.Definition.all():
```

Is this the solution?

```
if self.Definition == array([]):
```

Skip to content
# How can I check whether a numpy array is empty or not?

# edit

Each Answer to this Q is separated by one/two green lines.

How can I check whether a numpy array is empty or not?

I used the following code, but this fails if the array contains a zero.

```
if not self.Definition.all():
```

Is this the solution?

```
if self.Definition == array([]):
```

You can always take a look at the `.size`

attribute. It is defined as an integer, and is zero (`0`

) when there are no elements in the array:

```
import numpy as np
a = np.array([])
if a.size == 0:
# Do something when `a` is empty
```

https://numpy.org/devdocs/user/quickstart.html (2020.04.08)

NumPy’s main object is the homogeneous multidimensional array. It is a table of elements (usually numbers), all of the same type, indexed by a tuple of non-negative integers. In NumPy dimensions are called axes.

(…) NumPy’s array class is called ndarray. (…) The more important attributes of an ndarray object are:

ndarray.ndim

the number of axes (dimensions) of the array.

ndarray.shape

the dimensions of the array. This is a tuple of integers indicating the size of the array in each dimension. For a matrix with n rows and m columns, shape will be (n,m). The length of the shape tuple is therefore the number of axes, ndim.

ndarray.size

the total number of elements of the array. This is equal to the product of the elements of shape.

One caveat, though.

Note that np.array(None).size returns 1!

This is because a.size is equivalent to np.prod(a.shape),

np.array(None).shape is (), and an empty product is 1.

```
>>> import numpy as np
>>> np.array(None).size
1
>>> np.array(None).shape
()
>>> np.prod(())
1.0
```

Therefore, I use the following to test if a numpy array has elements:

```
>>> def elements(array):
... return array.ndim and array.size
>>> elements(np.array(None))
0
>>> elements(np.array([]))
0
>>> elements(np.zeros((2,3,4)))
24
```

Why would we want to check if an array is `empty`

? Arrays don’t grow or shrink in the same that lists do. Starting with a ’empty’ array, and growing with `np.append`

is a frequent novice error.

Using a list in `if alist:`

hinges on its boolean value:

```
In [102]: bool([])
Out[102]: False
In [103]: bool([1])
Out[103]: True
```

But trying to do the same with an array produces (in version 1.18):

```
In [104]: bool(np.array([]))
/usr/local/bin/ipython3:1: DeprecationWarning: The truth value
of an empty array is ambiguous. Returning False, but in
future this will result in an error. Use `array.size > 0` to
check that an array is not empty.
#!/usr/bin/python3
Out[104]: False
In [105]: bool(np.array([1]))
Out[105]: True
```

and `bool(np.array([1,2])`

produces the infamous ambiguity error.

The accepted answer suggests `size`

:

```
In [11]: x = np.array([])
In [12]: x.size
Out[12]: 0
```

But I (and most others) check the `shape`

more than the `size`

:

```
In [13]: x.shape
Out[13]: (0,)
```

Another thing in its favor is that it ‘maps’ on to an `empty`

list:

```
In [14]: x.tolist()
Out[14]: []
```

But there are other other arrays with 0 `size`

, that aren’t ’empty’ in that last sense:

```
In [15]: x = np.array([[]])
In [16]: x.size
Out[16]: 0
In [17]: x.shape
Out[17]: (1, 0)
In [18]: x.tolist()
Out[18]: [[]]
In [19]: bool(x.tolist())
Out[19]: True
```

`np.array([[],[]])`

is also size 0, but shape (2,0) and `len`

2.

While the concept of an `empty`

list is well defined, an `empty array`

is not well defined. One empty list is equal to another. The same can’t be said for a `size 0`

array.

The answer really depends on

- what do you mean by ’empty’?
- what are you really test for?

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .