I recently was challenged to re-write Pythons map, reduce and filter as
list comprehensions.
Examples
First of all, I want to make sure you understand what those functions do. You might also want to have a look at my old article Functional Programming in Python.
map
numbers = list(range(10))
squares = map(lambda x: x ** 2, numbers)
print(squares)
gives
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
filter
def is_prime(element):
if element == 2:
return True
elif element <= 1 or element % 2 == 0:
return False
else:
for i in range(3, element, 2):
if element % i == 0:
return False
return True
myList = [4, 4, 9, 12, 13, 2, 7, 9, 11, 11]
r = filter(is_prime, myList)
print(r)
gives [13, 2, 7, 11, 11].
reduce
numbers = list(range(10))
diff = reduce(lambda x, y: x - y, numbers)
print(diff)
gives -45, because
$$((((((((0-1)-2)-3)-4)-5)-6)-7)-8)-9 = -45$$
Sequential solution
The standard way to do these tasks without map, filter and reduce is to
use loops.
map
numbers = list(range(10))
squares = []
for x in numbers:
squares.append(x ** 2)
print(squares)
filter
def is_prime(element):
if element == 2:
return True
elif element <= 1 or element % 2 == 0:
return False
else:
for i in range(3, element, 2):
if element % i == 0:
return False
return True
my_list = [4, 4, 9, 12, 13, 2, 7, 9, 11, 11]
r = []
for x in my_list:
if is_prime(x):
r.append(x)
print(r)
reduce
numbers = list(range(10))
x = numbers[0]
for y in numbers[1:]:
x = x - y
print(x)
List comprehensions
List comprehensions are - according to Guido van Rossum - the way to go. So
lets see how the code looks like without map, reduce and filter.
map
numbers = list(range(10))
squares = [x ** 2 for x in numbers]
print(squares)
I think that is much more readable than the map solution.
filter
def is_prime(element):
if element == 2:
return True
elif element <= 1 or element % 2 == 0:
return False
else:
for i in range(3, element, 2):
if element % i == 0:
return False
return True
my_list = [4, 4, 9, 12, 13, 2, 7, 9, 11, 11]
r = [x for x in my_list if is_prime(x)]
print(r)
I also think this is more readable, as you can easily combine it with more transformations.
reduce
This is the tricky one. List comprehensions create lists again, so using only
list comprehensions is not going to work. However, you could cheat.
sum(numbers) is essentially reduce(lambda x, y: x + y, numbers). So we only
have to change the sign, except for the first one:
numbers = list(range(10))
diff = sum([numbers[0]] + [-x for x in numbers[1:]])
print(diff)
So, granted, the code using reduce looks much better. However, people argue
that you should use the sequential solution because it is simpler to
understand. By now, I understood every piece of code using reduce. But I
haven't seen it too often.