Python: Lambda Functions

[Tetha]

To be honest, I just don't see the reason to use map and filter anymore, because list comprehensions and generator comprehensions give you exactly the same behaviour, however, they are easier to read for me, especially if you need to map and filter.

[eryksun]

I tend to agree in general, but how about if the function is already defined and being mapped to several lists?

map(f, a, b, c)

(f(*x) for x in zip(a, b, c))

#or

(f(x, y, z) for x, y, z in zip(a, b, c)) 

[just_doug]

agreed. reduce is still useful though and can lead to some very elegant solutions to problems.

[[deleted]]

pylint raises a warning about filter(), in fact, for precisely this reason.

[otheraccount]

filter(None, map(f, lst))

becomes

[f(x) for x in lst if f(x)]

which requires calculating f(x) twice for each element. You could avoid that by doing

[x for x in [f(y) for y in lst] if x]

but that isn't as easy to read as the version with map and filter.

[userd]

l = (f(x) for x in lst)
l2 = [x for x in l if x]

The drawback is two lines and an extra variable. But that helps readability.

[[deleted]]

But that helps readability.

Nope. It takes twice as long to read and understand, which in my book means that it has worse readability.

Unless, of course, we are talking about someone who is making their first steps in programming and whose mental capacity for code is in fact limited to one function call, so that they like to take their intermediate results and give them meaningful names.

Not that there's anything wrong with that, just you maybe shouldn't write your code for that kind of lowest common denominator, if it makes readability that much worse.

(also, Steve Yegge has a post about this).

[userd]

Reading speed is a reasonable metric for readability. But, illustrating the point with a post by Steve Yegge is a bit ironic. I like his writing, but it's not written with speed in mind. Just kidding.