Elements of Functional Programming in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Elements of Functional Programming in Python\n",
    "Learn how to how to use the lambda, map, filter and reduce functions in Python to transform data structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides features like lambda, filter, map, and reduce that can basically cover most of what you would need to know about Functional Programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For detailed analysis, please see the accompanying blog titled:**[Elements of Functional Programming in Python](https://medium.com/p/1b295ea5bbe0/edit)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Lambda Expression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda expressions - also known as \"anonymous functions\" - allow us to create and use a function in a single line. They are useful when we need a short function that will be used only once. \n",
    "\n",
    "They are mostly used in conjunction with the map, filter and the sort methods, which we will see later in the article.\n",
    "\n",
    "Let's write a function in Python, that will compute the value of 5x + 2. The standard approach would be to define a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    \"\"\"Function to compute the value of 5x+2\"\"\"\n",
    "    return 5*x+2\n",
    "f(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we would compute the same expression using Lambda functions. To create a lambda expression, we type in the keyword **lambda**, followed by the inputs. Next, we enter a colon followed by the expression that will be the return value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x)>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda x: 5*x+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This lambda function will take the input x and return 5x + 2, just like the earlier function f. There is a problem, however.The **lambda** is not the name of the function. It is a Python keyword that says - what follows is an anonymous function. So how do we use it? One way is to give it a name.\n",
    "Let us call this lambda expression **g**. Now, you can use this like any other function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = lambda x: 5*x+2\n",
    "g(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda expression with multiple inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.215646837627989"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating Harmonic Mean using lambda function\n",
    "harmonic_mean = lambda x,y,z : 3/(1/x + 1/y + 1/z)**0.5\n",
    "harmonic_mean(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda expression without inputs.\n",
    "let's look at a common use of Lambda function where we do not assign it a name. Let's say we have a list of the first seven U.S Presidents and we'd like to sort this list by their last name. We shall create a Lambda function that extracts the last name, and uses that as the sorting value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sorting a List by thr last name using lambda expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['John Adams',\n",
       " 'John Quincy Adams',\n",
       " 'Andrew Jackson',\n",
       " 'Thomas Jefferson',\n",
       " 'James Madison',\n",
       " 'James Monroe',\n",
       " 'George Washington']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "presidents_usa = [\"George Washington\", \"John Adams\",\"Thomas Jefferson\",\"James Madison\",\"James Monroe\",\"John Quincy Adams\",\"Andrew Jackson\"]\n",
    "\n",
    "presidents_usa.sort(key = lambda name: name.split(\" \")[-1].lower())\n",
    "presidents_usa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Map Function\n",
    "\n",
    "The **map** function applies a function to every item of iterable, yielding the results. When used with lists, Map transforms a given list into a new list by applying the function to all the items in an input_list.\n",
    "\n",
    "### Syntax\n",
    "```\n",
    "map(function_to_apply, iterables)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage\n",
    "Suppose we have a function that computes the volume of a cube, given the value of its edge(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def volume(a):\n",
    "    \"\"\"volumne of a cube with edge 'a'\"\"\"\n",
    "    return a**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we need to compute the volumes for many different cubes with different edge lengths? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Edge length in cm\n",
    "edges = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two ways to do this. One by using the `direct method` and the other by using the `map` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 27, 64, 125]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the volume of given cubes using Direct Method\n",
    "\n",
    "volumes = []\n",
    "for a in edges:\n",
    "    v = volume(a)\n",
    "    volumes.append(v)\n",
    "    \n",
    "    \n",
    "volumes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see how we can accomplish this task using a single line of code with the map function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x10e9aa9b0>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calculating the volume of given cubes using the Map function\n",
    "\n",
    "map(volume,edges)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The map function takes in two arguments. \n",
    "The first is a function, and the second is your list, tuple, or any other iterable object. Here, the map function applies the volume function to each element in the list. \n",
    "\n",
    "However, an important thing to note here is that the output of the map function is not a list but a map object, which is actually an iterator over the results. We can, however, turn this into a list by passing the map to the list constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 27, 64, 125]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(volume,edges))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now see an example which demonstrates the use of `lambda` function with the `map` function. We have a list of tuples containing name and heights for 5 people. Each of the height is in centimeters and we need to convert it into feet.\n",
    "\n",
    "We will first write a converter function using a lambda expression which will accept a tuple as the input and will return a tuple with the same name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Tom', 6.0),\n",
       " ('Daisy', 5.6),\n",
       " ('Margaret', 5.9),\n",
       " ('Michael', 6.2),\n",
       " ('Nick', 5.4)]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert height from cms to feet : 1 cm = 0.0328 feet\n",
    "height_in_cms = [('Tom',183),('Daisy',171),('Margaret',179),('Michael',190),('Nick',165)]\n",
    "\n",
    "#Writing Convertor function using lambda expression\n",
    "height_in_feet = lambda data: (data[0],round(data[1]*0.0328,1))\n",
    "\n",
    "#Using the 'Map' function\n",
    "list(map(height_in_feet,height_in_cms))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Filter Function\n",
    "\n",
    "The `filter` function constructs an iterator from those elements of iterable for which function returns true. This means filter function is used to select certain pieces of data from a list, tuple, or other collection of data, hence the name.\n",
    "\n",
    "### Syntax\n",
    "\n",
    "```\n",
    "filter(filter(function, iterable)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage\n",
    "\n",
    "Let's see an example where we want to get the list of all numbers that are greater than 5, from a given input list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 7, 8, 9]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Filter out all the numbers greater than 5 from a list\n",
    "\n",
    "my_list = [1,2,3,4,5,6,7,8,9]\n",
    "output_list = filter(lambda x : x>5, my_list)\n",
    "\n",
    "list(output_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a list containing some of the countries in Asia. Notice there are numerous strings that are empty. We'll use the filter function to remove these missing values. We'll simply pass none as the first argument and the second argument is the list of data as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Afghanistan', 'Bhutan', 'China', 'Georgia', 'India']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Removing missing values from a list\n",
    "\n",
    "countries_asia = [\"Afghanistan\",\"\",\"Bhutan\",\"\",\"China\",\"\",\"Georgia\",\"\",\"\",\"India\"]\n",
    "\n",
    "list(filter(None,countries_asia))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This filters out all values that are treated as false in a boolean setting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Reduce Function\n",
    "\n",
    "The `Reduce` function is a bit unusual and in fact, as of Python 3, it is no longer a built-in function. Instead, it has been moved to the functools module. \n",
    "\n",
    "The 'reduce' function transforms a given list into a single value by applying a function cumulatively to the items of sequence, from left to right,\n",
    "\n",
    "### Syntax\n",
    "\n",
    "```\n",
    "reduce(func, seq)\n",
    "```\n",
    "where reduce continually applies the function func() to the sequence seq and returns a single value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage\n",
    "Let's illustrate the working of the reduce function with the help of a simple example that computes the product of a list of integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute the product of a list of integers using 'reduce'function\n",
    "\n",
    "from functools import reduce\n",
    "product = reduce((lambda x,y : x*y), [1,2,3,4,5])\n",
    "\n",
    "product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following diagram shows the intermediate steps of the calculation:\n",
    "![](https://cdn-images-1.medium.com/max/800/1*tFi8CEmD3eAPwP3_nHWaTg.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above program can also be written with an explicit for loop which is more clear.Hence Use functools.reduce if you really need it\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute the product of a list of integers using a 'For' loop\n",
    "\n",
    "product = 1\n",
    "list = [1,2,3,4,5]\n",
    "for num in list:\n",
    "    product = product*num\n",
    "    \n",
    "product    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "The `reduce` function can determine the maximum of a list containing integers in a single line of code. There does exist a built-in function called `max()` in Python which is normally used for this purpose as `max(list_name)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "698"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Determining the maximum number in a given list\n",
    "\n",
    "from functools import reduce\n",
    "f = lambda a,b : a if (a>b) else b\n",
    "reduce(f,[58,69,12,158,698])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions: Alternative to map, filter and reduce\n",
    "\n",
    "**List comprehension** is a way to define and create lists in Python. in most cases, list comprehensions let us create lists in a single line of code without worrying about initializing lists or setting up loops.\n",
    "It is also a substitute for the lambda function as well as the functions `map()`, `filter()` and `reduce()`. Some people find it a more pythonic way of writing functions and find it easier to understand."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a list of squares of first 10 numbers using loops \n",
    "\n",
    "squares = []\n",
    "for x in range(10):\n",
    "    squares.append(x**2)\n",
    "    \n",
    "squares    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's use list comprehension to achieve the same result in a one liner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# # Creating a list of squares of first 10 using list comprehension\n",
    "\n",
    "squares = [x**2 for x in range(10)]\n",
    "squares\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try and replicate the examples used in the above sections with list comprehensions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions vs Map function\n",
    "\n",
    "We used map function in conjunction with the lambda function to convert a list of heights from cm to feet. Let's use list comprehensions to achieve the same results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Tom', 6.0),\n",
       " ('Daisy', 5.6),\n",
       " ('Margaret', 5.9),\n",
       " ('Michael', 6.2),\n",
       " ('Nick', 5.4)]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Convert height from cms to feet using List Comprehension : 1 cm = 0.0328 feet\n",
    "height_in_cms = [('Tom',183),('Daisy',171),('Margaret',179),('Michael',190),('Nick',165)]\n",
    "\n",
    "height_in_feet = [(height[0],round(height[1]*0.0328,1)) for height in height_in_cms]\n",
    "\n",
    "height_in_feet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions vs Filter function\n",
    "\n",
    "We used the filter function to remove the missing values from a list of Asian countries. Let's use list comprehensions to get the same results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Afghanistan', 'Bhutan', 'China', 'Georgia', 'India']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Removing missing values from a list\n",
    "\n",
    "countries_asia = [\"Afghanistan\",\"\",\"Bhutan\",\"\",\"China\",\"\",\"Georgia\",\"\",\"\",\"India\"]\n",
    "[country for country in countries_asia if country!=\"\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions vs Reduce function\n",
    "\n",
    "Similarly, we can determine the maximum of a list containing integers easily using generator comprehension instead of using lambda and reduce. Generator expression are similar to list comprehension but with round brackets instead of the square one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "956"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Determining the maximum number in a given list\n",
    "\n",
    "numbers = [58,69,12,158,698,956]\n",
    "max((x) for x in numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "* [Don't Be Scared Of Functional Programming](https://www.smashingmagazine.com/2014/07/dont-be-scared-of-functional-programming/)\n",
    "* [Functional Programming HOWTO](https://docs.python.org/3.7/howto/functional.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}