<\/p>\n
1. map<\/h3>\n
Map allows you to apply an operation to each element of a sequence. You provide two inputs to map: the function to apply and the sequence.<\/p>\n
The output is a sequence of the results.<\/p>\n
For example, assuming you have a function that calculates the area of a circle. This function is given below.<\/p>\n
<\/p>\n
import<\/span> math<\/span>\r\n\r\ndef<\/span> calculatearea<\/span>(radius):\r\n # calculate area of a circle<\/span>\r\n area =<\/span> math.<\/span>pi *<\/span> radius *<\/span> radius\r\n return<\/span> area\r\n<\/pre>\n <\/p>\n
Also, let’s say we have a list of radii as:
\n<\/p>\n
<\/p>\n
radii =<\/span> [4<\/span>, 5.2<\/span>, 9<\/span>, 10<\/span>, 3<\/span>,8<\/span>, 6<\/span>, 7.5<\/span>]\r\n<\/pre>\n <\/p>\n
To calculate the areas of circle with these radii, we can loop through the list of radii and call the calculatearea() function for each of the radii.<\/p>\n
The code to do this is show below.<\/p>\n
<\/p>\n
<\/p>\n
areas =<\/span> []\r\nfor<\/span> radius in<\/span> radii:\r\n area =<\/span> calculatearea(radius)\r\n areas.<\/span>append(area)\r\n\r\nprint<\/span>(areas)\r\n<\/pre>\n <\/p>\n
This method above is fine and good. However, we can do the same thing with a single line of code. In this case, we use the map function.<\/p>\n
To do that, you simply call the map function, and provide the name of the function followed by the list of radii. This is shown below:<\/p>\n
<\/p>\n
<\/p>\n
areas =<\/span> map<\/span>(calculatearea, radii)\r\n\r\nprint<\/span>(list<\/span>(areas))\r\n<\/pre>\n <\/p>\n
You will notice that in the second line, we cast the output areas to a list. This is because the map function returns a map object.<\/p>\n
<\/p>\n
2. filter<\/h3>\n
You can use the filter function to filter a list. This like filtering out the data you do not need. So you can select certain data from the list based on some criteria.
\nAssuming you have a list of scores. Now, you will like to filter out scores below average. Let’s write do this the normal way. Then we also do it using the filter function. Here we assume that for a list of scores, 50 is the average score.<\/p>\n
<\/p>\n
newscores =<\/span> [] # holds scores above average<\/span>\r\n\r\nfor<\/span> score in<\/span> scores:\r\n if<\/span> isaboveaverage(score):\r\n \r\n # if score is above average, add it to newscores<\/span>\r\n newscores.<\/span>append(score)\r\n \r\nscores =<\/span> [45<\/span>, 70<\/span>, 94.2<\/span>, 75<\/span>, 51<\/span>, 49<\/span>, 35.1<\/span>]\r\n\r\nprint<\/span>(newscores)\r\n<\/pre>\n <\/p>\n
Again we can do this using the filter function. The code is given below:<\/p>\n
<\/p>\n
<\/p>\n
newscores =<\/span> filter<\/span>(isaboveaverage, scores)\r\nprint<\/span>(list<\/span>(newscores))\r\n<\/pre>\n <\/p>\n
Also, don’t forget that the output is converted back to list using the list function. This is because, the output of a filter function is a filter object. If you want to see what a filter object looks like, then first print it without converting.<\/p>\n
<\/p>\n
Filtering out missing data<\/strong><\/p>\nOne area you can use the filter function is to filter out missing data in a dataset. For example, the list below contains names of students with some missing values.<\/p>\n
<\/p>\n
students =<\/span> [\"Jadon\"<\/span>, \"Solace\"<\/span>, \"\"<\/span> \"Treasure\"<\/span>, \"\"<\/span>, \"\"<\/span>, \"Onyx\"<\/span>, \"Booboo\"<\/span>]\r\n<\/pre>\n <\/p>\n
If you print this list, it would include the missing values. This is not desirable. To filter out this missing values, you can use the filter function. In this case, you pass in None<\/em> as the first parameter.<\/p>\nThis is shown below:<\/p>\n
<\/p>\n
<\/p>\n
newStudents =<\/span> filter<\/span>(None<\/span>, students)\r\n\r\nprint<\/span>(list<\/span>(newStudents))\r\n<\/pre>\n <\/p>\n
I recommend you try out all these yourself to see how it works. Maybe you can change up the dataset.<\/p>\n
<\/p>\n
3. reduce<\/h3>\n
You use this this function to find some kind of aggregate of a list of item. The reduce function is a bit difference that the previous two. And you probably would not need to use if much. This is because, a loop tends to be better.<\/p>\n
<\/p>\n
Now this is how it works:<\/p>\n
It takes a sequence of items and applies a function to each item cumulatively. That means that it first applies the function to the first two items, then it applies the function to this result and the third item, then this result and the fourth item and so on. It continues until it reaches the last item.<\/p>\n
This is illustrated below<\/p>\n
<\/p>\n
![\"Map,](\"https:\/\/www.kindsonthegenius.com\/python\/wp-content\/uploads\/sites\/8\/2019\/02\/Map-Filter-and-Reduce.jpg\")
<\/p>\n
Let’s take for example, finding the product of all numbers in a list. However, we need to first import the reduce<\/em> function from the functools<\/em> module.<\/p>\n <\/p>\n
<\/p>\n
from<\/span> functools<\/span> import<\/span> reduce\r\n\r\ndata =<\/span> [3<\/span>, 5<\/span>, 3<\/span>, 1.2<\/span>, 2.6<\/span>, 3.5<\/span>, 1<\/span>]\r\n\r\nproduct =<\/span> lambda<\/span> x, y: x*<\/span>y\r\n\r\nresult =<\/span> reduce(product, data)\r\n<\/pre>\nWatch the Video<\/strong>
\n