o_18ufhmfmq19t513t3lgmn5l1qa8a.pdf

CHAPTER 6 ■ ABSTRACTION 135
>>> numbers = [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]
>>> filter(lambda n: n % 2 == 0, numbers)
[72, 108, 108, 44, 32, 114, 108, 100]
The lambda expression simply checks whether the remainder of a given number when
divided by 2 is zero (which is another way of saying that the number is even).
Now, map and filter can be very useful, but they were added to the language before list
comprehension came along. If you think about it, anything that map and filter can accomplish
can also be done with list comprehensions:
>>> [chr(n) for n in numbers] # characters corresponding to numbers
['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']
>>> [ord(c) for c in 'Hello, world!'] # numbers corresponding to characters
[72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]
>>> [n for n in numbers if n % 2 == 0] # filters out the odd numbers
[72, 108, 108, 44, 32, 114, 108, 100]
In my opinion, list comprehensions are, in most cases, more readable than using map and
filter. I won’t go so far as to say that you always should use list comprehensions: it’s largely a
matter of taste, and the demands of each specific programming task.
■Note If it is speed you are after, you may want to go with map and filter after all. When used with builtin
functions, they are faster than list comprehensions.
reduce
But what about the third function, reduce? This is a tricky one, and I confess that I rarely use it.
But people used to functional programming may find it useful. It combines the first two elements
of a sequence with a given function, and combines the result with the third element, and so on
until the entire sequence has been processed and a single result remains. For example, if you
wanted to sum all the numbers of a sequence, you could use reduce with lambda x, y: x+y (still
using the same numbers): 2
>>> numbers = [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]
>>> reduce(lambda x, y: x+y, numbers)
1161
In this example, all the numbers of numbers are summed by successively adding the current
sum and the next number in the sequence. What actually happens is very close to this:
sum = 0
for number in numbers:
sum = sum + number
2. Actually, instead of this lambda function, you could import the function add from the operator module,
which has a function for each of the built-in operators. Using functions from the operator module is
always more efficient than using your own functions.