如何检查列表中的所有项目是否都没有？

Question

In [27]: map( lambda f,p: f.match(p), list(patterns.itervalues()), vatids )
Out[27]: [None, <_sre.SRE_Match object at 0xb73bfdb0>, None]

The list can be all None or one of it is an re.Match instance. What one liner check can I do on the returned list to tell me that the contents are all None ?

Answer 1

all(v is None for v in l)

will return True if all of the elements of l are None

Note that l.count(None) == len(l) is a lot faster but requires that l be an actual list and not just an iterable.

Answer 2

not any(my_list)

returns True if all items of my_list are falsy.

Edit : Since match objects are always trucy and None is falsy, this will give the same result as all(x is None for x in my_list) for the case at hand. As demonstrated in gnibbler's answer , using any() is by far the faster alternative.

Answer 3

Since Match objects are never going to evaluate to false, it's ok and much faster to just use not any(L)

$ python -m timeit -s"L=[None,None,None]" "all( v is None for v in L )"
100000 loops, best of 3: 1.52 usec per loop
$ python -m timeit -s"L=[None,None,None]" "not any(L)"
1000000 loops, best of 3: 0.281 usec per loop

$ python -m timeit -s"L=[None,1,None]" "all( v is None for v in L )"
100000 loops, best of 3: 1.81 usec per loop
$ python -m timeit -s"L=[None,1,None]" "not any(L)"
1000000 loops, best of 3: 0.272 usec per loop

Answer 4

Or a bit weird but:

a = [None, None, None]
set(a) == set([None])

OR:

if [x for x in a if x]: # non empty list
    #do something   

EDITED:

def is_empty(lVals):
    if not lVals:
        return True
    for x in lVals:
        if x:
            return False
    return True

Answer 5

I managed to come up with an approach using map that hasn't been given yet

tl;dr

def all_none(l):
    return not any(map(None.__ne__, l))

all_none([None, None, None]) # -> True
all_none([None, None, 8])    # -> False

explanation

The use of None.__ne__ is bit weirder than you'd expect at first glance. This method returns a NotImplementedType object when given something that isn't None.

You'd be hoping that NotImplemented would be a stand-in for False , however it's truthy too! This means that using None.__eq__ across a collection will produce thruthy values for everything.

list(map(None.__eq__, [None, None, 8]))
# -> [True, True, NotImplemented]

all(list(map(None.__eq__, [None, None, 8])))
# -> True

From the Python Docs :

By default, an object is considered true unless its class defines either a bool () method that returns False or a len () method that returns zero

Instead, None.__ne__ returns False for any None elements, and a NotImplementedType object for anything else:

list(map(None.__ne__, [None, None, 8]))
# -> [False, False, NotImplemented]

Using this, you can check if any elements are not None which will return True . I like to think of this as 2 separate methods if that helps with the mental negation gymnastics.

def contains_truthy(l):
    return any(map(None.__ne__, l))

def all_none(l):
    return not contains_truthy(l)

I haven't done any benchmarking with this, but as mentioned by others in this thread, not any will produce fast results.

Answer 6

is_all_none = lambda L: not len(filter(lambda e: not e is None, L))

is_all_none([None,None,'x'])
False
is_all_none([None,None,None])
True