How to check if all items in the list are None?

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

For the specific use case in the question, you can use

not any(my_list)

This returns True if all items of my_list are falsy. Since the only objects in your list are match objects and Nones, and match objects are always trucy, this will give the same result as all(x is None for x in my_list). As demonstrated in gnibbler's answer, using not any(my_list) is much faster.

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

Answer 7

If you expect some items to not be None, then I would avoid looping through the entire list.

def check_none(l):
    for x in l:
        if not x is None:
            return False
    return True

Answer 8

Checking if all elements in all_none are None.

all_none = [None, None, None]

all_none == ([None] * len(all_none))
True