first class functions and closures are added

Author: sijantech

.ipynb_checkpoints/13. Generators and Decorators-checkpoint.ipynb

@@ -173,25 +173,23 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
+   "cell_type": "markdown",
+   "metadata": {},
    "source": [
-    "def read_big_file_in_chunks(file_object, chunk_size=1024):\n",
-    "    \"\"\"Reading whole big file in chunks.\"\"\"\n",
-    "    while True:\n",
-    "        data = file_object.read(chunk_size)\n",
-    "        if not data:\n",
-    "            break\n",
-    "        yield data\n",
-    "\n",
-    "\n",
-    "f = open('very_very_big_file.log')\n",
-    "for chunk in read_in_chunks(f):\n",
-    "    process_data(chunck)\n"
+    "```\n",
+    "    def read_big_file_in_chunks(file_object, chunk_size=1024):\n",
+    "        \"\"\"Reading whole big file in chunks.\"\"\"\n",
+    "        while True:\n",
+    "            data = file_object.read(chunk_size)\n",
+    "            if not data:\n",
+    "                break\n",
+    "            yield data\n",
+    "\n",
+    "\n",
+    "    f = open('very_very_big_file.log')\n",
+    "    for chunk in read_big_file_in_chunks(f):\n",
+    "       process_data(chunck)\n",
+    "```"
    ]
   },
   {
@@ -329,6 +327,220 @@
     "\n"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def smart_divide(func):\n",
+    "   def inner(a,b):\n",
+    "      print(\"I am going to divide\",a,\"and\",b)\n",
+    "      if b == 0:\n",
+    "         print(\"Whoops! cannot divide\")\n",
+    "         return\n",
+    "\n",
+    "      return func(a,b)\n",
+    "   return inner\n",
+    "\n",
+    "@smart_divide\n",
+    "def divide(a,b):\n",
+    "    return a/b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "I am going to divide 9 and 0\n",
+      "Whoops! cannot divide\n"
+     ]
+    }
+   ],
+   "source": [
+    "divide(9,0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "### EXAMPLE - 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Entering call_func1\n",
+      "inside func1()\n",
+      "Exited call_func1\n",
+      "Entering call_func2\n",
+      "inside func2()\n",
+      "Exited call_func2\n",
+      "new_fun\n"
+     ]
+    }
+   ],
+   "source": [
+    "# PythonDecorators/entry_exit_function.py\n",
+    "def my_decorator(f):\n",
+    "    def new_fun():\n",
+    "        print(\"Entering\", f.__name__)\n",
+    "        f()\n",
+    "        print(\"Exited\", f.__name__)\n",
+    "    return new_fun\n",
+    "\n",
+    "@my_decorator\n",
+    "def call_func1():\n",
+    "    print(\"inside func1()\")\n",
+    "\n",
+    "@my_decorator\n",
+    "def call_func2():\n",
+    "    print(\"inside func2()\")\n",
+    "\n",
+    "call_func1()\n",
+    "call_func2()\n",
+    "print(call_func1.__name__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### NOTE\n",
+    "\n",
+    " - new_fun() is defined within the body of my_decorator(), so it is created and returned when my_decorator() is called.\n",
+    " - Note that new_fun() is a closure, because it captures the actual value of f.\n",
+    " - print(call_func1.__name__) prints 'new_fun' because new_fun function has been substituted for the original function during decoration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### EXAMPLE - 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<i><b>Hello World</b></i>\n"
+     ]
+    }
+   ],
+   "source": [
+    "def makebold(fn):\n",
+    "    def wrapped():\n",
+    "        return \"<b>%s</b>\" % fn()\n",
+    "    return wrapped\n",
+    "\n",
+    "def makeitalic(fn):\n",
+    "    def cover():\n",
+    "        return \"<i>%s</i>\" %fn()\n",
+    "    return cover\n",
+    "\n",
+    "@makeitalic\n",
+    "@makebold\n",
+    "def hello():\n",
+    "    return \"Hello World\"\n",
+    "\n",
+    "print (hello())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "### EXAMPLE - 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```\n",
+    "@testtime\n",
+    "@testlog\n",
+    "def call_me():\n",
+    "    print (\"Hello, world!\")```\n",
+    "    \n",
+    "    \n",
+    "    \n",
+    "    - create function object (say - helloObject ) and binds it to name 'call_me'\n",
+    "    - passes helloObject to 'testlog' which will return new function object (say - helloObject2)\n",
+    "    - interpreter binds the real name 'call_me' to this new hellObject2.\n",
+    "    - helloObject2 is passed to 'testtime' and it will return new function object (say - hellObject3)\n",
+    "    - again, interpreter binds orignal name to this new object\n",
+    "    - IMPORTANT : we wrapped helloObject from call_me to helloObject2 from testlog and finally wrap this to helloObject3, and bound the original name 'call_me' to helloObject3. So when we call 'call_me', we are actually calling helloObject3."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "third one\n",
+      "second one\n",
+      "first one\n",
+      "Hello, world!\n",
+      "Hello, solar system!\n",
+      "Hello, galaxy!\n"
+     ]
+    }
+   ],
+   "source": [
+    "def testtime(original_function):\n",
+    "    def new_function():\n",
+    "        print('second one')\n",
+    "        #original_function()  # the () after \"original_function\" causes original_function to be called\n",
+    "        print(\"Hello, solar system!\")\n",
+    "    return new_function\n",
+    "     \n",
+    "def testlog(original_function):\n",
+    "    def new_function():\n",
+    "        print('third one')\n",
+    "        #original_function()  # the parentheses after \"original_function\" cause original_function to be called\n",
+    "        print(\"Hello, galaxy!\")\n",
+    "    return new_function\n",
+    " \n",
+    "\n",
+    "@testlog\n",
+    "@testtime\n",
+    "def call_me():\n",
+    "    print('first one')\n",
+    "    print (\"Hello, world!\")\n",
+    " \n",
+    "# Here is where we actually *do* something!\n",
+    "call_me()"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,