首页 文章

如何检查列表是否为空?

提问于
浏览
2957

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

a = []

如何检查 a 是否为空?

30 回答

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

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

  • 563

    另一种简单的方法可能是

    a = []
    if len(a) == 0:
      print("Empty")
    else:
      print(" Not empty")
    
  • 87

    从python3开始你可以使用

    a == []
    

    检查列表是否为空

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

    我不确定为什么会有这么多复杂的答案 . 它非常明确和直截了当

  • 1

    你甚至可以尝试像这样使用bool()

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

    我喜欢这种方式检查清单是否为空 .

    非常方便和有用 .

  • 232

    len() is an O(1) operation用于Python列表,字符串,dicts和集合 . Python内部跟踪这些容器中的元素数量 .

    JavaScript has a similar notion of truthy/falsy .

  • 33

    您可以检查数组的长度是否为零(或不是 . )如果 length of the array is zero ,那么它是 empty . 尝试以下方法:

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

    为什么要检查?

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

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

    a = []
    
    for item in a:
        <do something with item>
    
    <rest of code>
    

    这样可以处理 a 的任何内容,同时不需要对空白进行特定检查 . 如果 a 为空,则依赖块将不会执行,解释器将进入下一行 .

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

  • 58

    我已经看到以下是首选:

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

    一种非正式的方法:

    a = []
     try:
      print(a[-1])
     except IndexError:
      print("List is empty")
    
  • 24

    来自documentation关于真值测试:

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

    • None

    • False

    • 任何数字类型的零,例如 00.00j .

    • 任何空序列,例如 ''()[] .

    • 任何空映射,例如 {} .

    • 用户定义类的实例,如果类定义 __bool__()__len__() 方法,则该方法返回整数零或bool值 False .

    可以看出,空列表 [] 是假的,所以对布尔值做的事情听起来效率最高:

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

    pythonic方法来自PEP 8 style guide(其中 Yes 表示“推荐”, No 表示“不推荐”):

    对于序列,(字符串,列表,元组),请使用空序列为假的事实 . 是的:如果不是seq:
    如果seq:

    否:如果len(seq):
    如果不是len(seq):

  • 2

    Patrick's (accepted) answer是对的: if not a: 是正确的方法 . Harley Holcombe's answer是对的,这是PEP 8风格指南 . 但是没有一个答案可以解释为什么它对于Ruby用户或其他任何东西都不够明确或混淆 .

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

    确实 if not a: 不区分空列表与 None ,数字0或空元组,或空用户创建的集合类型,或空用户创建的非完全集合类型,或单元素NumPy数组充当标量有谬误的 Value 观等等 . 有时候明确这一点很重要 . 在这种情况下,你知道你想要明确的内容,所以你可以测试它 . 例如, if not a and a is not None: 表示"anything falsey except None",而 if len(a) != 0: 表示"only empty sequences—and anything besides a sequence is an error here",依此类推 . 除了测试您想要测试的内容外,这也向读者发出此测试很重要的信号 .

    但是当你没有任何明确的内容时, if not a: 以外的任何内容都会误导读者 . 你're signaling something as important when it isn' t . (你可能也会使代码变得不那么灵活,或者更慢,或者其他什么,但这一点都不那么重要 . )如果你习惯性地误导读者,那么当你确实需要做出区分时,它已经"crying wolf"全部"crying wolf"所有你的代码 .

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

    更实用一点:

    a.pop() if a else None
    
  • 7

    我使用的一些方法:

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

    我更喜欢以下内容:

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

    可读,您不必担心调用像 len() 这样的函数来遍历变量 . 虽然我的速度非常快,但我怀疑它是否重要,除非 a 是巨大的 .

  • 4213

    空列表的真值是 False ,而对于非空列表,它是 True .

  • 28

    我曾写过:

    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 如果你在's undefined) that you'准备处理的值上调用 len . 一般来说,"pythonic"约定似乎是最后一种方式 . 如果它不知道如何嘎嘎就让它像鸭子一样挤出它 . 你仍然需要考虑你没有准备妥善处理的类型假设确实会在正确的位置出错.Numpy数组是一个很好的例子,只是盲目地依赖于 len 或布尔类型转换可能无法正确地做什么你期待的 .

  • 4

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

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

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

    其他方法不适用于numpy数组

    你需要小心numpy数组,因为对于numpy数组,其他适用于 list 或其他标准容器的方法都会失败 . 我在下面解释原因,但简而言之,preferred method是使用 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 语句将"work",因为你没有得到错误 . 但是,如果该元素碰巧是 0 (或 0.0false ,...),则 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数组或其他什么,您可以将此方法与the answer @dubiousjim gives结合使用,以确保对每种类型使用正确的测试 . 不是很好"pythonic",但事实证明,至少在这种意义上,numpy故意打破了pythonicity .

    如果您需要做的不仅仅是检查输入是否为空,并且您可能更有效(当然更常见)强制输入为numpy数组 . 快速执行此操作有一些很好的功能 - 最重要的是numpy.asarray . 如果它是一个列表,元组等,它会接受你的输入,什么都不做,并且可选择将它转换为你选择的 dtype . 所以'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让它回到当前scope之外:

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

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

  • 1

    查看在Python交互式终端上执行的以下代码 .

    >>> a = []
    >>> if a:
    ...     print "List is not empty";
    ... else:
    ...     print "List is empty"
    ... 
    List is empty
    >>> 
    >>> a = [1, 4, 9]
    >>> if a:
    ...     print "List is not empty";
    ... else:
    ...     print "List is empty"
    ... 
    List is not empty
    >>>
    
  • 9

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

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

    如果要查看天气,列表中的所有值都为空 .

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

    但是对于空列表,这将是True .

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

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

    Python对于空虚的处理非常统一 . 鉴于以下内容:

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

    您只需使用“if”语句检查列表a,看它是否为空 . 从我读过和教过的内容来看,这是查看列表或元组是否为空的“Pythonic”方式 .

  • -1

    已经给出了很多答案,其中很多都很好 . 我只想补充一下这张支票

    not a
    

    也将传递 None 和其他类型的空结构 . 如果您确实想要检查空列表,可以执行以下操作:

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

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

    a = [] #the list
    

    1) 非常简单的pythonic方式:

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

    在Python中, empty containers 如列表,元组,集合,dicts,变量等被视为 False . 可以简单地将列表视为谓词(返回布尔值) . 并且 True 值表示它是非空的 .

    2) 一种非常明确的方式:使用 len() 查找长度并检查它是否等于 0

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

    3) 或将其与匿名空列表进行比较:

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

    4) 另一种愚蠢的方法是使用 exceptioniter()

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

    在真值测试中,空列表本身被视为假(参见python documentation):

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

    @Daren Thomas

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

    你的duckCollection应该实现 __nonzero____len__ 所以如果a:将工作没有问题 .

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

    虽然没有任何 Value 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
    
  • 1

    只需使用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
    

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

  • 0

    我明确地喜欢它:

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

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

  • 3

    检查列表是否为空的最佳方法例如,如果传递以下内容:a = []
    如何检查a是否为空?

    简答:

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

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

    向管理局提出上诉

    PEP 8,Python标准库中Python代码的官方Python风格指南,断言:

    对于序列,(字符串,列表,元组),请使用空序列为假的事实 . 是的:如果不是seq:
    如果seq:

    否:如果len(seq):
    如果不是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(并特别注意包含空列表, [] ):

    默认情况下,对象被视为true,除非其类定义了返回False的__bool __()方法或者在使用对象调用时返回零的__len __()方法 . 以下是大多数被认为是false的内置对象:常量定义为false:None和False . 任何数字类型的零:0,0.0,0j,十进制(0),分数(0,1)空序列和集合:'',(),[],{},set(),范围(0)

    和datamodel文档:

    object .__ bool __(self)调用实现真值测试和内置操作bool();应该返回False或True . 如果未定义此方法,则调用__len __()(如果已定义),如果对象的结果非零,则认为该对象为true . 如果类既未定义__len __()也未定义__bool __(),则其所有实例都被视为true .

    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
    

    我们看到,使用内置函数 len0 进行比较检查长度或检查空列表是否比使用所记录的语言的内置语法更低 .

    为什么?

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

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

相关问题