Python 如何检查列表是否为空？

例如，如果通过以下步骤：

a = []

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

a = []

如何检查

a

是否为空

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

---

在真值测试中，使用空的

列表的方法是非常有益的。
空列表本身被认为是错误的（请参阅）：

@达伦·托马斯

编辑：针对测试的另一点
空列表为False：那么
多态性？你不应该依赖别人
列表就是一个列表。它应该只是
像鸭子一样嘎嘎叫-你过得怎么样
让你的鸭群嘎嘎作响
没有元素时为“False”

您的duckCollection应该实现
\uuuuu非零\uuuuuuu
或
\uuuu len\uuuuuuu
，因此if a:将毫无问题地工作。
我更喜欢以下选项：

a = []

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

a = []

python的方法是从（其中Yes表示“推荐”，而No表示“不推荐”）：

对于序列（字符串、列表、元组），使用空序列为false这一事实。

<代码>是：如果不是，则如下：
如果如下所示：
否：如果长度（序号）：
如果不是len（序号）：

对于Python列表、字符串、dict和集合。Python在内部跟踪这些容器中的元素数量

---

JavaScript。

我更喜欢它：

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

通过这种方式，

li

是一个序列（列表），这是100%清楚的，我们想要测试它的大小。我对

if not li:…

的问题是，它给人一种错误的印象，认为

li

是一个布尔变量。

这是谷歌首次在“python测试空数组”和类似查询中大放异彩，加上其他人似乎把这个问题推广到了列表之外，所以我想我应该为很多人可能使用的不同类型的序列添加一个警告

其他方法不适用于NumPy数组 您需要小心使用NumPy数组，因为其他适用于

list

s或其他标准容器的方法无法适用于NumPy数组。我将在下面解释原因，但简而言之，问题是使用

size

“pythonic”方法不起作用：第1部分 对于NumPy数组，“pythonic”方法失败，因为NumPy尝试将数组强制转换为

bool

s的数组，并且

如果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部分 但至少上面的案例告诉你它失败了。如果恰好有一个NumPy数组，其中正好有一个元素，

If

语句将“起作用”，即不会出现错误。但是，如果一个元素恰好是

0

（或

0.0

，或

False

，…），则

if

语句将错误地导致

False

：

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

但是很明显，

x

存在并且不是空的！这个结果不是你想要的

使用

len

可能会产生意外的结果 比如说,

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

返回1，即使数组有零个元素

音速方式 如中所述，在您知道您有一个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

如果您不确定它可能是一个

列表

、一个NumPy数组还是其他什么，您可以将此方法与相结合，以确保对每种类型使用正确的测试。不是很“pythonic”，但事实证明NumPy至少在这个意义上故意打破了pythonicity

如果您需要做的不仅仅是检查输入是否为空，而且您正在使用其他NumPy功能，如索引或数学操作，那么强制输入为NumPy数组可能更有效（当然也更常见）。最重要的是，有一些很好的函数可以快速实现这一点。这将接收您的输入，如果它已经是一个数组，则不执行任何操作；如果它是一个列表、元组等，则将您的输入包装到一个数组中，并可选地将其转换为您选择的

dtype

。因此，无论何时，它都非常快速，并且它确保您只需假设输入是一个NumPy数组。我们通常甚至只使用相同的名称，因为转换为数组不会使其回到当前名称之外：

这将使

x.size

检查在我在本页上看到的所有情况下都有效。

我写过：

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

投票结果为-1。我不确定这是否是因为读者反对这一策略，或者认为给出的答案没有帮助。我会假装是后者，因为——不管算什么“蟒蛇式”——这是正确的策略。除非您已经排除，或者准备处理

a

为假的情况，例如

False

，否则您需要一个比

如果不是a:

更严格的测试。您可以使用以下内容：

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

第一个测试是对上面@Mike的答案的回应。第三行也可以替换为：

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

如果只希望接受特定类型（及其子类型）的实例，或使用：

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

您可以不进行显式类型检查，但前提是周围的上下文已经确保

a

是您准备处理的类型的值，或者您确定您不准备处理的类型将引发错误（例如，

TypeError

，如果您对未定义的值调用

len

），则为您准备处理的值。通常，“pythonic”惯例似乎走到了最后。像鸭子一样挤压它，如果它不知道如何嘎嘎叫，就让它引发一个DuckError。不过，你仍然需要考虑你正在做的是什么类型的假设，以及你没有准备好正确处理的情况是否真的会在正确的地方出错。Numpy数组就是一个很好的例子我们只是盲目地依赖于

len

或布尔类型转换可能无法实现您的期望。

是正确的：

如果不是：

就是正确的方法。这在PEP 8样式指南中是正确的。但是什么呢

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

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

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

a = [] #the list

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

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

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

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

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

a = []

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

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')

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')

>>> 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)
  1           0 LOAD_GLOBAL              0 (len)
              2 BUILD_LIST               0
              4 CALL_FUNCTION            1
              6 LOAD_CONST               1 (0)
              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

typedef struct {
    PyObject_VAR_HEAD
    /* 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

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)

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

l = []
if l:
    # do your stuff.

l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
    # do your stuff.

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

if empty_list(lst):
    # do your stuff.

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

not a

if isinstance(a, list) and len(a)==0:
    print("Received an empty list")

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

a.pop() if a else None

if a: a.pop() 

a == []

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"

if not a : 
   print ("Empty") 

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

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

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