Gfilui

I have seen a pattern repeated a couple times in my team's code, it looks like this

numbers = [1, 2, 3, 4]
even_numbers = [n for n in numbers if n % 2 == 0]
odd_numbers = [n for n in numbers if n % 2 != 0]

I was wondering if there is a function somewhere (I have looked around but haven't been able to find it) that would do something like this

numbers = [1, 2, 3, 4]
even_numbers, odd_numbers = fork(numbers, lambda x: x % 2 == 0)

So, this function I am looking for, would receive an iterable and a function, and return two lists, one would be the values that match a provided condition, and the other would be the ones that didn't.

Is there something around python's standard library that achieves this?

I usually call this sift, but partition is fine too.

Another, itertools-less implementation might be

def sift(iterable, predicate):
 t = 
 f = 
 for value in iterable:
 (t if predicate(value) else f).append(value)
 return (t, f)

even, odd = sift([1, 2, 3, 4, 5], lambda x: x % 2 == 0)

EDIT: for a slightly more complex implementation that is about 30% faster (on my Python installation anyway):

def sift2(iterable, predicate):
 t = 
 f = 
 ta = t.append
 fa = f.append
 for value in iterable:
 (ta if predicate(value) else fa)(value)
 return (t, f)

You can use the following function:

from itertools import filterfalse, tee

def fork(pred, iterable):
 'Use a predicate to partition entries into false entries and true entries'
 t1, t2 = tee(iterable)
 return list(filterfalse(pred, t1)), list(filter(pred, t2))

Source: itertools

I did not find anything in standard library performing what you want. I suggest you this user-defined implementation, which is not optimized at all but very simple and easy to read:

def myFunc(iterable, func):

 first = [i for i in iterable if func(i)]
 second = [i for i in iterable if not func(i)]

 return first,second


numbers = [1, 2, 3, 4]
even_numbers, odd_numbers = myFunc(numbers, lambda x: x % 2 == 0)

print(even_numbers) # [2, 4]
print(odd_numbers) # [1, 3]

Full code following @jonrsharpe suggestion.

import itertools

def fork(iterable):
 "Returns list of even, odd elements of a list"
 t1, t2 = itertools.tee(iterable)
 pred = lambda i: i % 2 == 0
 return list(filter(pred, t2)), list(itertools.filterfalse(pred, t1))

odd, even = fork([1,2,3,4,5])
print(odd)
print(even)

Alternative numpy version which might be faster for big arrays

import numpy as np

def fork(iterable):
 "Returns array of even, odd elements of an array"
 iterable_array = np.asarray(iterable)
 mask = (iterable_array % 2 == 0)
 return iterable_array[~mask], iterable_array[mask]

The simplest possible implementation would be probably

def partition(xs, cond):
 res = , 
 for x in xs:
 res[not cond(x)].append(x)
 return res

You can create your own function:

l = [1, 2, 3, 4]
def fork(l,key):
 return list(filter(key,l)), [i for i in l if i not in list(filter(key,l))]
even_numbers, odd_numbers = fork(l, lambda x: x % 2 == 0)
print(even_numbers)
print(odd_numbers)

Output:

[2, 4]
[1, 3]