如何检查列表是否为空？

Question

例如,如果传递以下内容:

a = []

如何检查是否a为空？

Answer 1

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

使用空列表的隐式布尔值是非常pythonic.

Answer 2

pythonic方法是从PEP 8样式指南(其中Yes表示"推荐",No表示"不推荐"):

对于序列,(字符串,列表,元组),请使用空序列为假的事实.

Yes: if not seq:
     if seq:

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

Answer 3

我明确地喜欢它:

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

这样,它是100%清晰li的序列(列表),我们想测试它的大小.我的问题if not li: ...是它给出了li一个布尔变量的错误印象.

Answer 4

_{其他人似乎将这个问题概括为仅仅是列表,所以我想我会为很多人可能会使用的不同类型的序列添加一个警告,特别是因为这是第一次google hit for"python test empty array" .}

其他方法不适用于numpy数组

您需要小心numpy数组,因为其他适用于lists或其他标准容器的方法对于numpy数组都会失败.我在下面解释原因,但简而言之,首选方法是使用size.

"pythonic"方式不起作用:第1部分

"pythonic"方式因numpy数组失败,因为numpy尝试将数组转换为bools 数组,并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

如果您不确定它是否是a list,numpy数组或其他什么,您可以将此方法与@dubiousjim给出的答案结合起来,以确保为每种类型使用正确的测试.不是很"pythonic",但事实证明numpy至少在这个意义上有意破坏了pythonicity.

如果您需要做的不仅仅是检查输入是否为空,并且您正在使用索引或数学运算等其他numpy功能,那么强制输入为 numpy数组可能更有效(当然也更常见).快速完成这项工作有一些很好的功能 - 最重要的是numpy.asarray.这会接受您的输入,如果它已经是数组则不执行任何操作,或者如果它是列表,元组等,则将输入包装到数组中,并可选择将其转换为您选择的数组dtype.因此,只要它可以很快,它确保你只是假设输入是一个numpy数组.我们通常只使用相同的名称,因为转换为数组不会使其回到当前范围之外:

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

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

Answer 5

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

例如,如果传递以下内容:

a = []

如何检查a是否为空？

简答:

将列表放在布尔上下文中(例如,使用if或while语句).它将测试False它是否为空,True否则.例如:

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

向管理局提出上诉

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中甚至在语义上也是正确的.

但我们认为它不是Pythonic,因为Python通过布尔强制直接在列表对象的接口中支持这些语义.

从文档(并特别注意包含空列表[]):

默认情况下,对象被视为true,除非其类定义__bool__()返回False的__len__()方法或返回零的方法(使用对象调用时).以下是大多数被认为是错误的内置对象:

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

和datamodel文档:

object.__bool__(self)

被称为实施真值测试和内置操作bool(); 应该回来False或True.如果未定义此方法,__len__()则调用此方法( 如果已定义),如果其结果为非零,则将该对象视为true.如果一个类既未定义也__len__() 未定义__bool__(),则其所有实例都被视为真.

和

object.__len__(self)

被称为实现内置功能len().应该返回对象的长度,整数> = 0.此外,在布尔上下文中,未定义__bool__()方法且其__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

我们看到,无论是与内建函数长度检查len相比,0 或检查对空列表是太多比使用语言的内置语法记载高性能的少.

为什么？

对于len(a) == 0检查:

首先Python必须检查全局变量以查看是否len被遮蔽.

然后它必须调用函数,加载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

因为[] == []它必须构建一个不必要的列表,然后再次在Python的虚拟机中进行比较操作(而不是C)

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

"Pythonic"方式是一种更简单,更快速的检查,因为列表的长度缓存在对象实例头中:

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

来自C源和文档的证据

PyVarObject

这是PyObject增加ob_size字段的扩展.这仅用于具有一些长度概念的对象.此类型通常不会出现在Python/C API中.它对应于PyObject_VAR_HEAD宏扩展定义的字段.

从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

我喜欢研究这个,我花了很多时间来策划我的答案.如果您认为我要留下一些东西,请在评论中告诉我.

Answer 6

在真值测试中,空列表本身被认为是假的(参见python文档):

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

@Daren Thomas

编辑:反对测试空列表的另一点是错误的:多态性怎么样？您不应该依赖列表作为列表.它应该像鸭子一样嘎嘎叫 - 如果它没有元素,你怎么能让你的duckCollection嘎嘎''假''？

你的duckCollection应该实现,__nonzero__或者__len__if a:将正常工作.

Answer 7

帕特里克(接受)的答案是对的:这if not a:是正确的方法.Harley Holcombe的回答是正确的,这是PEP 8风格指南.但是,没有任何答案可以解释为什么遵循这个习惯是一个好主意 - 即使你个人发现它不够明确或者对Ruby用户或其他任何东西感到困惑.

Python代码和Python社区有很强的习惯用法.遵循这些习语使得您的代码更易于阅读Python中的任何人.当你违反这些习语时,这是一个强烈的信号.

确实,if not a:不区分空列表None,数字0或空元组,或空用户创建的集合类型,或空用户创建的非完全集合类型,或单元素NumPy数组充当带有falsey的标量值得等等.有时候明确这一点很重要.而在这种情况下,你知道什么,你想明确一下,这样你就可以测试这一点.例如,if not a and a is not None:意味着"除了None之外的任何虚假",而if len(a) != 0:意味着"只有空序列 - 除了序列之外的任何东西都是错误的",依此类推.除了测试您想要测试的内容外,这也向读者发出此测试很重要的信号.

但是,当你没有任何明确的内容时,除了if not a:误导读者之外的其他任何事情.如果没有,那么你就会发出重要的信号.(你可能也会使代码变得不那么灵活,或者更慢,或者其他什么,但这些都不那么重要.)如果你习惯性地误导读者,那么当你确实需要做出区分时,它会被忽视,因为你的代码一直在"哭狼".

Answer 8

为什么要检查？

似乎没有人质疑你是否需要首先测试清单.因为您没有提供额外的上下文,我可以想象您可能不需要首先进行此检查,但不熟悉Python中的列表处理.

我认为最pythonic的方法是根本不检查,而是只处理列表.这样,无论是空的还是满的,它都会做正确的事情.

a = []

for item in a:
    <do something with item>

<rest of code>

这具有处理任何内容的好处一,而不是要求对空虚的特定检查.如果a为空,则依赖块将不会执行,解释器将进入下一行.

如果你确实需要检查数组是否空虚,那么其他答案就足够了.

Answer 9

len()是 Python列表,字符串,dicts和集合的O(1)操作.Python内部跟踪这些容器中的元素数量.

JavaScript 有一个类似于truthy/falsy的概念.

Answer 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或布尔类型转换可能无法完全按照您的期望.

Answer 11

从关于真值测试的文档:

除此处列出的值之外的所有值都将被考虑 True

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

可以看出,空列表[]是假的,因此对布尔值执行的操作听起来效率最高:

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

Answer 12

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

a = [] #the list

1)非常简单的pythonic方式:

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

在Python中,列表,元组,集合,dicts,变量等空容器被视为False.可以简单地将列表视为谓词(返回布尔值).一个True值表明它是非空的.

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

Answer 13

你甚至可以尝试这样使用bool()。虽然它的可读性肯定较低，但它是执行此操作的简洁方法。

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

我喜欢这种方式，因为检查清单是否为空。

非常方便和有用。

Answer 14

方法1（首选）：

if not a : 
   print ("Empty") 

方法2：

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

方法3：

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

Answer 15

我更喜欢以下内容:

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

Answer 16

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

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.

Answer 17

要检查列表是否为空，您可以使用以下两种方法。但请记住，我们应该避免显式检查序列类型的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"

希望这可以帮助。

Answer 18

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

Answer 19

受到@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

Answer 20

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

更实用一点：

a.pop() if a else None

和最测试版本：

if a: a.pop() 

Answer 21

只需使用 is_empty() 或 make 函数，如：-

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

它可以用于任何数据结构，如列表、元组、字典等等。通过这些，您可以仅使用is_empty(any_structure).

Answer 22

Simple way is checking the length is equal zero.

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

Answer 23

给出了许多答案，其中很多都很好。我只想补充一下

not a

也将通过None和其他类型的空结构。如果您确实要检查一个空列表，可以执行以下操作：

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

Answer 24

从 python3 开始，您可以使用

a == []

检查列表是否为空

编辑：这也适用于 python2.7..

我不知道为什么有这么多复杂的答案。这是非常清晰和直接的

Answer 25

我们可以使用简单的方法：

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

Answer 26

让我来到这里的是一个特殊的用例：我实际上想要一个函数来告诉我列表是否为空。我想避免在这里编写自己的函数或使用 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)))

当然，不要使用in bool(if即if bool(L):)，因为它是隐含的。但是，对于明确需要“不为空”作为函数的情况，bool是最佳选择。

Answer 27

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