tutorials/Lambda, map, filter and reduce functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Introduction\" data-toc-modified-id=\"Introduction-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Introduction</a></span></li><li><span><a href=\"#The-link-with-functional-programming\" data-toc-modified-id=\"The-link-with-functional-programming-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>The link with functional programming</a></span></li><li><span><a href=\"#What-is-a-lambda-function?\" data-toc-modified-id=\"What-is-a-lambda-function?-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>What is a <code>lambda</code> function?</a></span></li><li><span><a href=\"#map-function\" data-toc-modified-id=\"map-function-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span><code>map</code> function</a></span><ul class=\"toc-item\"><li><span><a href=\"#Map-vs.-list-comprehension\" data-toc-modified-id=\"Map-vs.-list-comprehension-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span><code>Map</code> vs. list comprehension</a></span></li></ul></li><li><span><a href=\"#filter-function\" data-toc-modified-id=\"filter-function-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span><code>filter</code> function</a></span><ul class=\"toc-item\"><li><span><a href=\"#filter-vs.-list-comprehension\" data-toc-modified-id=\"filter-vs.-list-comprehension-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span><code>filter</code> vs. list comprehension</a></span></li></ul></li><li><span><a href=\"#reduce\" data-toc-modified-id=\"reduce-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span><code>reduce</code></a></span><ul class=\"toc-item\"><li><span><a href=\"#reduce-vs.-list-comprehension\" data-toc-modified-id=\"reduce-vs.-list-comprehension-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span><code>reduce</code> vs. list comprehension</a></span></li></ul></li><li><span><a href=\"#References\" data-toc-modified-id=\"References-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>References</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<font color=black>\n",
    "\n",
    "**What?** Lambda, map and filter functions\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The link with functional programming\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- `map`, `filter` and `reduce` are all example of functional programming in python.\n",
    "- **Definition #1** style of programming in which functions are treated and manipulated as objects, i.e. functions can be assigned to variables, they can be passed as arguments, and they can be stored in containers along with other data. We can write parallel code that works by running lots of functions in parallel on large amounts of data.\n",
    "- **Definition #2** when you build your applications completely out of pure functions. Pure Function: Its return value is determined exclusively by it's arguments.\n",
    "\n",
    "- **Why would you want to use them?** It’s much simpler, it improves maintainability, we can define extremely complex functions easily, it provides modularity and is shorter. It makes parallelisation much easier. \n",
    "    \n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is a `lambda` function?\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- `lambda` returns a function object which can be assigned to any variable.\n",
    "- `lambda` functions are passed as parameters to functions that expect function object as parameters such as `map`, `reduce`, and `filter` functions. So, you will often see `lambda` used in combination with those functions.\n",
    "- Lambda functions are single-expression  functions that **are not necessarily** bound to a name (they can be anonymous). \n",
    "- Lambda functions can't use regular Python statements and always include an implicit `return` statement.\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.228507Z",
     "start_time": "2023-01-13T18:00:38.225947Z"
    }
   },
   "outputs": [],
   "source": [
    "# Can we achieve something like this in a different way?\n",
    "def add(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.239808Z",
     "start_time": "2023-01-13T18:00:38.230424Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x, y)>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda x, y: x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.246026Z",
     "start_time": "2023-01-13T18:00:38.242483Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add = lambda x, y: x + y\n",
    "add(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.250889Z",
     "start_time": "2023-01-13T18:00:38.247656Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x, y)>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The same type is being printed here as well\n",
    "add"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- **So why would you ever want to use such a thing?** Primarily, it comes down to the fact that *everything is an object* in Python, even functions themselves!\n",
    "- That means that functions can be passed as arguments to functions.\n",
    "- As an example of this, suppose we have some data stored in a list of dictionaries:\n",
    "    \n",
    "\n",
    "</font>\n",
    "</div>    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.255510Z",
     "start_time": "2023-01-13T18:00:38.252705Z"
    }
   },
   "outputs": [],
   "source": [
    "data = [{'first':'Guido', 'last':'Van Rossum', 'YOB':1956},\n",
    "        {'first':'Grace', 'last':'Hopper',     'YOB':1906},\n",
    "        {'first':'Alan',  'last':'Turing',     'YOB':1912}]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.260356Z",
     "start_time": "2023-01-13T18:00:38.257383Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Guido'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[0][\"first\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now suppose we want to sort this data.\n",
    "Python has a ``sorted`` function that does this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.265103Z",
     "start_time": "2023-01-13T18:00:38.261937Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted([2,4,3,5,1,6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- But dictionaries are not orderable: we need a way to tell the function *how* to sort our data.\n",
    "- We can do this by specifying the ``key`` function, a function which given an item returns the sorting key for that item: \n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.270472Z",
     "start_time": "2023-01-13T18:00:38.266905Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'first': 'Alan', 'last': 'Turing', 'YOB': 1912},\n",
       " {'first': 'Grace', 'last': 'Hopper', 'YOB': 1906},\n",
       " {'first': 'Guido', 'last': 'Van Rossum', 'YOB': 1956}]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sort alphabetically by first name\n",
    "sorted(data, key = lambda item: item['first'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.278312Z",
     "start_time": "2023-01-13T18:00:38.274042Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'first': 'Grace', 'last': 'Hopper', 'YOB': 1906},\n",
       " {'first': 'Alan', 'last': 'Turing', 'YOB': 1912},\n",
       " {'first': 'Guido', 'last': 'Van Rossum', 'YOB': 1956}]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sort by year of birth\n",
    "sorted(data, key = lambda item: item['YOB'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `map` function\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- `map()` is a built-in function that allows you to process and transform all the items in an iterable without using an explicit for loop.\n",
    "- This technique is called **mapping**, hence the name.\n",
    "- `map()` is useful when you need to apply a transformation function to each item in an iterable and transform them **into a new iterable**.\n",
    "- `map()` is one of the tools that support a functional programming style in Python.\n",
    "- The structure is the following: `map(function_object, iterable1, iterable2, ....)`\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.283362Z",
     "start_time": "2023-01-13T18:00:38.280692Z"
    }
   },
   "outputs": [],
   "source": [
    "def multiplyByTwo(x):\n",
    "    return x*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.289228Z",
     "start_time": "2023-01-13T18:00:38.285180Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x7fd465718640>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return another iterable\n",
    "map(multiplyByTwo, [1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.295526Z",
     "start_time": "2023-01-13T18:00:38.291213Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check if it really returns an iterable\n",
    "hasattr(map(multiplyByTwo, [1,2,3,4]), '__iter__')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.301485Z",
     "start_time": "2023-01-13T18:00:38.297872Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(multiplyByTwo, [1,2,3,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.307236Z",
     "start_time": "2023-01-13T18:00:38.303204Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3, 4, 1, 2, 3, 4], [5, 6, 7, 8, 5, 6, 7, 8]]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(multiplyByTwo, [[1,2,3,4], [5,6,7,8]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.312991Z",
     "start_time": "2023-01-13T18:00:38.309400Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can made the whole thing much shorter\n",
    "list(map(lambda x:x*2, [1,2,3,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.318994Z",
     "start_time": "2023-01-13T18:00:38.315150Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 1, 2], [2, 3, 2, 3]]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "b = [2, 3]\n",
    "list(map(multiplyByTwo, [a, b]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T14:54:44.020925Z",
     "start_time": "2023-04-01T14:54:44.018418Z"
    }
   },
   "source": [
    "## `Map` vs. list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- It seems to be a matter of preferences, and under certain conditions this is the case.\n",
    "- Here, we'd like to go a little deeper into the comparison.\n",
    "Specifically, we will look at three scenarios: \n",
    "    - list comprehensions\n",
    "    - `map()` with a predefined input function\n",
    "    - `map()` with an ad-hoc lambda function.\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T14:57:10.651292Z",
     "start_time": "2023-04-01T14:57:10.616476Z"
    }
   },
   "outputs": [],
   "source": [
    "# Definie an input list\n",
    "lst = list(range(1000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T14:57:48.419402Z",
     "start_time": "2023-04-01T14:57:42.268685Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "61.5 ms ± 3 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# list comprehension\n",
    "%timeit -r 10 -n 10 [i / 0.939276 for i in lst]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T14:58:21.086130Z",
     "start_time": "2023-04-01T14:58:21.083757Z"
    }
   },
   "outputs": [],
   "source": [
    "# predefined conversion function\n",
    "def eur_to_usd(x):\n",
    "    return x / 0.939276"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T14:58:47.627577Z",
     "start_time": "2023-04-01T14:58:39.352258Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "82.7 ms ± 4.68 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# map with predefined input function\n",
    "%timeit -r 10 -n 10 list(map(eur_to_usd, lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T14:59:15.308986Z",
     "start_time": "2023-04-01T14:59:06.330317Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "89.7 ms ± 4.25 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# map with lambda function\n",
    "%timeit -r 10 -n 10 list(map(lambda x: x / 0.939276, lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- **Simplicity and readability**: the list comprehension appears to be winning the race here. The programmer’s intention is immediately apparent and there’s no need to include any extra keywords or define additional functions. However, it’s worth noting that for more complex operations, separate transformation functions may need to be defined, which would take away some of the brownie points that list comprehensions generally receive for their readability.\n",
    "\n",
    "- **Performance**: list comprehensions are fastest, followed by `map()` with a predefined input function, and lastly `map()` with a `lambda` function. A `lambda` function gets called for each item in the input list, resulting in a computational overhead due to the creation and destruction of `lambda` function objects. Predefined functions, by contrast, are optimised and stored in memory, which leads to more efficient execution.\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `filter` function\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:25.570618Z",
     "start_time": "2023-01-13T18:00:25.565960Z"
    }
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- The `filter()` function expects two arguments: function_object and an iterable. \n",
    "- function_object returns a boolean value and is called for each element of the iterable. \n",
    "- `filter()` returns only those elements for which the function_object returns `True`.\n",
    "- Like the `map()` function, the `filter()` function also returns a list of elements.\n",
    "- Unlike `map()`, the `filter()` function can only have **one** iterable as input.\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.323317Z",
     "start_time": "2023-01-13T18:00:38.320828Z"
    }
   },
   "outputs": [],
   "source": [
    "list_a = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.329966Z",
     "start_time": "2023-01-13T18:00:38.326003Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<list_iterator at 0x7fd465723340>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is a quick way to know if it is iterable\n",
    "iter(list_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.335052Z",
     "start_time": "2023-01-13T18:00:38.331878Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<filter object at 0x7fd4657237c0>\n"
     ]
    }
   ],
   "source": [
    "filterObject = filter(lambda x: x%2 == 0.0, list_a)\n",
    "# This returns an object\n",
    "print(filterObject)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.339710Z",
     "start_time": "2023-01-13T18:00:38.336961Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "# To get the list use list\n",
    "filterObject = list(filterObject)\n",
    "print(filterObject)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-13T18:00:38.346079Z",
     "start_time": "2023-01-13T18:00:38.341988Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<function <lambda> at 0x7fd465728d30>, [1, 2, 3, 4, 5]]\n"
     ]
    }
   ],
   "source": [
    "# This is what happens if I do not use filter\n",
    "filterObject = lambda x: x%2 == 0.0, list_a\n",
    "even_num = list(filterObject)\n",
    "print(even_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `filter` vs. list comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T15:28:35.497848Z",
     "start_time": "2023-04-01T15:28:35.493420Z"
    }
   },
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- It seems to be a matter of preferences, and under certain conditions this is the case.\n",
    "- Here, we'd like to go a little deeper into the comparison.\n",
    "Specifically, we will look at three scenarios: \n",
    "    - list comprehensions\n",
    "    - `filter()` with a predefined input function\n",
    "    - `filter()` with an ad-hoc lambda function.\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T15:28:53.104878Z",
     "start_time": "2023-04-01T15:28:53.064815Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create an input list\n",
    "lst = list(range(1000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T15:29:09.041460Z",
     "start_time": "2023-04-01T15:29:03.806976Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52.3 ms ± 1.69 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# List comprehension\n",
    "%timeit -r 10 -n 10 [i for i in lst if i % 2 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T15:29:17.737330Z",
     "start_time": "2023-04-01T15:29:17.734655Z"
    }
   },
   "outputs": [],
   "source": [
    "# Predefined filter function\n",
    "def fil(x):\n",
    "    if x % 2 == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T15:29:39.300038Z",
     "start_time": "2023-04-01T15:29:31.519627Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "77.8 ms ± 1 ms per loop (mean ± std. dev. of 10 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Filter with predefined filter function\n",
    "%timeit -r 10 -n 10 list(filter(fil, lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-04-01T15:29:57.913593Z",
     "start_time": "2023-04-01T15:29:49.722365Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81.9 ms ± 719 µs per loop (mean ± std. dev. of 10 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Filter with lambda function\n",
    "%timeit -r 10 -n 10 list(filter(lambda x: x % 2 == 0, lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- **Readability** seems to be draw! List comprehensions are pretty easy to read and don’t require any predefined or ad-hoc functions or extra keywords. However, it has been argued that the use of the function filter() immediately gives away the programmer’s intent of, well, filtering something, perhaps more so than the list comprehension does. This is of course a highly subjective matter and will depend on the individual’s preferences and tastes.\n",
    "- **Performance**: list comprehensions are fastest, followed by filter() with a predefined filter function, and filter() with an ad-hoc lambda function comes in last. The reasons for this are the same mentioned for `map`.\n",
    "    \n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `reduce`\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<font color=black>\n",
    "\n",
    "- `reduce()` function doesn’t return a new sequence like `map()` and `filter()`. Instead, it returns a single value. The syntax is similar to the other two functions: `reduce(function, iterable)`\n",
    "- `reduce()` applies the function to the elements of the sequence, from left to right, starting with the first two elements in the sequence.\n",
    "- We combine the result of applying the function to the sequence’s first two elements with the third element and pass them to another call of the same function.\n",
    "- This process repeats until we reach the end of the iterable and the iterable reduces to a single value. \n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-01-25T13:37:15.192607Z",
     "start_time": "2023-01-25T13:37:15.187388Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "\n",
    "nums = [1, 3, 4, 1]\n",
    "# (((1*3)*4)*)1\n",
    "reduce(lambda x, y: x*y, nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<font color=black>\n",
    "\n",
    "- [Whirlwind Tour of Python](http://www.oreilly.com/programming/free/a-whirlwind-tour-of-python.csp)\n",
    "- https://medium.com/better-programming/lambda-map-and-filter-in-python-4935f248593 \n",
    "- [Python's `map()`: Processing Iterables Without a Loop](https://realpython.com/python-map-function/)\n",
    "- [`map` vs. `reduce`](https://www.udacity.com/blog/2020/12/our-guide-to-map-filter-and-reduce-functions-in-python.html)\n",
    "- [Comparing List Comprehensions vs. Built-In Functions in Python: Which Is Better?](https://towardsdatascience.com/comparing-list-comprehensions-vs-built-in-functions-in-python-which-is-better-1e2c9646fafe)\n",
    "    \n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "231px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}