006_Python_Function_Anonymous.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Functions** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/04_Python_Functions)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Anonymous/**`lambda`** Function\n",
    "\n",
    "In this class, you'll learn about the anonymous function, also known as **`lambda`** functions. You'll learn what they are, their syntax and how to use them (with examples)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What are **`lambda`** functions in Python?\n",
    "\n",
    "In Python, an anonymous function is a **[function](https://github.com/milaan9/04_Python_Functions/blob/main/001_Python_Functions.ipynb)** that is defined without a name.\n",
    "\n",
    "While normal functions are defined using the **`def`** keyword in Python, anonymous functions are defined using the **`lambda`** keyword.\n",
    "\n",
    "In opposite to a normal function, a Python **`lambda`** function is a single expression. But, in a lambda body, we can expand with expressions over multiple lines using parentheses **`()`** or a multiline string **`\"\"\" \"\"\"`**.\n",
    "\n",
    "For example: **`lambda n:n+n`**\n",
    "\n",
    "The reason behind the using anonymous function is for instant use, that is, one-time usage and the code is very concise so that there is more readability in the code.\n",
    "\n",
    "Hence, anonymous functions are also called **`lambda`** functions.\n",
    "\n",
    "* Lambda forms can take any number of arguments but return just one value in the form of an expression. They cannot contain commands or multiple expressions.\n",
    "\n",
    "* An anonymous function cannot be a direct call to print because **lambda** requires an expression. \n",
    "\n",
    "* **`lambda`** functions have their own local namespace and cannot access variables other than those in their parameter list and those in the global namespace. \n",
    "\n",
    "* Although it appears that lambdas are a one-line version of a function, they are not equivalent to inline statements in C or C++, whose purpose is to stack allocation by passing function, during invocation for performance reasons.\n",
    "\n",
    "**Syntax:** \n",
    "\n",
    "```python\n",
    "lambda argument_list: expression\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s see an example to print even numbers without a **`lambda`** function and with a **`lambda`** function. See the difference in line of code as well as readability of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:39.033426Z",
     "start_time": "2021-06-13T16:39:39.014872Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Even numbers are: [10, 16, 78, 2]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Program for even numbers without lambda function\n",
    "\n",
    "def even_numbers(nums):\n",
    "    even_list = []\n",
    "    for n in nums:\n",
    "        if n % 2 == 0:\n",
    "            even_list.append(n)\n",
    "    return even_list\n",
    "\n",
    "num_list = [10, 9, 16, 78, 2, 3, 7, 1]\n",
    "ans = even_numbers(num_list)\n",
    "print(\"Even numbers are:\", ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:39.494358Z",
     "start_time": "2021-06-13T16:39:39.474831Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Even numbers are:  [10, 16, 78, 2]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Program for even number with a lambda function\n",
    "\n",
    "l = [10, 9, 16, 78, 2, 3, 7, 1]\n",
    "even_nos = list(filter(lambda x: x % 2 == 0, l))\n",
    "print(\"Even numbers are: \", even_nos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:39.879120Z",
     "start_time": "2021-06-13T16:39:39.860569Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Program to show the use of lambda functions\n",
    "\n",
    "double = lambda x: x * 2\n",
    "\n",
    "print(double(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In the above program, lambda **`x: x * 2`** is the lambda function. Here **`x`** is the argument and **`x * 2`** is the expression that gets evaluated and returned.\n",
    "\n",
    "This function has no name. It returns a function object which is assigned to the identifier **`double`**. We can now call it as a normal function. The statement\n",
    "\n",
    "```python\n",
    ">>> double = lambda x: x * 2\n",
    "```\n",
    "\n",
    "is nearly the same as:\n",
    "\n",
    "```python\n",
    ">>> def double(x):\n",
    ">>>     return x * 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:40.863492Z",
     "start_time": "2021-06-13T16:39:40.847866Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square of number is 100\n",
      "Square of number is 4\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Normal Function definition is here\n",
    "\n",
    "def square(x):\n",
    "    return x*x\n",
    "\n",
    "# anonymous function\n",
    "sqr = lambda x: x*x\n",
    "\n",
    "#Calling square function\n",
    "print(\"Square of number is\",square(10)) #call normal function\n",
    "print(\"Square of number is\",sqr(2)) #call anonymous function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use of **`lambda`** Function in python\n",
    "\n",
    "We use **`lambda`** function when we require a nameless function for a short period of time.\n",
    "\n",
    "In Python, we generally use it as an argument to a higher-order function (a function that takes in other functions as **[arguments](https://github.com/milaan9/04_Python_Functions/blob/main/004_Python_Function_Arguments.ipynb)**). **`lambda`** function are used along with built-in functions like **`filter()`**, **`map()`**, **`reduce()`** etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `lambda` function use with `filter()`\n",
    "\n",
    "The **`filter()`** function in Python takes in a function and a list as arguments.\n",
    "\n",
    "The function is called with all the items in the list and a new list is returned which contains items for which the function evaluates to **`True`**.\n",
    "\n",
    "Here is an example use of **`filter()`** function to filter out only even numbers from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:42.617383Z",
     "start_time": "2021-06-13T16:39:42.602735Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Even numbers are:  [4, 6, 8, 12]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Program to filter out only the even items from a list\n",
    "\n",
    "my_list = [1, 5, 4, 6, 8, 11, 3, 12]  # total 8 elements\n",
    "\n",
    "new_list = list(filter(lambda x: (x%2 == 0), my_list)) # returns the output in form of a list\n",
    "\n",
    "print(\"Even numbers are: \", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:43.496282Z",
     "start_time": "2021-06-13T16:39:43.478704Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive numbers are:  [5, 12, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "l = [-10, 5, 12, -78, 6, -1, -7, 9]\n",
    "positive_nos = list(filter(lambda x: x > 0, l))\n",
    "print(\"Positive numbers are: \", positive_nos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `lambda` function with `map()`\n",
    "\n",
    "The **`map()`** function in Python takes in a function and a list.\n",
    "\n",
    "The function is called with all the items in the list and a new list is returned which contains items returned by that function for each item.\n",
    "\n",
    "Here is an example use of **`map()`** function to double all the items in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:45.093927Z",
     "start_time": "2021-06-13T16:39:45.078304Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Double values are:  [2, 10, 8, 12, 16, 22, 6, 24]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Program to double each item in a list using map()\n",
    "\n",
    "my_list = [1, 5, 4, 6, 8, 11, 3, 12]  # total 8 elements\n",
    "new_list = list(map(lambda x: x * 2, my_list)) # returns the output in form of a list\n",
    "print(\"Double values are: \", new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:45.524588Z",
     "start_time": "2021-06-13T16:39:45.512870Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cube values are: [8, 27, 64, 512, 729]\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "list1 = [2, 3, 4, 8, 9]\n",
    "list2 = list(map(lambda x: x*x*x, list1))\n",
    "print(\"Cube values are:\", list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `lambda` function with `reduce()`\n",
    "\n",
    "The **`reduce()`** function is used to minimize sequence elements into a single value by applying the specified condition.\n",
    "\n",
    "The **`reduce()`** function is present in the **`functools`** module; hence, we need to import it using the import statement before using it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-13T16:39:46.968912Z",
     "start_time": "2021-06-13T16:39:46.960127Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition of all list elements is :  54\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "from functools import reduce\n",
    "list1 = [20, 13, 4, 8, 9]\n",
    "add = reduce(lambda x, y: x+y, list1)\n",
    "print(\"Addition of all list elements is : \", add)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "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": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "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": 2
}