is there a way to capture misses on a list comprehension?

Question

Based on a simple list comprehension :

yay = [ i for i in a if a[i] ]
nay = [ i for i in a if not a[i] ]

I am wondering if there is a way to assign both the yay and nay values at once ( ie hits and misses on the conditional )?

Something that would look like this

( yay , nay ) = ...

I was curious about this on readability and speed ( I was a bit surprised to see two list comprehensions are about 5% faster than a single for-loop that appends to either list )

---

update:

The original example was to grab a listing of "true" and "false" valued keys in a dict...

a = {i: i >= 50 for i in range(100)}

yay = [k for k, v in a.items() if v]
nay = [k for k, v in a.items() if not v]

Answer 1

The usual solution here is not to get all hung up on the idea of using a list comprehension. Just use a for loop:

yay, nay = [], []
for i in a:
    if somecondition(i):
        yay.append(i)
    else:
        nay.append(i)

If you find yourself doing this a lot then simply move the code out into a function:

def yesno(seq, cond):
    yay, nay = [], []
    for i in seq:
        if cond(i):
            yay.append(i)
        else:
            nay.append(i)
    return yay, nay

yay, nay = yesno(a, lambda x: a[x])

The comments suggest this is slower than list comprehension. Passing the condition as a lambda is inevitably going to have a big hit and I don't think you can do much about that, but some of the performance hit probably comes from looking up the append method and that can be improved:

def yesno(seq, cond):
    yay, nay = [], []
    yes, no = yay.append, nay.append
    for i in seq:
        if cond(i):
            yes(i)
        else:
            no(i)
    return yay, nay

I don't know if that makes much of a difference, but it might be interesting to time it.

In the comments @martineau suggests using a generator and consuming it with any(). I'll include that here, but I would replace any with the itertools recipe to consume an iterator:

def consume(iterator, n):
    "Advance the iterator n-steps ahead. If n is none, consume entirely."
    # Use functions that consume iterators at C speed.
    if n is None:
        # feed the entire iterator into a zero-length deque
        collections.deque(iterator, maxlen=0)
    else:
        # advance to the empty slice starting at position n
        next(islice(iterator, n, n), None)

and then you can write:

yay, nay = [], []
consume((yay if a[i] else nay).append(i) for i in a)

Answer 2

I would still say, your way of doing is more readable and should be the suggested approach, but in any case, if you are looking for alternative, you can look forward with a solution from itertools

>>> from itertools import compress, imap
>>> from operator import not_
>>> yay, nay = compress(a,a.values()), compress(a, imap(not_,a.values()))

Answer 3

This could be done with something like this:

yay, nay = zip(*[(k, None) if v else (None, k) for k, v in a.items()])
yay, nay = filter(None, yay), filter(None, nay)

As to if it would be faster... maybe for huge lists. Otherwise, it's probably not going to matter.

Naturally, if None is a value in your lists, you will need to swap it out for another sentinel and do an identity check with filter().

Answer 4

You might be able to use a dict comprehension, but I'm reasonably sure you can't* use list comprehension to do what you ask. Assuming the data is or can be sorted** I would probably use itertools.groupby.

results = itertools.groupby(sorted_a, bool)

*Qualification: OK, Lattyware's answer shows that you can, but it also generates a tuple with an None value for each member of the iterable. IMO that's a lot of waste. While I confess I didn't even consider that, I'm not ashamed that I didn't.

**Sorted: It needs to be sorted by the same key as it's grouped by.

Answer 5

It's not pretty, but you could do something among this lines:

nay = []
yay = [foo for foo in foos if condition or nay.append(foo)]

This takes advantage of the short-circuit on the or operator.

Answer 6

EDIT

Oh well, I wrote a solution that was pretty the same than one of the Duncan's ones. So I delete what I wrote and I let what I consider to be the best solution, mixing one Duncan's solution and the proposal of martineau (use of any( ) appears to me a lot more preferable to the use of list( ) or a list comprehension as the one I had written; very good idea the any( ), that's better than the complication of importing consume( ) IMO)

def disting(L):
        dust,right = [],[]
        dustapp = dust.append
        rightapp = right.append
        any(rightapp(x) if x else dustapp(x) for x in L)
        return right,dust

for seq in ((10,None,'a',0,None,45,'qada',False,True,0,456),
            [False,0,None,104,True,str,'',88,'AA',__name__]):
    yay,nay = disting(seq)     
    print 'seq == %r\nyay == %r\nnay == %r' % (seq,yay,nay)
    print '---------------------------------------'

result

seq == (10, None, 'a', 0, None, 45, 'qada', False, True, 0, 456)
yay == [10, 'a', 45, 'qada', True, 456]
nay == [None, 0, None, False, 0]
---------------------------------------
seq == [False, 0, None, 104, True, <type 'str'>, '', 88, 'AA', '__main__']
yay == [104, True, <type 'str'>, 88, 'AA', '__main__']
nay == [False, 0, None, '']
---------------------------------------

By the way, using any( ) works because rightapp(x) and dustapp(x) return None. In case a True or equivalent to True would be returned, the iteration inside any( ) would stop !