This article is going to try to shed some light on how to convert map, reduce and filter (often used with lambda expressions) in python into a syntax conforming to „the python way“. At the bottom you will find a download link to execute this stuff for yourself.

l = range(10)
print l
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
This is going to be the list (l) we’re working on.

What we’ll be looking at first, is iterating through this list and applying a function. And what simpler function could there be, than the identity?
a = map(lambda x: x, l)
b = list(x for x in l)
print a, b
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
If you don’t really know what the we did in (a) you may want to read up on lambda expressions, a topic I am not covering now. We need the list-method in (b) because map() always returns a list and the for-expression coughs up a generator object which we have to fully evaluate and convert to a list, to get the equivalent. Generator objects I will cover in the future. For now, suffice to say, it has a reason we are applying the list-function.

Next, we are doing an actual calculation by looking for the cubes of our list (l)
a = map(lambda x: x**2, l)
b = list(x**2 for x in l)
print a, b
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Of course you can use actual functions like the cube root or any user defined function.
def usr(p):
return p+p
a = map(lambda x: usr(x), l)
b = list(usr(x) for x in l)
#[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

We could also combine various functions to create a new anonymous function to apply to our list
a = map(lambda x: usr(x)+5, l)
b = list(usr(x)+5 for x in l)
#[5, 7, 9, 11, 13, 15, 17, 19, 21, 23]
I think you got the idea. Remember, (a) and (b) are equivalent.

Next we will use two inputs. Let’s get ourselves another list then, shall we?
m = range(10,20)
#[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

And we add both lists together
a = map(lambda x,y: x+y, l, m)
b = list(x+y for x,y in zip(l, m))
print a,b
#[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]
Why internally those constructs do something very different, I will cover in the article about generators. But the resulting list is completely the same. Zip() takes lists/iterables as input and convertes them to a list of tuples (n-tuples for n = [number of input iterables]). This tuple is taken apart and put into x and y.

And we can also look at other methods like filter
a = filter(lambda x: x%2==0, l)
b = list(x for x in l if x%2==0)
#[0, 2, 4, 6, 8]

filter() can only filter through input. If you want to apply apply a function, you will have to use map again. In (b) you can do that intuitively:

a = map(lambda x: x*2, filter(lambda x: x%2==0, l))
b = list(x*2 for x in l if x%2==0)
print a,b
#[0, 4, 8, 12, 16]
As we can see, the for-construct can apply map() and filter()

reduce, which applies a two-parameter-function accumulatively throughout an iterable, on the other hand, is looks a bit different on converting (we try to find out the sum of l):
a = reduce(lambda x,y: x+y, l, 0)
b = 0
for x in l:
b = b+x
#45

If we use for in this way, we also can use the filter-if and the map, but we can not use it in the same line as the for-construct. But it is rather trivial, where to use it.

a = reduce(lambda x,y: x+y, map(lambda x: x*2, filter(lambda x: x%2==0, l)), 0)
b = 0
for x in l:
if (x%2==0):
b = b+ x*2
#40

In some cases map, filter, and reduce, (together with lambda expressions) probably are syntactic sugar. But in most cases, the python way looks much more readable.

As a note: you can use map, filter and reduce without lambda, as long as you have a function that has as many parameters as you have input iterables. This is valid and does the same as the one far above:
a = map(usr, l)
#[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

And if you do not want to think about lambdas you can easily create named functions with this simple rule:
lambda arguments: expression
#is the same as
def name(arguments):
return expression

As a final note: The for-construct actually is a generator expression which are handled a bit differently from lists or other „normal“ iterables. This can have impact on execution speed (or control flow in general) but that will be covered later.
Thanks for reading.

Attachment: lambda_anon.txt which I couldn’t name .py because WordPress is paranoid.