003_Python_Closure.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Advanced Topics** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/07_Python_Advanced_Topics)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Closures\n",
    "\n",
    "In this class, you'll learn about Python closure, how to define a closure, and the reasons you should use it.\n",
    "\n",
    "Before understand Python Closure let us try to understand first **Higher Order Functions**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Higher Order Functions\n",
    "\n",
    "In Python functions are treated as first class citizens, allowing you to perform the following operations on functions:\n",
    "\n",
    "- A function can take one or more functions as parameters\n",
    "- A function can be returned as a result of another function\n",
    "- A function can be modified\n",
    "- A function can be assigned to a variable\n",
    "\n",
    "In this sub-section, we will cover:\n",
    "\n",
    "1. Handling functions as parameters\n",
    "2. Returning functions as return value from another functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function as a Parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:06.599037Z",
     "start_time": "2021-10-18T07:33:06.586340Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "def sum_numbers(nums):  # normal function\n",
    "    return sum(nums)    # a sad function abusing the built-in sum function :<\n",
    "\n",
    "def higher_order_function(f, lst):  # function as a parameter\n",
    "    summation = f(lst)\n",
    "    return summation\n",
    "result = higher_order_function(sum_numbers, [1, 2, 3, 4, 5])\n",
    "print(result)       # 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function as a Return Value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:06.752357Z",
     "start_time": "2021-10-18T07:33:06.610758Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "27\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def square(x):          # a square function\n",
    "    return x ** 2\n",
    "\n",
    "def cube(x):            # a cube function\n",
    "    return x ** 3\n",
    "\n",
    "def absolute(x):        # an absolute value function\n",
    "    if x >= 0:\n",
    "        return x\n",
    "    else:\n",
    "        return -(x)\n",
    "\n",
    "def higher_order_function(type): # a higher order function returning a function\n",
    "    if type == 'square':\n",
    "        return square\n",
    "    elif type == 'cube':\n",
    "        return cube\n",
    "    elif type == 'absolute':\n",
    "        return absolute\n",
    "\n",
    "result = higher_order_function('square')\n",
    "print(result(3))       # 9\n",
    "result = higher_order_function('cube')\n",
    "print(result(3))       # 27\n",
    "result = higher_order_function('absolute')\n",
    "print(result(-3))      # 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see from the above example that the higher order function is returning different functions depending on the passed parameter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nonlocal variable in a nested function\n",
    "\n",
    "Before getting into what a closure is, we have to first understand what a nested function and nonlocal variable is.\n",
    "\n",
    "A function defined inside another function is called a nested function. Nested functions can access variables of the enclosing scope.\n",
    "\n",
    "In Python, these non-local variables are read-only by default and we must declare them explicitly as non-local (using **[nonlocal keyword](https://github.com/milaan9/01_Python_Introduction/blob/main/Python_Keywords_List.ipynb)**) in order to modify them.\n",
    "\n",
    "Following is an example of a nested function accessing a non-local variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:06.892983Z",
     "start_time": "2021-10-18T07:33:06.758218Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def print_msg(msg):\n",
    "    # This is the outer enclosing function\n",
    "\n",
    "    def printer():\n",
    "        # This is the nested function\n",
    "        print(msg)\n",
    "\n",
    "    printer()\n",
    "\n",
    "# We execute the function\n",
    "# Output: Hello\n",
    "print_msg(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the nested **`printer()`** function was able to access the non-local **`msg`** variable of the enclosing function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a Closure Function\n",
    "\n",
    "Python allows a nested function to access the outer scope of the enclosing function. This is is known as a Closure. Let us have a look at how closures work in Python. In Python, closure is created by nesting a function inside another encapsulating function and then returning the inner function.\n",
    "\n",
    "In the example above, what would happen if the last line of the function **`print_msg()`** returned the **`printer()`** function instead of calling it? This means the function was defined as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:06.998455Z",
     "start_time": "2021-10-18T07:33:06.901774Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def print_msg(msg):\n",
    "    # This is the outer enclosing function\n",
    "\n",
    "    def printer():\n",
    "        # This is the nested function\n",
    "        print(msg)\n",
    "\n",
    "    return printer  # returns the nested function\n",
    "\n",
    "\n",
    "# Now let's try calling this function.\n",
    "# Output: Hello\n",
    "another = print_msg(\"Hello\")\n",
    "another()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's unusual."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **`print_msg()`** function was called with the string **`\"Hello\"`** and the returned function was bound to the name **`another`**. On calling **`another()`**, the message was still remembered although we had already finished executing the **`print_msg()`** function.\n",
    "\n",
    "This technique by which some data (\"**`\"Hello\"`** in this case) gets attached to the code is called **closure in Python**.\n",
    "\n",
    "This value in the enclosing scope is remembered even when the variable goes out of scope or the function itself is removed from the current namespace.\n",
    "\n",
    "Try running the following in the Python shell to see the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:07.150794Z",
     "start_time": "2021-10-18T07:33:07.017006Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "del print_msg\n",
    "another()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:07.862712Z",
     "start_time": "2021-10-18T07:33:07.153726Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'print_msg' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-af0f59439c9b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint_msg\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Hello\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'print_msg' is not defined"
     ]
    }
   ],
   "source": [
    "print_msg(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the returned function still works even when the original function was deleted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## When do we have closures?\n",
    "\n",
    "As seen from the above example, we have a closure in Python when a nested function references a value in its enclosing scope.\n",
    "\n",
    "The criteria that must be met to create closure in Python are summarized in the following points.\n",
    "\n",
    "1. We must have a nested function (function inside a function).\n",
    "2. The nested function must refer to a value defined in the enclosing function.\n",
    "3. The enclosing function must return the nested function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## When to use closures?\n",
    "\n",
    "So what are closures good for?\n",
    "\n",
    "Closures can avoid the use of global values and provides some form of data hiding. It can also provide an object oriented solution to the problem.\n",
    "\n",
    "When there are few methods (one method in most cases) to be implemented in a class, closures can provide an alternate and more elegant solution. But when the number of attributes and methods get larger, it's better to implement a class.\n",
    "\n",
    "Here is a simple example where a closure might be more preferable than defining a class and making objects. But the preference is all yours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:13.293885Z",
     "start_time": "2021-10-18T07:33:13.281190Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n",
      "15\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "def make_multiplier_of(n):\n",
    "    def multiplier(x):\n",
    "        return x * n\n",
    "    return multiplier\n",
    "\n",
    "\n",
    "# Multiplier of 3\n",
    "times3 = make_multiplier_of(3)\n",
    "\n",
    "# Multiplier of 5\n",
    "times5 = make_multiplier_of(5)\n",
    "\n",
    "\n",
    "print(times3(9))  # Output: 27\n",
    "\n",
    "print(times5(3))  # Output: 15\n",
    "\n",
    "print(times5(times3(2)))  # Output: 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:14.004822Z",
     "start_time": "2021-10-18T07:33:13.984320Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "20\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "def add_ten():\n",
    "    ten = 10\n",
    "    def add(num):\n",
    "        return num + ten\n",
    "    return add\n",
    "\n",
    "closure_result = add_ten()\n",
    "print(closure_result(5))  # 15\n",
    "print(closure_result(10))  # 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[Python Decorators](https://github.com/milaan9/07_Python_Advanced_Topics/blob/main/004_Python_Decorators.ipynb)** make an extensive use of closures as well.\n",
    "\n",
    "On a concluding note, it is good to point out that the values that get enclosed in the closure function can be found out.\n",
    "\n",
    "All function objects have a **`__closure__`** attribute that returns a tuple of cell objects if it is a closure function. Referring to the example above, we know **`times3`** and **`times5`** are closure functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:15.157170Z",
     "start_time": "2021-10-18T07:33:15.128852Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<cell at 0x0000012C87C0AF70: int object at 0x00007FFAD7CB2770>,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_multiplier_of.__closure__\n",
    "times3.__closure__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell object has the attribute cell_contents which stores the closed value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:16.187448Z",
     "start_time": "2021-10-18T07:33:16.167921Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "times3.__closure__[0].cell_contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:33:16.789013Z",
     "start_time": "2021-10-18T07:33:16.767533Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "times5.__closure__[0].cell_contents"
   ]
  },
  {
   "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": 4
}