## 问题：如何检查列表是否为空？

``a = []``

For example, if passed the following:

``````a = []
``````

How do I check to see if `a` is empty?

## 回答 0

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

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

Using the implicit booleanness of the empty `list` is quite pythonic.

## 回答 1

``````Yes: if not seq:
if seq:

No:  if len(seq):
if not len(seq):``````

The pythonic way to do it is from the PEP 8 style guide (where Yes means “recommended” and No means “not recommended”):

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

``````Yes: if not seq:
if seq:

No:  if len(seq):
if not len(seq):
``````

## 回答 2

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

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.

# 其他方法不适用于NumPy数组

### “ pythonic”方式无效：第1部分

NumPy数组的“ pythonic”方法失败，因为NumPy尝试将数组转换为`bool`s 的数组，并`if x`尝试`bool`一次对所有这些s 求值，以获得某种合计的真值。但这没有任何意义，因此您得到了`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()``````

### “ pythonic”方式无效：第2部分

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

### 使用`len`会产生意想不到的结果

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

### numpythonic方式

SciPy常见问题解答中所述，在您知道拥有NumPy数组的所有情况下，正确的方法是使用`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``````

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

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 . 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.

## 检查列表是否为空的最佳方法

``a = []``

## 简短答案：

``````if not a:                           # do this!
print('a is an empty list')``````

## 人教版8

PEP 8是Python标准库中Python代码的官方Python样式指南，它断言：

``````Yes: if not seq:
if seq:

No: if len(seq):
if not len(seq):``````

## 说明

``````if len(a) == 0:                     # Don't do this!
print('a is an empty list')``````

``````if a == []:                         # Don't do this!
print('a is an empty list')``````

• 定义为false的常量：`None``False`
• 任何数值类型的零：`0``0.0``0j``Decimal(0)``Fraction(0, 1)`
• 空序列和集合：`''``()``[]``{}``set()``range(0)`

`object.__bool__(self)`

`object.__len__(self)`

``````if len(a) == 0:                     # Don't do this!
print('a is an empty list')``````

``````if a == []:                     # Don't do this!
print('a is an empty list')``````

``````if not a:
print('a is an empty list')``````

## 做Pythonic通常可以提高性能：

``````>>> import timeit
>>> min(timeit.repeat(lambda: len([]) == 0, repeat=100))
0.13775854044661884
>>> min(timeit.repeat(lambda: [] == [], repeat=100))
0.0984637276455409
>>> min(timeit.repeat(lambda: not [], repeat=100))
0.07878462291455435``````

``````>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342``````

``````>>> import dis
>>> dis.dis(lambda: len([]) == 0)
2 BUILD_LIST               0
4 CALL_FUNCTION            1
8 COMPARE_OP               2 (==)
10 RETURN_VALUE``````

``````>>> dis.dis(lambda: [] == [])
1           0 BUILD_LIST               0
2 BUILD_LIST               0
4 COMPARE_OP               2 (==)
6 RETURN_VALUE``````

``````>>> dis.dis(lambda: not [])
1           0 BUILD_LIST               0
2 UNARY_NOT
4 RETURN_VALUE``````

## 来自C源代码和文档的证据

`PyVarObject`

``````typedef struct {
/* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
PyObject **ob_item;

/* ob_item contains space for 'allocated' elements.  The number
* currently in use is ob_size.
* Invariants:
*     0 <= ob_size <= allocated
*     len(list) == ob_size``````

## 对评论的回应：

IPython的魔术`%timeit`在这里并非完全没有用：

``````In [1]: l = []

In [2]: %timeit l
20 ns ± 0.155 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [3]: %timeit not l
24.4 ns ± 1.58 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [4]: %timeit not not l
30.1 ns ± 2.16 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)``````

``````In [5]: %timeit if l: pass
22.6 ns ± 0.963 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [6]: %timeit if not l: pass
24.4 ns ± 0.796 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [7]: %timeit if not not l: pass
23.4 ns ± 0.793 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)``````

``````In [8]: l = [1]

In [9]: %timeit if l: pass
23.7 ns ± 1.06 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [10]: %timeit if not l: pass
23.6 ns ± 1.64 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [11]: %timeit if not not l: pass
26.3 ns ± 1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)``````

Python是用C编写的；它在C级别使用其逻辑。您用Python编写的任何内容都会变慢。除非您直接使用Python内置的机制，否则这可能会慢几个数量级。

## Best way to check if a list is empty

For example, if passed the following:

``````a = []
``````

How do I check to see if a is empty?

Place the list in a boolean context (for example, with an `if` or `while` statement). It will test `False` if it is empty, and `True` otherwise. For example:

``````if not a:                           # do this!
print('a is an empty list')
``````

## PEP 8

PEP 8, the official Python style guide for Python code in Python’s standard library, asserts:

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

``````Yes: if not seq:
if seq:

No: if len(seq):
if not len(seq):
``````

We should expect that standard library code should be as performant and correct as possible. But why is that the case, and why do we need this guidance?

## Explanation

I frequently see code like this from experienced programmers new to Python:

``````if len(a) == 0:                     # Don't do this!
print('a is an empty list')
``````

And users of lazy languages may be tempted to do this:

``````if a == []:                         # Don't do this!
print('a is an empty list')
``````

These are correct in their respective other languages. And this is even semantically correct in Python.

But we consider it un-Pythonic because Python supports these semantics directly in the list object’s interface via boolean coercion.

From the docs (and note specifically the inclusion of the empty list, `[]`):

By default, an object is considered true unless its class defines either a `__bool__()` method that returns `False` or a `__len__()` method that returns zero, when called with the object. Here are most of the built-in objects considered false:

• constants defined to be false: `None` and `False`.
• zero of any numeric type: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)`
• empty sequences and collections: `''`, `()`, `[]`, `{}`, `set()`, `range(0)`

And the datamodel documentation:

`object.__bool__(self)`

Called to implement truth value testing and the built-in operation `bool()`; should return `False` or `True`. When this method is not defined, `__len__()` is called, if it is defined, and the object is considered true if its result is nonzero. If a class defines neither `__len__()` nor `__bool__()`, all its instances are considered true.

and

`object.__len__(self)`

Called to implement the built-in function `len()`. Should return the length of the object, an integer >= 0. Also, an object that doesn’t define a `__bool__()` method and whose `__len__()` method returns zero is considered to be false in a Boolean context.

``````if len(a) == 0:                     # Don't do this!
print('a is an empty list')
``````

or this:

``````if a == []:                     # Don't do this!
print('a is an empty list')
``````

Do this:

``````if not a:
print('a is an empty list')
``````

## Doing what’s Pythonic usually pays off in performance:

Does it pay off? (Note that less time to perform an equivalent operation is better:)

``````>>> import timeit
>>> min(timeit.repeat(lambda: len([]) == 0, repeat=100))
0.13775854044661884
>>> min(timeit.repeat(lambda: [] == [], repeat=100))
0.0984637276455409
>>> min(timeit.repeat(lambda: not [], repeat=100))
0.07878462291455435
``````

For scale, here’s the cost of calling the function and constructing and returning an empty list, which you might subtract from the costs of the emptiness checks used above:

``````>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342
``````

We see that either checking for length with the builtin function `len` compared to `0` or checking against an empty list is much less performant than using the builtin syntax of the language as documented.

Why?

For the `len(a) == 0` check:

First Python has to check the globals to see if `len` is shadowed.

Then it must call the function, load `0`, and do the equality comparison in Python (instead of with C):

``````>>> import dis
>>> dis.dis(lambda: len([]) == 0)
2 BUILD_LIST               0
4 CALL_FUNCTION            1
8 COMPARE_OP               2 (==)
10 RETURN_VALUE
``````

And for the `[] == []` it has to build an unnecessary list and then, again, do the comparison operation in Python’s virtual machine (as opposed to C)

``````>>> dis.dis(lambda: [] == [])
1           0 BUILD_LIST               0
2 BUILD_LIST               0
4 COMPARE_OP               2 (==)
6 RETURN_VALUE
``````

The “Pythonic” way is a much simpler and faster check since the length of the list is cached in the object instance header:

``````>>> dis.dis(lambda: not [])
1           0 BUILD_LIST               0
2 UNARY_NOT
4 RETURN_VALUE
``````

## Evidence from the C source and documentation

`PyVarObject`

This is an extension of `PyObject` that adds the `ob_size` field. This is only used for objects that have some notion of length. This type does not often appear in the Python/C API. It corresponds to the fields defined by the expansion of the `PyObject_VAR_HEAD` macro.

From the c source in Include/listobject.h:

``````typedef struct {
/* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
PyObject **ob_item;

/* ob_item contains space for 'allocated' elements.  The number
* currently in use is ob_size.
* Invariants:
*     0 <= ob_size <= allocated
*     len(list) == ob_size
``````

I would point out that this is also true for the non-empty case though its pretty ugly as with `l=[]` then `%timeit len(l) != 0` 90.6 ns ± 8.3 ns, `%timeit l != []` 55.6 ns ± 3.09, `%timeit not not l` 38.5 ns ± 0.372. But there is no way anyone is going to enjoy `not not l` despite triple the speed. It looks ridiculous. But the speed wins out
I suppose the problem is testing with timeit since just `if l:` is sufficient but surprisingly `%timeit bool(l)` yields 101 ns ± 2.64 ns. Interesting there is no way to coerce to bool without this penalty. `%timeit l` is useless since no conversion would occur.

IPython magic, `%timeit`, is not entirely useless here:

``````In [1]: l = []

In [2]: %timeit l
20 ns ± 0.155 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [3]: %timeit not l
24.4 ns ± 1.58 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [4]: %timeit not not l
30.1 ns ± 2.16 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
``````

We can see there’s a bit of linear cost for each additional `not` here. We want to see the costs, ceteris paribus, that is, all else equal – where all else is minimized as far as possible:

``````In [5]: %timeit if l: pass
22.6 ns ± 0.963 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [6]: %timeit if not l: pass
24.4 ns ± 0.796 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [7]: %timeit if not not l: pass
23.4 ns ± 0.793 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
``````

Now let’s look at the case for an unempty list:

``````In [8]: l = [1]

In [9]: %timeit if l: pass
23.7 ns ± 1.06 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [10]: %timeit if not l: pass
23.6 ns ± 1.64 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [11]: %timeit if not not l: pass
26.3 ns ± 1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
``````

What we can see here is that it makes little difference whether you pass in an actual `bool` to the condition check or the list itself, and if anything, giving the list, as is, is faster.

Python is written in C; it uses its logic at the C level. Anything you write in Python will be slower. And it will likely be orders of magnitude slower unless you’re using the mechanisms built into Python directly.

## 回答 5

``````a = []
if a:
print "not empty"``````

@达伦·托马斯

An empty list is itself considered false in true value testing (see python documentation):

``````a = []
if a:
print "not empty"
``````

@Daren Thomas

EDIT: Another point against testing the empty list as False: What about polymorphism? You shouldn’t depend on a list being a list. It should just quack like a duck – how are you going to get your duckCollection to quack ”False” when it has no elements?

Your duckCollection should implement `__nonzero__` or `__len__` so the if a: will work without problems.

## 回答 6

Python代码和Python社区都有非常强大的习惯用法。遵循这些惯用法可以使您的代码更容易为有Python经验的人阅读。当您违反这些习惯用法时，这是一个强烈的信号。

Patrick’s (accepted) answer is right: `if not a:` is the right way to do it. Harley Holcombe’s answer is right that this is in the PEP 8 style guide. But what none of the answers explain is why it’s a good idea to follow the idiom—even if you personally find it’s not explicit enough or confusing to Ruby users or whatever.

Python code, and the Python community, has very strong idioms. Following those idioms makes your code easier to read for anyone experienced in Python. And when you violate those idioms, that’s a strong signal.

It’s true that `if not a:` doesn’t distinguish empty lists from `None`, or numeric 0, or empty tuples, or empty user-created collection types, or empty user-created not-quite-collection types, or single-element NumPy array acting as scalars with falsey values, etc. And sometimes it’s important to be explicit about that. And in that case, you know what you want to be explicit about, so you can test for exactly that. For example, `if not a and a is not None:` means “anything falsey except None”, while `if len(a) != 0:` means “only empty sequences—and anything besides a sequence is an error here”, and so on. Besides testing for exactly what you want to test, this also signals to the reader that this test is important.

But when you don’t have anything to be explicit about, anything other than `if not a:` is misleading the reader. You’re signaling something as important when it isn’t. (You may also be making the code less flexible, or slower, or whatever, but that’s all less important.) And if you habitually mislead the reader like this, then when you do need to make a distinction, it’s going to pass unnoticed because you’ve been “crying wolf” all over your code.

# 为什么要检查？

``````a = []

for item in a:
<do something with item>

<rest of code>``````

# Why check at all?

No one seems to have addressed questioning your need to test the list in the first place. Because you provided no additional context, I can imagine that you may not need to do this check in the first place, but are unfamiliar with list processing in Python.

I would argue that the most pythonic way is to not check at all, but rather to just process the list. That way it will do the right thing whether empty or full.

``````a = []

for item in a:
<do something with item>

<rest of code>
``````

This has the benefit of handling any contents of a, while not requiring a specific check for emptiness. If a is empty, the dependent block will not execute and the interpreter will fall through to the next line.

If you do actually need to check the array for emptiness, the other answers are sufficient.

## 回答 8

`len()`用于Python列表，字符串，字典和集合的O（1）操作。Python在内部跟踪这些容器中元素的数量。

JavaScript 有一个true / falsy的类似概念

`len()` is an O(1) operation for Python lists, strings, dicts, and sets. Python internally keeps track of the number of elements in these containers.

JavaScript has a similar notion of truthy/falsy.

## 回答 9

``````if isinstance(a, (list, some, other, types, i, accept)) and not a:
do_stuff``````

``````if isinstance(a, numpy.ndarray) and not a.size:
do_stuff
elif isinstance(a, collections.Sized) and not a:
do_stuff``````

``elif isinstance(a, (list, tuple)) and not a:``

``elif isinstance(a, (list, tuple)) and not len(a):``

``````if isinstance(a, (list, some, other, types, i, accept)) and not a:
do_stuff
``````

which was voted -1. I’m not sure if that’s because readers objected to the strategy or thought the answer wasn’t helpful as presented. I’ll pretend it was the latter, since—whatever counts as “pythonic”—this is the correct strategy. Unless you’ve already ruled out, or are prepared to handle cases where `a` is, for example, `False`, you need a test more restrictive than just `if not a:`. You could use something like this:

``````if isinstance(a, numpy.ndarray) and not a.size:
do_stuff
elif isinstance(a, collections.Sized) and not a:
do_stuff
``````

the first test is in response to @Mike’s answer, above. The third line could also be replaced with:

``````elif isinstance(a, (list, tuple)) and not a:
``````

if you only want to accept instances of particular types (and their subtypes), or with:

``````elif isinstance(a, (list, tuple)) and not len(a):
``````

You can get away without the explicit type check, but only if the surrounding context already assures you that `a` is a value of the types you’re prepared to handle, or if you’re sure that types you’re not prepared to handle are going to raise errors (e.g., a `TypeError` if you call `len` on a value for which it’s undefined) that you’re prepared to handle. In general, the “pythonic” conventions seem to go this last way. Squeeze it like a duck and let it raise a DuckError if it doesn’t know how to quack. You still have to think about what type assumptions you’re making, though, and whether the cases you’re not prepared to handle properly really are going to error out in the right places. The Numpy arrays are a good example where just blindly relying on `len` or the boolean typecast may not do precisely what you’re expecting.

## 回答 10

• `None`
• `False`
• 任何数值类型的零，例如`0``0.0``0j`
• 任何空序列，例如`''``()``[]`
• 任何空映射，例如`{}`
• 用户定义的类的实例，如果该类定义了`__bool__()``__len__()`方法，则该方法返回整数0或bool value时`False`

``````if not a:
print('"a" is empty!')``````

From documentation on truth value testing:

All values other than what is listed here are considered `True`

• `None`
• `False`
• zero of any numeric type, for example, `0`, `0.0`, `0j`.
• any empty sequence, for example, `''`, `()`, `[]`.
• any empty mapping, for example, `{}`.
• instances of user-defined classes, if the class defines a `__bool__()` or `__len__()` method, when that method returns the integer zero or bool value `False`.

As can be seen, empty list `[]` is falsy, so doing what would be done to a boolean value sounds most efficient:

``````if not a:
print('"a" is empty!')
``````

## 回答 11

``a = [] #the list``

1）非常简单的pythonic方式：

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

2）一种非常明确的方法：使用`len()`来查找长度并检查其是否等于`0`

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

3）或将其与匿名空列表进行比较：

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

4）另一种愚蠢的做法是使用`exception``iter()`

``````try:
next(iter(a))
# list has elements
except StopIteration:
print("Error: a is empty")``````

Here are a few ways you can check if a list is empty:

``````a = [] #the list
``````

1) The pretty simple pythonic way:

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

In Python, empty containers such as lists,tuples,sets,dicts,variables etc are seen as `False`. One could simply treat the list as a predicate (returning a Boolean value). And a `True` value would indicate that it’s non-empty.

2) A much explicit way: using the `len()` to find the length and check if it equals to `0`:

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

3) Or comparing it to an anonymous empty list:

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

4) Another yet silly way to do is using `exception` and `iter()`:

``````try:
next(iter(a))
# list has elements
except StopIteration:
print("Error: a is empty")
``````

## 回答 12

``````if a == []:
print "The list is empty."``````

I prefer the following:

``````if a == []:
print "The list is empty."
``````

## 回答 13

``````if not a :
print ("Empty") ``````

``````if len(a) == 0 :
print( "Empty" )``````

``````if a == [] :
print ("Empty")``````

Method 1 (Preferred):

``````if not a :
print ("Empty")
``````

Method 2 :

``````if len(a) == 0 :
print( "Empty" )
``````

Method 3:

``````if a == [] :
print ("Empty")
``````

## 回答 14

``````def list_test (L):
if   L is None  : print('list is None')
elif not L      : print('list is empty')
else: print('list has %d elements' % len(L))

list_test(None)
list_test([])
list_test([1,2,3])``````

``````list is None
list is empty
list has 3 elements``````

``````def list_test2 (L):
if not L      : print('list is empty')
else: print('list has %d elements' % len(L))

list_test2(None)
list_test2([])
list_test2([1,2,3])``````

``````list is empty
list is empty
list has 3 elements``````
``````def list_test (L):
if   L is None  : print('list is None')
elif not L      : print('list is empty')
else: print('list has %d elements' % len(L))

list_test(None)
list_test([])
list_test([1,2,3])
``````

It is sometimes good to test for `None` and for emptiness separately as those are two different states. The code above produces the following output:

``````list is None
list is empty
list has 3 elements
``````

Although it’s worth nothing that `None` is falsy. So if you don’t want to separate test for `None`-ness, you don’t have to do that.

``````def list_test2 (L):
if not L      : print('list is empty')
else: print('list has %d elements' % len(L))

list_test2(None)
list_test2([])
list_test2([1,2,3])
``````

produces expected

``````list is empty
list is empty
list has 3 elements
``````

## 回答 15

``not a``

``````if isinstance(a, list) and len(a)==0:

Many answers have been given, and a lot of them are pretty good. I just wanted to add that the check

``````not a
``````

will also pass for `None` and other types of empty structures. If you truly want to check for an empty list, you can do this:

``````if isinstance(a, list) and len(a)==0:
``````

## 回答 16

``````item_list=[]
if len(item_list) == 0:
print("list is empty")
else:
print("list is not empty")``````

we could use a simple if else:

``````item_list=[]
if len(item_list) == 0:
print("list is empty")
else:
print("list is not empty")
``````

## 回答 17

``````l = []
if l:

``````l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):

``````def empty_list(lst):
if len(lst) == 0:
return False
else:
return all(bool(x) for x in l)``````

``````if empty_list(lst):

If you want to check if a list is empty:

``````l = []
if l:
``````

If you want to check whether all the values in list is empty. However it will be `True` for an empty list:

``````l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
``````

If you want to use both cases together:

``````def empty_list(lst):
if len(lst) == 0:
return False
else:
return all(bool(x) for x in l)
``````

Now you can use:

``````if empty_list(lst):
``````

## 回答 18

``````import collections
def is_empty(a):
return not a and isinstance(a, collections.Iterable)``````

``````>>> is_empty('sss')
False
>>> is_empty(555)
False
>>> is_empty(0)
False
>>> is_empty('')
True
>>> is_empty([3])
False
>>> is_empty([])
True
>>> is_empty({})
True
>>> is_empty(())
True``````

Being inspired by @dubiousjim’s solution, I propose to use an additional general check of whether is it something iterable

``````import collections
def is_empty(a):
return not a and isinstance(a, collections.Iterable)
``````

Note: a string is considered to be iterable. – add `and not isinstance(a,(str,unicode))` if you want the empty string to be excluded

Test:

``````>>> is_empty('sss')
False
>>> is_empty(555)
False
>>> is_empty(0)
False
>>> is_empty('')
True
>>> is_empty([3])
False
>>> is_empty([])
True
>>> is_empty({})
True
>>> is_empty(())
True
``````

## 回答 19

``print('not empty' if a else 'empty')``

``a.pop() if a else None``

``if a: a.pop() ``
``````print('not empty' if a else 'empty')
``````

a little more practical:

``````a.pop() if a else None
``````

and shertest version:

``````if a: a.pop()
``````

## 回答 20

``a == []``

From python3 onwards you can use

``````a == []
``````

to check if the list is empty

EDIT : This works with python2.7 too..

I am not sure why there are so many complicated answers. It’s pretty clear and straightforward

## 回答 21

``````    a = [1,2,3];
print bool(a); # it will return True
a = [];
print bool(a); # it will return False``````

You can even try using bool() like this

``````    a = [1,2,3];
print bool(a); # it will return True
a = [];
print bool(a); # it will return False
``````

I love this way for checking list is empty or not.

Very handy and useful.

## 回答 22

``````def is_empty(any_structure):
if any_structure:
print('Structure is not empty.')
return True
else:
print('Structure is empty.')
return False  ``````

Simply use is_empty() or make function like:-

``````def is_empty(any_structure):
if any_structure:
print('Structure is not empty.')
return True
else:
print('Structure is empty.')
return False
``````

It can be used for any data_structure like a list,tuples, dictionary and many more. By these, you can call it many times using just `is_empty(any_structure)`.

## 回答 23

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

Simple way is checking the length is equal zero.

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

## 回答 24

The truth value of an empty list is `False` whereas for a non-empty list it is `True`.

## 回答 25

``foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))``

``foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))``

What brought me here is a special use-case: I actually wanted a function to tell me if a list is empty or not. I wanted to avoid writing my own function or using a lambda-expression here (because it seemed like it should be simple enough):

``````foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))
``````

And, of course, there is a very natural way to do it:

``````foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))
``````

Of course, do not use `bool` in `if` (i.e., `if bool(L):`) because it’s implied. But, for the cases when “is not empty” is explicitly needed as a function, `bool` is the best choice.

## 回答 26

``````def enquiry(list1):
if len(list1) == 0:
return 0
else:
return 1

# ––––––––––––––––––––––––––––––––

list1 = []

if enquiry(list1):
print ("The list isn't empty")
else:
print("The list is Empty")

# Result: "The list is Empty".``````

``````def enquiry(list1):
if not list1:
return True
else:
return False

# ––––––––––––––––––––––––––––––––

list1 = []

if enquiry(list1):
print ("The list is Empty")
else:
print ("The list isn't empty")

# Result: "The list is Empty"``````

To check whether a list is empty or not you can use two following ways. But remember, we should avoid the way of explicitly checking for a type of sequence (it’s a `less pythonic` way):

``````def enquiry(list1):
if len(list1) == 0:
return 0
else:
return 1

# ––––––––––––––––––––––––––––––––

list1 = []

if enquiry(list1):
print ("The list isn't empty")
else:
print("The list is Empty")

# Result: "The list is Empty".
``````

The second way is a `more pythonic` one. This method is an implicit way of checking and much more preferable than the previous one.

``````def enquiry(list1):
if not list1:
return True
else:
return False

# ––––––––––––––––––––––––––––––––

list1 = []

if enquiry(list1):
print ("The list is Empty")
else:
print ("The list isn't empty")

# Result: "The list is Empty"
``````

Hope this helps.