Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "51c38776",
   "metadata": {},
   "source": [
    "### Wrap of basics:\n",
    "   * Data types\n",
    "   * if-else, for, while\n",
    "   * comprehensions\n",
    "   -----------------\n",
    "    \n",
    "### Functions:\n",
    "   - [x] predefined functions\n",
    "   - [x] user defined functions\n",
    "   - [ ] Higher Order functions\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f0529f",
   "metadata": {},
   "source": [
    "#### Pre-defined functions"
   ]
  },
  {
   "cell_type": "raw",
   "id": "940cd15d",
   "metadata": {},
   "source": [
    "print()\n",
    "sum()\n",
    "len()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82ebc285",
   "metadata": {},
   "source": [
    "#### user-defined functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b7742e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "fname = input('Enter name here:')\n",
    "print('Welcome to the class, ' + fname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a9a814d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def welcomeMsg(fname): \n",
    "    print('Hi ' + fname +'!')\n",
    "    print('Welcome to the class') # definition of the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "044289ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "welcomeMsg('Siddhart')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6b20d01",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mathfunc(x,y):\n",
    "    z = 2*(x+y)\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24912219",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sign(anyInteger):\n",
    "    if anyInteger > 0:\n",
    "        return \n",
    "    elif anyInteger < 0:\n",
    "        return \n",
    "    else:\n",
    "        return "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d811d4dd",
   "metadata": {},
   "source": [
    "##### Functions ae typeless  !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f295df3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def udf(a,b):\n",
    "    return a*b"
   ]
  },
  {
   "cell_type": "raw",
   "id": "92c4bcd5",
   "metadata": {},
   "source": [
    "udf(2,3) and udf ('python',3) are both perfectly valid; Depending on the input, python decides multiplication vs repetition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e40ba4cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "udf(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "754ffeb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "udf('hi',3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "723f0098",
   "metadata": {},
   "source": [
    "#### Functions and namespaces:\n",
    "\n",
    "- Names are created in name spaces and that affects its visibility\n",
    "- Functions provide a namepsace for a variable to exist\n",
    "- Names assigned inside a `def` can exist only within that `def` aka the namespace of that particular function\n",
    "- Names assigned within two `def` do not clash with each other even if the names are the same because theie namespaces are different\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33663b12",
   "metadata": {},
   "source": [
    "If a variable is assigned to a function it is local to that function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ed8094b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def udf():\n",
    "    a = 4\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c81367a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "udf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bef26001",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bb5e798",
   "metadata": {},
   "source": [
    "variable assigned outside the `def` is global"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "faeb8416",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 50\n",
    "\n",
    "def udf():\n",
    "    a = 30\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfc9f0eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "udf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff67db27",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02f91fd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def udf(b):\n",
    "    global a\n",
    "    a = 100\n",
    "    return a*b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "318f0e82",
   "metadata": {},
   "outputs": [],
   "source": [
    "udf(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2837fdce",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0659eb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = 99\n",
    "\n",
    "def func1():\n",
    "    global X \n",
    "    X = 88\n",
    "\n",
    "def func2(): \n",
    "    global X\n",
    "    X = 77"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "170c6fa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a83d5d15",
   "metadata": {},
   "outputs": [],
   "source": [
    "func1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41f6b7dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df25e557",
   "metadata": {},
   "outputs": [],
   "source": [
    "func2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b8ae504",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c593e29e",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = 99\n",
    "\n",
    "def func1():\n",
    "    global X \n",
    "    X = 88\n",
    "\n",
    "def func2(): \n",
    "    global X\n",
    "    X = 77"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd392a0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7afe125f",
   "metadata": {},
   "source": [
    "#### Value of X depends on which function was run first; Hence, do not abuse global!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdf2e200",
   "metadata": {},
   "source": [
    "#### Nested functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "7e96c779",
   "metadata": {},
   "outputs": [],
   "source": [
    "def udf():\n",
    "    a = 20 #local to udf and all its nested functions\n",
    "    def udf1():\n",
    "        b = 4 # local to only udf1\n",
    "        print(a*b)\n",
    "    udf1()\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "a6b8c74f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "udf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "3eadaa96",
   "metadata": {},
   "outputs": [],
   "source": [
    "def udf():\n",
    "    a = 20\n",
    "    def udf1():\n",
    "        b = 4\n",
    "        print(a*b)\n",
    "    udf1()\n",
    "    return a,b # Will b be alive?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "99d9ed14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'b' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/64/86wm1bvj5tdbj8tcrs97120w0000gn/T/ipykernel_4784/1425727631.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mudf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/var/folders/64/86wm1bvj5tdbj8tcrs97120w0000gn/T/ipykernel_4784/1323198879.py\u001b[0m in \u001b[0;36mudf\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mudf1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m \u001b[0;31m# Will b be alive?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'b' is not defined"
     ]
    }
   ],
   "source": [
    "udf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82f8ce78",
   "metadata": {},
   "outputs": [],
   "source": [
    "def udf():\n",
    "    a = 20\n",
    "    def udf1():\n",
    "        global b\n",
    "        b = 4\n",
    "        print(a*b)\n",
    "    udf1()\n",
    "    return a,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1556d62b",
   "metadata": {},
   "outputs": [],
   "source": [
    "udf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce6f3d25",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Are a and b still alive?\n",
    "print(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c41be8dc",
   "metadata": {},
   "source": [
    "#### Higher functionalities with python functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "5068bf8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def udf():\n",
    "    mystr = 'udf function printed'\n",
    "    return mystr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "3a112c9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "udf1 = udf #assign new variable name udf1 to udf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "286e5e4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "udf2 = udf() #call udf and assign the result to udf2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "6dcff12c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'udf function printed'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "udf1()  ##the contents of udf exists in both udf and udf1 giving the same result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "ebccc06e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'udf function printed'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "udf() ##the contents of udf exists in both udf and udf1 giving the same result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "57b17175",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/64/86wm1bvj5tdbj8tcrs97120w0000gn/T/ipykernel_4784/2698350213.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mudf2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object is not callable"
     ]
    }
   ],
   "source": [
    "udf2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32f319e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(udf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11d5a5e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(udf1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "615abaac",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(udf2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a486ced",
   "metadata": {},
   "source": [
    "#### Functions as objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "512afe29",
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    \"\"\"Square of x.\"\"\"\n",
    "    return x*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "2772ea5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cube(x):\n",
    "    \"\"\"Cube of x.\"\"\"\n",
    "    return x * x * x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "b3f265ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "funcs = {'square': square, 'cube': cube}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "287915c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_num = 4\n",
    "\n",
    "for eachFunction in funcs: \n",
    "    print(eachFunction, funcs[eachFunction](my_num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "6da390f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e8b0f0f3",
   "metadata": {},
   "source": [
    "### Higher-order functions\n",
    "\n",
    "A function that uses another function as an input argument or returns a function is known as a higher-order function(HOF). \n",
    "\n",
    "The most familiar examples are map() and filter().\n",
    "\n",
    "#### Passing a function as argument to another function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "1244c4c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_map(func, arg_list):\n",
    "    result = []\n",
    "    for i in arg_list:\n",
    "        result.append(func(i))\n",
    "    return result # for every element i in the list arg_list do what\n",
    "                  # is described in the function func and append it to  \n",
    "                  # the new list result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "993b999b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 27, 64]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_map(cube, list(range(1,5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13829327",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ec448cd6",
   "metadata": {},
   "source": [
    "#### Return a function from a function \n",
    "\n",
    "### Inner Functions\n",
    "\n",
    "Inner functions are the function that are defined inside other function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "1c84c27f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_fun(a):\n",
    "    print(\"Printing from the outer_fun() function\")\n",
    "\n",
    "    def first_inner_fun():\n",
    "        print(\"Printing from the first_inner_fun() function\")\n",
    "        return 3*a\n",
    "\n",
    "    def second_inner_fun():\n",
    "        print(\"Printing from the second_inner_fun() function\")\n",
    "        return 2*a\n",
    "\n",
    "    b = first_inner_fun()\n",
    "    c = second_inner_fun()\n",
    "    return a*b*c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "165e664b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing from the outer_fun() function\n",
      "Printing from the first_inner_fun() function\n",
      "Printing from the second_inner_fun() function\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "162000"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "outer_fun(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a572864",
   "metadata": {},
   "source": [
    "### Closure\n",
    "\n",
    "Closure allow us to take advantage of first-class functions, and return an inner function that remembers and has access to variables local to the scope in which they were created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "268e3151",
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_fun(message):\n",
    "    \n",
    "    def inner_fun():\n",
    "        print(message)\n",
    "        \n",
    "    return inner_fun()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "bd68d965",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "outer_fun('Hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "37d9987d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def makerfunc(Num1):\n",
    "    def actionfunc(Num2):\n",
    "        return Num1*Num2\n",
    "    return actionfunc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "4c3af627",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'actionfunc' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/64/86wm1bvj5tdbj8tcrs97120w0000gn/T/ipykernel_4784/617616116.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mactionfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'actionfunc' is not defined"
     ]
    }
   ],
   "source": [
    "actionfunc(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "03df203e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.makerfunc.<locals>.actionfunc(Num2)>"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "makerfunc(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "5761a06a",
   "metadata": {},
   "outputs": [],
   "source": [
    "hof1 = makerfunc(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "acfec5e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.makerfunc.<locals>.actionfunc(Num2)>"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hof1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "ef780699",
   "metadata": {},
   "outputs": [],
   "source": [
    "strtimes = hof1('3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "397c713c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3333333333'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strtimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41b7940b",
   "metadata": {},
   "outputs": [],
   "source": [
    "numtimes = hof1(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "002a7589",
   "metadata": {},
   "outputs": [],
   "source": [
    "numtimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "849ba7bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def makefun(N):\n",
    "    return lambda X:X*N\n",
    "\n",
    "h = makefun(3)\n",
    "h(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5c69a68",
   "metadata": {},
   "source": [
    "## Decorators - Dynamically Alter The Functionality Of Your Functions\n",
    "\n",
    "Decorator takes another function as argument and adds (decorates the function) a different functionality and returns a function without altering the original function that was passed in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "a2cd8b39",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator_function(message):\n",
    "    def wrapper_function():\n",
    "        print(message)\n",
    "    return wrapper_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6aecf79",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd9ff36b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c4c1f070",
   "metadata": {},
   "source": [
    "The above is a regular function that takes in message as input; but decorator function takes in another function as it input argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "a5bfc111",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator_function(someInput_func):\n",
    "    def wrapper_function():\n",
    "        return someInput_func()\n",
    "    return wrapper_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "822ed94d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display():\n",
    "    print('The display function ran today')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "10cf7ea5",
   "metadata": {},
   "outputs": [],
   "source": [
    "call_function = decorator_function(display)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "12406f15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The display function ran today\n"
     ]
    }
   ],
   "source": [
    "call_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11598de6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator_function(someInput_func): # change the wrapper function without altering the display function\n",
    "    def wrapper_function():\n",
    "#         print('Wrapper function executed this line before {} function'.format(someInput_func.__name__))\n",
    "        print('Wrapper function added this functionality to the display function')\n",
    "        return someInput_func()\n",
    "    return wrapper_function\n",
    "\n",
    "def display():\n",
    "    print('The display function ran')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "291156b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "call_function = decorator_function(display)\n",
    "\n",
    "call_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d35ccdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator_function(someInput_func): # change the wrapper function without altering the display function\n",
    "    def wrapper_function():\n",
    "#         print('Wrapper function executed this line before {} function'.format(someInput_func.__name__))\n",
    "        print('Wrapper function added this functionality to the display function')\n",
    "        return someInput_func()\n",
    "    return wrapper_function\n",
    "\n",
    "@decorator_function\n",
    "def display():\n",
    "    print('The display function ran') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23a1bcb9",
   "metadata": {},
   "outputs": [],
   "source": [
    "display() # run the 'display' function as a decorated function of 'decorator function'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "811e0e9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "@decorator_function\n",
    "def mathFunc(): # mathFunc will run as regular function\n",
    "    num1 = int(input('enter any number: '))\n",
    "    c = num1**2\n",
    "    print(\"the square of the entered number is {}\".format(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e88d319",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input function with arguments:\n",
    "\n",
    "def decorator_function(someInput_func):\n",
    "    def wrapper_function():\n",
    "        print('Wrapper function executed this line before {} function'.format(someInput_func.__name__))\n",
    "        return someInput_func()\n",
    "    return wrapper_function\n",
    "\n",
    "@decorator_function\n",
    "def display():\n",
    "    print('The display function ran')  \n",
    "    \n",
    "    \n",
    "@decorator_function\n",
    "def display_info(name,age):\n",
    "    print('The display info now ran with argument({}, {})'.format(name,age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5415162e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator_function(someInput_func):\n",
    "    def wrapper_function(*args, **kwargs):\n",
    "        print('Wrapper function executed this line before {} function'.format(someInput_func.__name__))\n",
    "        return someInput_func(*args, **kwargs)\n",
    "    return wrapper_function\n",
    "\n",
    "@decorator_function\n",
    "def display():\n",
    "    print('The display function ran')  \n",
    "    \n",
    "    \n",
    "@decorator_function\n",
    "def display_info(name,age):\n",
    "    print('The display info now ran with argument({}, {})'.format(name,age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8639aa7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrapper function executed this line before display_info function\n",
      "The display info now ran with argument(Ram, 26)\n"
     ]
    }
   ],
   "source": [
    "display_info('Ram',26)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "952babe3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_timer(orig_func):\n",
    "    \n",
    "    import time\n",
    "    \n",
    "    def wrapper(*args, **kwargs):\n",
    "        t1 = time.time()\n",
    "        result = orig_func(*args, **kwargs)\n",
    "        t2 = time.time() - t1\n",
    "        print('{} ran in: {} sec'. format(orig_func.__name__, t2))\n",
    "        return result\n",
    "    \n",
    "    return wrapper\n",
    "\n",
    "@my_timer\n",
    "def display_info(name, age):\n",
    "    print('display_info ran with arguments ({}, {})'.format(name, age))\n",
    "    \n",
    "display_info('Sid', 33)\n",
    "\n",
    "@my_timer\n",
    "def anyotherfunction():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d72b04d5",
   "metadata": {},
   "source": [
    "#### Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "757d8e61",
   "metadata": {},
   "source": [
    "`yield` statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fd6bda5",
   "metadata": {},
   "outputs": [],
   "source": [
    "help('next')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c661e29",
   "metadata": {},
   "outputs": [],
   "source": [
    "def simplegenerator():\n",
    "    print('First item')\n",
    "    yield 10\n",
    "\n",
    "    print('Second item')\n",
    "    yield 20\n",
    "\n",
    "    print('Last item')\n",
    "    yield 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46a97165",
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = simplegenerator() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7af9433d",
   "metadata": {},
   "outputs": [],
   "source": [
    "next(gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "fcaa9048",
   "metadata": {},
   "outputs": [],
   "source": [
    "squres = (x*x for x in range(5)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "0f20b229",
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/64/86wm1bvj5tdbj8tcrs97120w0000gn/T/ipykernel_4784/3421283323.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msqures\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "print(next(squres))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d195084b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b9a552a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "24\n",
      "15\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "l = [23,24,15,2,4,6]\n",
    "lobj = l.__iter__()\n",
    "print(lobj.__next__())\n",
    "print(lobj.__next__())\n",
    "print(lobj.__next__())\n",
    "print(lobj.__next__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "dfb6c3f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "dr\n",
      "8\n",
      "8\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "t = (2,4,'dr',8,8,4,3,8)\n",
    "tobj = iter(t)\n",
    "print(next(tobj))\n",
    "print(next(tobj))\n",
    "print(next(tobj))\n",
    "print(next(tobj))\n",
    "print(next(tobj))\n",
    "print(next(tobj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3e845502",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (2,4,'dr',8,8,4,3,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7b2c1728",
   "metadata": {},
   "outputs": [],
   "source": [
    "def simplegenerator(it):\n",
    "    for eachitem in it:\n",
    "        yield eachitem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "98ca5aa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "tgen = simplegenerator(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "54f8755a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dr'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(tgen)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "835613c4",
   "metadata": {},
   "source": [
    "#### module itertools\n",
    "https://docs.python.org/3/library/itertools.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "8de44d42",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d17d7191",
   "metadata": {},
   "outputs": [],
   "source": [
    "def countfunc(startval,stepval):\n",
    "    for i in itertools.count(startval,stepval):\n",
    "        yield i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "64a58c4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "_10count = countfunc(10,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "bb24e1fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(_10count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e939691b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "a4f50993",
   "metadata": {},
   "outputs": [],
   "source": [
    "def accumGen(iterobj):\n",
    "    for items in itertools.accumulate(l):\n",
    "        yield items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "de8b9efd",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [23,24,15,2,4,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "ab1f3f35",
   "metadata": {},
   "outputs": [],
   "source": [
    "l_accumGen = accumGen(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "ee935586",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(l_accumGen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "c280adf5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(l_accumGen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "959b58c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23, 47, 62, 64, 68, 74]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(itertools.accumulate(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be345405",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}