Question

I find myself often wanting to write Python list comprehensions like this:

nearbyPoints = [(n, delta(n,x)) for n in allPoints if delta(n,x)<=radius]

That hopefully gives some context as to why I would want to do this, but there
are also cases where multiple values need to be computed/compared per
element:

newlist = [(x,f(x),g(f(x))) for x in bigList if f(x)<p and g(f(x))<q]

So I have two questions:

1. will all those functions be evaluated multiple times or is the result cached?
   Does the language specify or is it implementation-specific? I’m using 2.6 now, but would 3.x be different?
2. is there a neater way to write it? Sometimes f and g are long expressions and
   duplication is error prone and looks messy. I would really like to be able to
   write this:

newList = [(x,a=f(x),b=g(a)) for x in bigList if a<p and b<q]

but that doesn’t work. Is there a good reason for not supporting this syntax? Can
it be done via something like this?
Or would I just have to use multiple listcomps or a for-loop?

Answer 1

In regards to #1, yes, they will be evaluated multiple times.

In regards to #2, the way to do it is to calculate and filter in separate comprehensions:

Condensed version:

[(x,fx,gx) for (x,fx,gx) in ((x,fx,g(fx)) for (x,fx) in ((x,f(x)) for x in bigList) if fx < p) if gx<q]

Longer version expanded to make it easier to follow:

[(x,f,g) for (x,f,g) in
  ((x,f,g(f)) for (x,f) in
     ((x,f(x)) for x in bigList)
  if f < p)
if g<q]

This will call f and g as few times as possible (values for each f(x) is not < p will never call g, and f will only be called once for each value in bigList).

If you prefer, you can also get neater code by using intermediate variables:

a = ( (x,f(x)) for x in bigList )
b = ( (x,fx,g(fx)) for (x,fx) in a if fx<p )
results = [ c for c in b if c[2] < q ] # faster than writing out full tuples

a and b use generator expressions so that they don’t have to actually instantiate lists, and are simply evaluated when necessary.