如何检查列表是否为空？

a = []

#1 楼

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

使用空的list的隐式布尔值是相当Python的。

#2 楼

pythonic的方法来自PEP 8样式指南（其中Yes表示“推荐”，No表示“不推荐”）：


对于序列，（字符串，列表，元组） ），请使用空序列为假的事实。

Yes: if not seq:
     if seq:

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

#3 楼

我显式地喜欢它：

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

这样可以100％清楚地知道li是一个序列（列表），我们要测试其大小。我对if not li: ...的问题是它给人一种错误的印象，即li是布尔变量。

#4 楼

这是google在“ python测试空数组”和类似查询上的首次亮相，再加上其他人似乎在推广问题，不仅限于列表，所以我想为很多人添加另一种类型的序列的警告可能会使用。

其他方法不适用于NumPy数组

您需要谨慎使用NumPy数组，因为其他适用于list s或其他标准容器的方法对于NumPy数组失败。我将在下面解释原因，但总之，首选方法是使用size。

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

“ pythonic”方式NumPy数组失败，因为NumPy尝试将数组强制转换为bool的数组，而if x尝试一次为某种总计真值求值所有bool。但这没有任何意义，因此您会得到一个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。

numpythonic方式

如SciPy FAQ中所述，在您知道自己拥有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

如果不确定是否是list，NumPy数组或其他东西，则可以将此方法与@dubiousjim给出的答案结合使用，以确保对每种类型使用正确的测试。不是很“ pythonic”，但事实证明，NumPy至少在这种意义上有意破坏了pythonicity。

如果您需要做的不仅仅是检查输入是否为空，而您正在使用其他NumPy功能（例如索引或数学运算），将输入强制为NumPy数组可能更有效（当然更常见）。有一些不错的功能可以快速完成此操作-最重要的是numpy.asarray。这将接受您的输入，如果已经是数组，则不执行任何操作；如果是列表，元组等，则将您的输入包装到数组中，并有选择地将其转换为您选择的dtype。因此，它可以在任何时候都非常快，并且可以确保您只是假设输入是NumPy数组。我们通常甚至都使用相同的名称，因为转换为数组不会使其返回当前范围之外：

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

这将使x.size检查在此页面上看到的所有情况下都可以正常工作。

#5 楼

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

例如，如果传递了以下内容：

a = []

如何检查看看a是否为空？


简短答案：

将列表放在布尔上下文中（例如，使用if或while语句）。它将测试False是否为空，否则测试True。例如：

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

PEP 8

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

对于序列（字符串，列表，元组），请使用空序列为假的事实。

Yes: if not seq:
     if seq:

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

我们应该期望标准库代码应具有尽可能高的性能和正确性。但是为什么会这样，为什么我们需要这个指导呢？

解释

我经常从Python的新手那里看到这样的代码：

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

这些在他们各自的其他语言中都是正确的。在Python中，这甚至在语义上都是正确的。

但是我们认为它不是Python语言，因为Python通过布尔强制转换直接在列表对象的界面中支持这些语义。

从文档中开始（并特别注意包含空list，[]）：


默认情况下，除非对象的类定义了
返回__bool__()的False方法或返回__len__()的None方法
，否则认为该对象为true与对象一起调用时为零。以下是大多数被视为false的内置对象：


常量被定义为false：False和0。
任意数字类型为零：0.0，0j，Decimal(0)， Fraction(0, 1)，''

空序列和集合：()，[]，{}，set()，range(0)，object.__bool__(self)



数据模型文档：


bool()

用于实现真值测试和内置操作False;应该返回True或__len__()。如果未定义此方法，则调用__len__()（如果已定义），并且如果其结果为非零，则认为该对象为true。如果一个类既没有定义__bool__()
也没有定义object.__len__(self)，则所有实例都被认为是正确的。


和



len()

被调用以实现内置功能__bool__()。应该返回对象的长度，即> = 0的整数。而且，在布尔型上下文中，未定义__len__()方法且其len方法返回零的对象也被视为false。


所以代替这个：

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

我们看到，要么使用内置函数0来比较len(a) == 0来检查长度，要么检查是否为空list的性能远不如使用所记录的语言的内置语法低。

为什么？

对于len检查：

第一个Python具有检查全局变量以查看0是否被遮挡。

然后，它必须调用该函数，加载[] == []，并在Python中（而不是使用C）进行相等比较：

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

对于PyVarObject，它必须建立一个不必要的列表，然后再次在Python的虚拟机（而不是C）中进行比较操作。

>>> 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源代码和文档的证据


PyObject

这是对ob_size的扩展，其中添加了PyObject_VAR_HEAD字段。仅用于具有长度概念的对象。此类型通常不出现在Python / C API中。它对应于l=[]宏扩展定义的字段。


从Include / listobject.h中的c源中：

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

回应评论：


我要指出的是，对于非空情况也是如此，尽管它与%timeit len(l) != 0然后%timeit l != [] 90.6 ns±8.3 ns相当难看， %timeit not not l 55.6 ns±3.09，not not l 38.5 ns±0.372。但是，尽管速度提高了三倍，但没有人会喜欢if l:。看起来很荒谬。但是速度胜过
我想问题是要及时测试，因为仅%timeit bool(l)就足够了，但令人惊讶的是%timeit l的输出为101 ns±2.64 ns。有趣的是，没有这种惩罚就没有办法胁迫。 %timeit是无用的，因为将不会进行转换。


IPython的not并不是在这里完全没用：

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)
 

现在让我们来看一个不空列表的情况：

 bool 

我们可以在这里看到的是，无论是将实际的q4312079q传递给条件检查还是列表本身，都没有什么区别，并且如果有的话，按原样提供列表也更快。

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

#6 楼

一个空列表本身在真实值测试中被认为是错误的（请参阅python文档）：

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

@Daren Thomas


编辑：反对测试
空列表的另一点是False：
多态性呢？您不应该依赖列表作为列表。它应该像鸭子一样嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎地嘎嘎嘎嘎地嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎嘎的鸭子鸭子鸭子
在没有元素的情况下“ False”？


您的duckCollection应该实现__nonzero__或__len__，因此if a：可以毫无问题地工作。

#7 楼

帕特里克（接受）的答案是正确的：if not a:是正确的方法。 Harley Holcombe的答案是正确的，因为这在PEP 8样式指南中。但是，答案没有一个能解释的是，为什么遵循这个习惯用法是一个好主意-即使您个人发现它对Ruby用户或其他任何人来说不够明确或令人困惑。

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

的确，if not a:不能将空列表与None，数字0，空元组或空用户创建的集合类型或空的用户创建的非相当集合类型，或单元素NumPy数组充当带有虚假值的标量，等等。有时，对此加以明确是很重要的。在这种情况下，您知道要明确说明的内容，因此可以进行准确测试。例如，if not a and a is not None:的意思是“除None以外的其他任何虚假信息”，而if len(a) != 0:的意思是“仅空序列-此处除序列外的任何内容都是错误”，依此类推。除了准确测试您要测试的内容之外，这还向读者表明该测试很重要。

但是当您没有任何要明确的内容时，if not a:之外的任何其他内容都会误导读者。当您不重要时，您表示的是同样重要的事情。 （您可能还会使代码的灵活性降低，变慢，变慢等等，但这并不那么重要。）而且，如果您习惯性地这样误导读者，那么当您确实需要区分时，它会被忽略，因为您在代码中一直在“哭狼”。

#8 楼

为什么要全部检查？
似乎没有人提出质疑，要求您首先测试列表。因为您没有提供其他上下文，所以我可以想象您可能不需要首先进行此检查，但是您不熟悉Python中的列表处理。
我认为，最Python的方式是不检查全部，而是仅处理列表。这样一来，无论是空还是满，它都会做正确的事情。

a = []

for item in a:
    <do something with item>

<rest of code>

的好处是可以处理a的任何内容，而无需专门检查是否为空。如果a为空，则将不执行从属块，并且解释器将进入下一行。
如果确实需要检查数组是否为空，则其他答案就足够了。

#9 楼

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

JavaScript具有类似的true / falsy概念。

#10 楼

我曾写过：

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

被投票为-1。我不确定这是否是因为读者反对该策略或认为答案对所提供的内容没有帮助。我会假装是后者，因为-不管什么都算是“ pythonic”-这都是正确的策略。除非您已经排除或准备处理a例如False的情况，否则您需要的测试不仅仅是if not 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或布尔类型转换可能无法完全满足您的期望。

#11 楼

从关于真值测试的文档中：

除此处列出的值外，所有其他值均视为True


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

可以看到，空列表[]是虚假的，因此应执行以下操作将值设为布尔值听起来最有效：

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

#12 楼

我更喜欢以下内容：

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

#13 楼

您可以通过以下几种方法检查列表是否为空：

a = [] #the list

1）非常简单的pythonic方式：

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

在Python中，空容器（如列表，元组，集合，字典，变量等）被视为False。可以简单地将列表视为谓词（返回布尔值）。

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

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

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

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

4）另一种愚蠢的方法是使用0和exception ：

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

#14 楼

方法1（首选）：

if not a : 
   print ("Empty") 

方法2：

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

方法3：

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

#15 楼

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

分别测试None和空度有时是好的，因为它们是两个不同的状态。上面的代码产生以下输出：

list is None 
list is empty 
list has 3 elements

尽管None虚假是毫无价值的。因此，如果您不想对None -ness进行单独测试，则不必这样做。

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

#16 楼

给出了许多答案，其中很多都很好。我只是想补充一下，对于None和其他类型的空结构，check

not a

也将通过。如果您确实要检查一个空列表，可以执行以下操作：

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

#17 楼

如果要检查列表是否为空：

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

如果要检查列表中的所有值是否为空。但是，对于空列表，它将是True：

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.

#18 楼

受@dubiousjim解决方案的启发，我建议对它是否可迭代进行额外的常规检查。

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

注意：字符串被认为是可迭代的。 -如果要排除空字符串，请添加and not isinstance(a,(str,unicode))

测试：

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

我们可以使用一个简单的if if：

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

#20 楼

您甚至可以尝试使用bool()这样。尽管肯定不太可读，但这是执行此操作的简洁方法。

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

我喜欢这种方式，因为检查清单是否为空。
非常方便且有用。

#21 楼

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

更实用：

a.pop() if a else None

和最透明的版本：

if a: a.pop() 

#22 楼

要检查列表是否为空，可以使用以下两种方法。但是请记住，我们应该避免显式检查序列类型的方法（这是less pythonic方法）：

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

第二个方式是more pythonic之一。此方法是一种隐式检查方法，比以前的方法更可取。

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"

希望有帮助。

#23 楼

只需使用is_empty（）或使函数类似：-

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

它可用于任何data_structure，例如列表，元组，字典等。通过这些，您可以仅使用is_empty(any_structure)多次调用它。

#24 楼

简单的方法是检查长度等于零。

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

#25 楼

从python3开始，您可以使用

a == []

检查列表是否为空

编辑：这也适用于python2.7。 br />
我不确定为什么会有这么多复杂的答案。
它很清楚和直接

#26 楼

空列表的真值是False，而非空列表的真值是True。

#27 楼

这给我带来了一个特殊的用例：我实际上想要一个函数来告诉我列表是否为空。我想避免在此处编写自己的函数或使用lambda表达式（因为它看起来应该足够简单）：

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

当然，不要暗示在bool中使用if（即if bool(L):）。但是，对于明确需要“不为空”作为函数的情况，bool是最佳选择。