Thanks for the timing tests. My lists consist of a sets of nodes for synthetically generated protein phylogeny networks, with size ranges varying from ~10^3 to ~10^4. The structure of each network is essentially a forest of trees, and the goal of my filtering function is to extract the root nodes from each forest. My filter based code looks something like this:

However, after reading over your response and looking again at the NetworkX documentation, I found a simpler and more efficient solution.

Even on a set of very small networks (average size of 500 nodes each) second approach is about a 0.1s faster on each network. However, this adds up to a significant savings as I am calling rootSet on a fairly large number of networks. When I move to larger networks, the savings should be even more significant.

I think my example supports your conclusion. In addition to performing my filter as a list comprehension, choosing the proper NetworkX functions allowed me to replace my function call with a simple statement. Thanks again for your input.

17.8 seconds:
print timeit.timeit(‘[x for x in xrange(100000) if (lambda y: y==5)(x)]‘, number=100)
11.4 seconds:
print timeit.timeit(‘l5 = lambda x: x==5; [x for x in xrange(100000) if l5(x)]‘, number=100)
9.8 seconds:
print timeit.timeit(‘filter(lambda x: x==5, xrange(100000))’, number=100)
print timeit.timeit(‘l5 = lambda x: x==5; filter(l5, xrange(100000))’, number=100)
3.5 seconds:
print timeit.timeit(‘[x for x in xrange(100000) if x==5]‘, number=100)

When the filter can be written as a statement, under my test conditions the list comprehension is fastest. Have you tried inlining your filter function? Python has historically required such ugly tricks for best performance.

I’d really like to know how big your list is and what you do in your filtering function.