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

利用空名单中的暗含的酒精是相当的蟒蛇。

做这件事的方法是从 PEP 8 style guide (何处) 是的 建议的方法和 不 表示不推荐):

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

Yes: if not seq:
     if seq:

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

我更喜欢它:

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

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

_{其他人似乎只是泛化了列表之外的问题,所以我想我应该为很多人可能使用的不同类型的序列添加一个警告,特别是因为这是Google第一次点击“python test empty array”。}

其他方法不适用于numpy数组

您需要小心使用numpy数组,因为其他方法对 list 对于numpy数组,s或其他标准容器失败。我解释了下面的原因,但简而言之, preferred method 是使用 size .

“蟒蛇”的方式不起作用:第一部分

“pythonic”方法在numpy数组中失败,因为numpy试图将数组强制转换为 bool S和 if x 尝试评估所有这些 布尔 对于某种集合的真值。但这没有任何意义,所以你得到一个 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()

“蟒蛇”的方式不起作用:第2部分

但至少上面的情况告诉你它失败了。如果恰好有一个numpy数组中只有一个元素, if 声明将“起作用”,在这个意义上,你不会得到一个错误。但是,如果一个元素恰好是 0 (或) 0.0 或 false ,……) 如果 语句将错误地导致 假 :

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

但是很清楚 x 存在且不是空的!这个结果不是你想要的。

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

例如,

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

返回1,即使数组中没有元素。

麻木的方式

如中所述 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

如果你不确定是否是 列表 ,一个numpy数组或其他东西,您可以将此方法与 the answer @dubiousjim gives 以确保每种类型都使用了正确的测试。不是很“蟒蛇”,但事实证明,麻木的人至少在这个意义上故意破坏了蟒蛇。

如果您需要做的不仅仅是检查输入是否为空,而且您正在使用索引或数学操作等其他麻木功能,那么强制输入可能更有效(当然更常见)。 成为 一个麻木的数组。有一些很好的功能可以很快完成这项工作,最重要的是 numpy.asarray . 这将接受您的输入,如果它已经是一个数组,则不执行任何操作;如果输入是一个列表、元组等,则将其包装为一个数组,并可以选择将其转换为所选的 dtype . 所以无论什么时候它都是非常快速的,它可以确保您可以假设输入是一个麻木的数组。我们通常甚至只使用相同的名称,因为到数组的转换不会使它返回到当前的外部 scope :

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

这将使 x.size 检查我在本页上看到的所有情况下的工作。

在真值测试中,空列表本身被认为是错误的(请参见 python documentation ):

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

@ Daren Thomas

编辑:另一个反对测试的观点 空列表为假:怎么办? 多态性?你不应该依赖 列表是一个列表。它应该只是 像鸭子一样嘎嘎叫-你好吗 让你的DuckCollection去江湖 “false”当它没有元素时?

您的DuckCollection应该实现 __nonzero__ 或 __len__ 因此,如果A:可以毫无问题地工作。

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

例如,如果通过以下步骤:

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通过布尔强制直接在列表对象的接口中支持这些语义。

从 docs (并特别注意空名单的列入, [] ):

默认情况下,除非对象的类定义 要么是 __bool__() 返回的方法 假 或A __len__() 方法 当用对象调用时返回零。以下是大多数被认为是错误的内置对象:

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

以及数据模型文档:

object.__bool__(self)

调用以实现真值测试和内置操作 bool() 应该返回 假 或 真 . 如果未定义此方法, α- Lyapunov() 如果已定义,则调用,如果结果非零,则认为对象为真。如果类既没有定义 α- Lyapunov() 也不 α-BooLoL*() ,它的所有实例都被认为是真的。

和

object.__len__(self)

调用以实现内置函数 len() . 应返回对象的长度,一个整数>=0。另外,不定义 α-BooLoL*() 方法和谁的 α- Lyapunov() 方法返回零在布尔上下文中被视为假。

因此,不要这样:

如果len(a)==0:不要这样做!
print('a是空列表')

或者:

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

对于scale,这里是调用函数并构造和返回空列表的成本,您可以从上面使用的空性检查的成本中减去:

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

我们看到了 任何一个 使用内置函数检查长度 len 相比于 零 或 检查空列表是 许多的 比使用文档中的语言内置语法性能差。

为什么?

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

首先,python必须检查全局参数以查看 伦恩 被遮蔽。

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

从C源输入 Include/listobject.h :

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

我很喜欢研究这个问题,我花了很多时间整理我的答案。如果你认为我遗漏了什么,请在评论中告诉我。

Patrick's (accepted) answer 是正确的: if not a: 是正确的方法。 Harley Holcombe's answer 这是正确的,这是在政治公众人物8风格指南。但是没有一个答案能解释为什么遵循这个成语是一个好主意,即使你个人认为它对Ruby用户或其他人来说不够明确或令人困惑。

python代码和python社区有非常强的习惯用法。遵循这些习语可以让您的代码更容易被任何在Python中有经验的人阅读。当你违反了这些习语,这是一个强烈的信号。

是真的 如果不是: 不区分空列表和 None ,或数字0,或空元组,或空的用户创建的集合类型,或空的用户创建的不完全的集合类型,或单元素numpy数组充当带有虚假值的标量,等等,有时需要明确说明这一点。在这种情况下,你知道 什么 你想要明确的,所以你可以测试一下。例如, if not a and a is not None: 意思是“除无以外的任何虚假”,而 if len(a) != 0: 意思是“只有空序列,除了序列之外的任何东西在这里都是错误的”,等等。除了测试您想要测试的内容之外,这还向读者发出信号,表明这个测试很重要。

但是当你没有任何明确的事情,除了 如果不是: 误导读者。当它不重要的时候,你在发出同样重要的信号。(你也可能使代码变得不那么灵活,或者更慢,或者其他什么,但这都不那么重要。) 习惯性地 像这样误导读者,然后当你 做 需要做一个区分,因为你在你的代码中一直在“哭泣的狼”,所以它不会被注意到。

我已将以下内容视为首选:

if not a:
    print("The list is empty or null")

为什么要检查?

似乎没人问过你 需要 首先测试列表。因为您没有提供额外的上下文,所以我可以想象,您可能首先不需要执行这种检查,但是不熟悉Python中的列表处理。

我认为 大多数蟒蛇 方法是根本不检查,而只是处理列表。这样,无论是空的还是满的,它都会做正确的事情。

a = []

for item in a:
    <do something with item>

<rest of code>

这有利于处理 一 ,而不需要对空性进行特定检查。如果 一 为空,依赖块将不执行,解释器将进入下一行。

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

len() is an O(1) operation 对于python列表、字符串、dict和集合。python在内部跟踪这些容器中的元素数量。

JavaScript has a similar notion of truthy/falsy .

我曾写过:

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

投票结果是-1。我不确定这是否是因为读者反对这一策略,或是因为他们认为这个答案在本文中没有帮助。我会假装是后者,因为——不管什么叫做“蟒蛇”——这是正确的策略。除非你已经排除了,或者准备好处理那些 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):

您可以在不进行显式类型检查的情况下离开,但前提是周围的上下文已经确保 一 是您准备处理的类型的值,或者如果您确定不准备处理的类型将引发错误(例如 TypeError 如果你打电话 len 在一个未定义的值上)准备处理。总的来说,“蟒蛇”公约似乎走到了最后。像鸭子一样挤压它,如果它不知道如何嘎嘎叫,就让它把鸭子养大。你还得这么做 认为 但是,关于您所做的类型假设,以及您不准备正确处理的案例是否真的会在正确的地方出错。numpy数组就是一个很好的例子,它只是盲目地依赖 伦恩 或者布尔类型转换可能不会完全按照您的期望进行。

巨蟒对空虚的处理非常统一。鉴于以下情况:

a = []

.
.
.

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

您只需检查带有“if”语句的列表A,看看它是否为空。根据我所读和所教的内容,这是一种“蟒蛇式”的方式来查看列表或元组是否是空的。

从 documentation 关于真值测试:

除此处列出的值以外的所有值都将被视为 True

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

可以看到,空列表 [] 是 法西 因此,对布尔值执行什么操作听起来最有效:

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

我使用的一些方法:

if not a:
    print "list is empty"


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

以下是检查列表是否为空的几种方法:

a = [] #the list

1) 非常简单的蟒蛇方式:

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

在蟒蛇中, 空容器 例如列表、元组、集合、dict、变量等被视为 False . 我们可以简单地将列表视为谓词。( 返回布尔值 )和A 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")

我更喜欢以下内容:

if a == []:
   print "The list 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])

有时候测试是很好的 None 对于空虚,因为它们是两种不同的状态。上面的代码产生以下输出:

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 = []
if len(a) == 0:
  print("Empty")
else:
  print(" Not empty")

从python3起,您可以使用

a == []

检查列表是否为空

编辑:这也适用于python2.7。

我不知道为什么会有这么多复杂的答案。 很清楚很简单

如果 数组的长度为零 那就是 空的 . 尝试以下操作:

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

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

已经给出了很多答案,其中很多都很好。我只是想加上那张支票

not a

也会通过 None 以及其他类型的空结构。如果您真的想检查空列表,可以这样做:

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

我们可以使用简单的if-else:

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

您甚至可以尝试这样使用bool()。

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

我喜欢这种方式,因为检查清单是空的还是不空的。

非常方便和有用。

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

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

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

更实用一点:

a.pop() if a else None

检查是否: len(list) == 0 返回: True

方法1(首选):

if not a : 
   print ("Empty") 

方法2:

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

方法3:

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

只需使用is_empty()或使函数如下:

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

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

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.