Decorators - Seminar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color='red'>D E C O R A T O R S</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diptangsu Goswami\n",
    "### Computer Science and Engineering, 3<sup>rd</sup> Year"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are decorators?\n",
    "Decorators provide a simple syntax for calling higher-order functions.\n",
    "By definition, a decorator is a function that takes another function and extends the behaviour of the latter function without explicitly modifying it.\n",
    "\n",
    "In other words, if you have some function, and you want that function to do something extra for you, or you want a number of functions to do something extra for you, you'd use a decorator to extend what the function is capable of doing. You're decorating an already defined function to do something extra.\n",
    "\n",
    "Decorators are one of the core features of python, and they allow us to minimise and optimise code quality.\n",
    "\n",
    "This sounds complicated and boring, so we'll start with something very basic and fundamental."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's define a simple function that adds two numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    s = x + y\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add(10, 20)       -> 30\n",
      "add(20, 30)       -> 50\n",
      "add(10.11, 20.21) -> 30.34\n",
      "add(\"a\", \"b\")     -> ab\n"
     ]
    }
   ],
   "source": [
    "print 'add(10, 20)       ->', add(10, 20)\n",
    "print 'add(20, 30)       ->', add(20, 30)\n",
    "print 'add(10.11, 20.21) ->', add(10.11, 20.23)\n",
    "print 'add(\"a\", \"b\")     ->', add(\"a\", \"b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What was achieved?\n",
    "A function that can add two numbers.\n",
    "\n",
    "#### What if we want something extra?\n",
    "What if we want to print out the amount of time it took to compute the sum?\n",
    "\n",
    "We can do that using the ```time``` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use the `time()` function to get the current time.<br>\n",
    "We can use this function to calculate the time taken to compute the sum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1522845196.987576"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1522845197.522074"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, we can fetch the time before and after the function call and the difference between the times would give me the time taken by the function to execute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 8.70227813721e-05\n",
      "Sum = 30\n"
     ]
    }
   ],
   "source": [
    "start = time()\n",
    "s = add(10, 20)\n",
    "end = time()\n",
    "print 'Time taken:', end - start\n",
    "print 'Sum =', s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 8.10623168945e-05\n",
      "Sum = 30.4\n"
     ]
    }
   ],
   "source": [
    "start = time()\n",
    "s = add(10.1, 20.3)\n",
    "end = time()\n",
    "print 'Time taken:', end - start\n",
    "print 'Sum =', s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 0.000111103057861\n",
      "Sum = de\n"
     ]
    }
   ],
   "source": [
    "start = time()\n",
    "s = add('d', 'e')\n",
    "end = time()\n",
    "print 'Time taken:', end - start\n",
    "print 'Sum =', s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>So, everytime I want to find the time taken for the `add(x, y)` function to execute, I have to repeat 3 extra lines of code.</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='purple'>Is there a better way?</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could add the timer logic to the function itself.<br>\n",
    "This would reduce repetition of code and solve our problem at the same time.\n",
    "\n",
    "The new function would look something like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_timeit(x, y):\n",
    "    start = time()\n",
    "    s = x + y\n",
    "    end = time()\n",
    "    print 'Time taken:', end - start\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 1.90734863281e-06\n",
      "Sum = 30 \n",
      "\n",
      "Time taken: 1.19209289551e-06\n",
      "Sum = 70 \n",
      "\n",
      "Time taken: 1.90734863281e-06\n",
      "Sum = 30.4 \n",
      "\n",
      "Time taken: 3.09944152832e-06\n",
      "Sum = Diptangsu Goswami \n",
      "\n"
     ]
    }
   ],
   "source": [
    "s = add_timeit(10, 20)\n",
    "print 'Sum =', s, '\\n'\n",
    "\n",
    "s = add_timeit(30, 40)\n",
    "print 'Sum =', s, '\\n'\n",
    "\n",
    "s = add_timeit(10.15, 20.25)\n",
    "print 'Sum =', s, '\\n'\n",
    "\n",
    "s = add_timeit('Diptangsu ', 'Goswami')\n",
    "print 'Sum =', s, '\\n'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### I'm not satisfied with this solution.\n",
    "We do get a considerable amount of code cleanup, but, the function definition has to be changed.\n",
    "\n",
    "We need to understand that in real life situations, the decorating logic might not be this simple.\n",
    "\n",
    "And what if we have multiple functions we want to time?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    s = x + y\n",
    "    return s\n",
    "\n",
    "\n",
    "def sub(x, y):\n",
    "    s = x - y\n",
    "    return s\n",
    "\n",
    "\n",
    "def mul(x, y):\n",
    "    p = x * y\n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='red'>If we wanted to find out the time taken for all these functions, we still have to repeat code inside all of these functions.</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='purple'>Is there a better way?</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Well, in python, there's always a better way.\n",
    "But, to easily understand what that is, let's learn about python a bit more."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What are functions in python?\n",
    "Well, everything in python is an object. Python functions are first-class objects.<br>\n",
    "Function is a builtin type in python.<br>\n",
    "Which means, we can throw it around in the code like we can do with ints or floats or any of the other datatypes we are familiar with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function add at 0x7fb424161cf8>\n"
     ]
    }
   ],
   "source": [
    "print add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "579"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(123, 456)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(add)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = x\n",
    "print y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'add'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function add at 0x7f8fd4216500>\n"
     ]
    }
   ],
   "source": [
    "print a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function add at 0x7f8fd4216500>\n"
     ]
    }
   ],
   "source": [
    "print add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'add'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can pass variables to other functions, right?<br>\n",
    "Since, function is itself a type in python, a function can also be passed to another function!\n",
    "\n",
    "So, we had our `add(x, y)` function, let's write another function that takes a function as an argument and calls it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_caller(func, x, y):\n",
    "    rv = func(x, y)\n",
    "    return rv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum = 60\n"
     ]
    }
   ],
   "source": [
    "s = func_caller(add, 20, 40)\n",
    "print 'Sum =', s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, we can easily add our timer code to the func_caller and then we won't have to change function definitions everytime we want a function to do something extra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timer(func, *args):\n",
    "    before = time()\n",
    "    rv = func(*args)\n",
    "    after = time()\n",
    "    print 'Time taken:', after - before\n",
    "    return rv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 1.90734863281e-06\n",
      "Sum = 5\n",
      "\n",
      "Time taken: 5.00679016113e-06\n",
      "Sum = 9.1\n"
     ]
    }
   ],
   "source": [
    "d = timer(add, 2, 3)\n",
    "print 'Sum =', d\n",
    "print ''\n",
    "d = timer(add, 5.6, 3.5)\n",
    "print 'Sum =', d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 3.09944152832e-06\n",
      "Difference = 21\n",
      "\n",
      "Time taken: 4.05311584473e-06\n",
      "Difference = -1.0\n"
     ]
    }
   ],
   "source": [
    "d = timer(sub, 24, 3)\n",
    "print 'Difference =', d\n",
    "print ''\n",
    "d = timer(sub, 2.5, 3.5)\n",
    "print 'Difference =', d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 5.00679016113e-06\n",
      "Product = 6\n",
      "\n",
      "Time taken: 8.82148742676e-06\n",
      "Product = 8.75\n"
     ]
    }
   ],
   "source": [
    "p = timer(mul, 2, 3)\n",
    "print 'Product =', p\n",
    "print ''\n",
    "p = timer(mul, 2.5, 3.5)\n",
    "print 'Product =', p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This definitely solves our previous two problems,<br>\n",
    "We don't have to change function definitions and we don't have to write sloppy repetitive code everytime we want something extra.\n",
    "\n",
    "But, all of the user code has to be changed, everytime a function is called, it has to be changed.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color='purple'>Is there a better way?</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which brings us to our next question,\n",
    "<font color='blue'>What kind of values can a function return in Python?</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions in Python can return anything!\n",
    "\n",
    "Which means, a function can return another function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_func_add():\n",
    "    def add(x, y, z):\n",
    "        return x + y + z\n",
    "    return add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = return_func_add()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s(2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timeit(func):\n",
    "    # create a wrapper function which wraps some function with extra functionalities.\n",
    "    def wrapper(*args):\n",
    "        before = time()\n",
    "        rv = func(*args)\n",
    "        after = time()\n",
    "        print 'Time taken:', after - before\n",
    "        return rv\n",
    "    \n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    return x + y\n",
    "add = timeit(add)\n",
    "\n",
    "@timeit\n",
    "def sub(x, y):\n",
    "    return x - y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 3.09944152832e-06\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken: 3.09944152832e-06\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sub(10, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This is what a decorator is\n",
    "It provides a simple syntax for calling higher-order functions.\n",
    "By definition, a ```decorator``` is a ```function``` that takes another ```function``` and extends the behaviour of the latter function without explicitly modifying it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More on decorators\n",
    "We can have higher order decorators or nested decorators which are nothing but decorators which can take parameters.\n",
    "\n",
    "Like, if we want to make n function calls everytime a function is called once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ntimes(n):\n",
    "    def caller(func):\n",
    "        def wrapper(*args):\n",
    "            for _ in range(n):\n",
    "                print func.__name__, 'called'\n",
    "                rv = func(*args)\n",
    "            return rv\n",
    "        return wrapper\n",
    "    return caller"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ntimes(3)\n",
    "def f(x):\n",
    "    return x\n",
    "\n",
    "@ntimes(5)\n",
    "def g(x):\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f called\n",
      "f called\n",
      "f called\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g called\n",
      "g called\n",
      "g called\n",
      "g called\n",
      "g called\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'dip'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g('dip')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Have we written the perfect decorator\n",
    "## or\n",
    "## <font color='purple'>Is there a better way?</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The decorator we have written has some drawbacks.\n",
    "- The function definition remains unchanged.\n",
    "- The function gets extra features as the result of decoration.\n",
    "\n",
    "But, what about the properties of the function?<br>\n",
    "Is it still the same function?<br>\n",
    "<font color='red'>It is not</font>\n",
    "- Function metadata is lost\n",
    "- The documentation of the function changes.\n",
    "- The name of the function changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator(func):\n",
    "    def wrapper(*a, **kw):\n",
    "        'This is the wrapper'\n",
    "        return func(*a, **kw)\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "def f():\n",
    "    'This is a function'\n",
    "    print 'I am a function'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a function\n"
     ]
    }
   ],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.f>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function f at 0x7f8fd41da410>\n"
     ]
    }
   ],
   "source": [
    "print f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a function'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before decorating the function, it has all the properties of itself, as is expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "@decorator\n",
    "def f():\n",
    "    'This is a function'\n",
    "    print 'I am a function'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.wrapper>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function wrapper at 0x7f8fd41da050>\n"
     ]
    }
   ],
   "source": [
    "print f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'wrapper'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is the wrapper'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decorating a function changes the `docstring` associated with it.<br>\n",
    "Ofcourse, we wouldn't want the documentation to change when some extra functionality is added to a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How do we fix this problem?\n",
    "Turns out, python has an inbuilt decorator which is part of the `functools` module which allows a decorator to pass on all properties from the function getting decorated, to itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import wraps\n",
    "\n",
    "def dec(func):\n",
    "    @wraps(func)\n",
    "    def wrapper(*a, **kw):\n",
    "        'This is the wrapper'\n",
    "        return func(*a, **kw)\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dec\n",
    "def g():\n",
    "    'This is a function g'\n",
    "    print 'I am a function g'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.g>"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function g at 0x7f8fd41da2a8>\n"
     ]
    }
   ],
   "source": [
    "print g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a function g'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thank You"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}