Software engineers spend a lot of time working with lists. You work on Wall
Street - you're analyzing lists of stock prices. Writing software for a drone
delivery service - you're processing lists of orders. You work at friendface - you're
profiling lists of users with your mountain of personal data. A lot of code
is spent analyzing, filtering, and combining the items in a list. Python
gives you functions to streamline these tasks: the map, filter, and reduce
functions. We will now iterate over this list of functions one by one.
Let us begin with the map function.
Suppose we have a function that computes the area
of a circle with radius R. What if we need to compute the areas for many
different circles? Here is a list of their radii. One way to do this would be
to first create an empty list of areas. Next, you could loop over the list of
radii. For each radius you would compute the area of the circle, then append it to
the area list. This block of code is very clear and erect. But with the map
function, we can accomplish this with a single line of code. The map function
takes two arguments. The first is a function, and the second is your list,
tuple, or other iterable object. Here, map will apply the area function to each
element in the list. But look! The output of the map function
is not a list. It is a map object, which is actually an iterator over the results.
This is highly favorable, especially when working with large collections of data.
We can, however, turn this into a list by passing the map to the list constructor.
If brevity is the soul of wit, then Python is in a class by itself. Here is
the general way the map function works. Suppose you have a list, tuple, or other
iterable collection of data, and we would like to apply the function f to each
piece of data. With the map function, you first specify the function, then you
specify the data to iterate over. The map function will return an iterator over
the collection of F applied to each piece of data.
For a second example, we will use the map function when working with data for a
map. Suppose you work for a weather reporting service, and all of your
temperature data is stored in Celsius. Then, unexpectedly, someone asks for a
weather map in Fahrenheit. How could this happen? I just do not know. Nevertheless,
we live to serve the user. Here is a list of temperature data for some major
cities around the world. Each tuple contains the name of the city in English,
and the temperature in degrees Celsius. Our goal is to convert this to a list,
where the degrees are in Fahrenheit. Here is the formula for converting from
Celsius to Fahrenheit. First, we will write a converter function using a
lambda expression. This function will accept a tuple as the input, and will
return a tuple with the same name, but the temperature in Fahrenheit. If you are
unfamiliar with lambda expressions, they are a way to create short functions in a
single line. We have a video that covers this topic in detail. You can now create
a list of data in Fahrenheit, by mapping the converter function to our list of
temperature data. Do not forget your jacket if you're visiting Argentina. The
filter function is used to select certain pieces of data from a list, tuple,
or other collection of data. This name was chosen because it filters out the
data you do not need. Suppose you were analyzing some data and you would like
to select all values that are above the average. First, import the statistics
module since it contains the mean function. Here is a short list of data
that I collected from a nearby fuel sensor. Let us compute the average of
this data, then display the average so that you can see that the filter works
as intended. We will now use the filter function to select the data greater than
the average. Just like with map, the first argument is a function. We will create an
anonymous function that tests the input to see if it is above average. Next, pass
in the list of data. The filter function will only return the data for which the
function is true. Once again, the return value is not a list, but a filter object,
which is an iterator over the results. We can create a list of the results by
passing the filter function to the list constructor.
It worked. These are the three values above the mean, and with a small change
to the lambda expression, you can select the values below average. I should check
the sensor. We cannot have negative amounts of fuel. Can we? Let us see
another interesting use of the filter function. When you are working with data
from outside sources, you will often encounter missing data or empty values.
For example, here is a partial list of the countries in South America.
Notice there are numerous strings that are empty. To remove these, we'll use the
filter function. But instead of passing in a function, we'll simply pass none as
the first argument. The second argument is the list of data as before.
This filters out all values that are treated as false in a boolean setting. In Python,
the values that are treated as false are the empty string, 0, an empty list, empty
tuple, empty dictionary, false, none, and those objects that signal to Python that
it is a trivial instance. But be careful when using the filter function in this way.
0 is a valid piece of data in most situations, so you would not want to
filter that out. The last function on our list is the reduce function.
This function is a bit ...unusual. In fact, as of Python 3, it is no longer a built-in
function. Instead, it has been demoted to the func tools module. The creator of
Python had this to say about the reduce function: use func tools dot reduce if
you really need it; however, 99% of the time an explicit for loop is more
readable. Once you see an example of the reduced
function you are likely to agree. Here is how the reduced function works. Suppose
you have a sequence of data, and a function that takes two arguments.
The reduce function will first apply F to the first two terms. Next, it will apply F
to the output value and to the third piece of data. Then, it will repeat this
process. In each step, it applies F to the previous output value and the next term
in the sequence. Once it has reached the last piece of data, it will return the
final value. Alternatively, the reduced function
computes this nested value. Let us see an example. To use the reduce function, we
must first import it from the func tools module. Let us use the reduce function to
multiply all numbers in a list. For this demonstration, we will multiply the first
10 prime numbers. To use the reduce function, we need a function that takes
two inputs. We will use a lambda expression to make a function that will
multiply the two inputs. And there is the product. Here is how it would look if you
multiply the prime numbers using a for loop instead of the reduce function
Which do you prefer?
The map, filter, and reduce functions greatly simplify the
process of working with lists and other iterable collections of data. In fact, if
you use lambda expressions, your work can often be done in a single line. After you
master these functions you will realize that Python should be a comedian, because
it's full of one-liners.