10_miscellaneous.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Passing tuples around"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,d = (3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,s = (4,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Special Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are certain methods such as the \\_\\_init\\_\\_ and \\_\\_del\\_\\_ methods which have special significance in classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SINGLE STATEMENT BLOCKS "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "We have seen that each block of statements is set apart from the rest by its own indentation level. Well, there is one caveat. If your block of statements contains only one single statement, then you can specify it on the same line of, say, a conditional statement or looping statement. The following example should make this clear:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes\n"
     ]
    }
   ],
   "source": [
    "flag = True\n",
    "if flag: print('Yes')\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Notice that the single statement is used in-place and not as a separate block. Although, you can use this for making your program smaller, I strongly recommend avoiding this short-cut method, except for error checking, mainly because it will be much easier to add an extra statement if you are using proper indentation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `lambda` function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "A lambda statement is used to create new function objects. Essentially, the lambda takes a parameter followed by a single expression. Lambda becomes the body of the function. The value of this expression is returned by the new function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'x': 2, 'y': 3}, {'x': 4, 'y': 1}]\n"
     ]
    }
   ],
   "source": [
    "points = [{'x': 2, 'y': 3}, \n",
    "           {'x': 4, 'y': 1}]\n",
    "    \n",
    "points.sort(key=lambda i: i['x']) \n",
    "print(points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **_write more about_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `map` function "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The map iterator takes a function and applies it to the values in an *__iterator__*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 9 16 25 36 49 64 81 "
     ]
    }
   ],
   "source": [
    "# find the first 10 square numbers \n",
    "square = lambda x: x ** 2\n",
    "for val in map(square, range(10)): \n",
    "    print(val, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `filter` function "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The filter *iterator* looks similar, except it only passes through values for which the filter function __evaluates to True__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 "
     ]
    }
   ],
   "source": [
    "is_even=lambda x:x%2==0\n",
    "for val in filter(is_even, range(10)): \n",
    "    print(val, end=' ')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Comprehension "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehensions are used to derive a new list from an existing list. Suppose you have a list of numbers and you want to get a corresponding list with all the numbers multiplied by 2 only when the number itself is greater than 2. List comprehensions are ideal for such situations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 8]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listone = [0.5,2, 3, 4]\n",
    "listtwo = [2*i for i in listone if i > 2]\n",
    "listtwo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.125, 8, 6, 8]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listthree = [2*i if i>2 else i**3 for i in listone]\n",
    "listthree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Genrators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List comprehensions use square brackets, while generator expressions use parentheses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x7fdd384e5c10>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(n ** 2 for n in range(12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is a collection of values, while a generator is a recipe for producing values\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you create a list, you are actually building a collection of val‐ ues, and there is some memory cost associated with that. When you create a generator, you are not building a collection of values, but a recipe for producing those values. Both expose the same iterator interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 9 16 25 36 49 64 81 100 121 "
     ]
    }
   ],
   "source": [
    "G=(n**2for n in range(12)) \n",
    "for val in G:\n",
    "    print(val, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The difference is that a generator expression does not actually com‐ pute the values until they are needed. This not only leads to memory efficiency, but to computational efficiency as well! This also means that while the size of a list is limited by available memory, the size of a generator expression is unlimited!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might see what we’re getting at here: if we were to expand the list of factors appropriately, what we would have the beginnings of is a prime number generator, using the Sieve of Eratosthenes algo‐ rithm. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 11 13 17 19 23 29 31 37 41 \n",
      "43 47 53 59 61 67 71 73 79 83 89 97 101 "
     ]
    }
   ],
   "source": [
    "from itertools import count\n",
    "factors = [2, 3, 5, 7] \n",
    "G=(i for i in count() if all(i%n>0for n in factors)) \n",
    "for val in G:\n",
    "    print(val, end=' ') \n",
    "    if val > 40: break\n",
    "\n",
    "print()\n",
    "\n",
    "for i in G:\n",
    "    print(i, end = ' ')\n",
    "    if i> 100 : break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list can be iterated multiple times; a generator expression is single use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 9 16 25 36 49 64 81 100 121 \n",
      "0 1 4 9 16 25 36 49 64 81 100 121 "
     ]
    }
   ],
   "source": [
    "L=[n**2 for n in range(12)] \n",
    "for val in L:\n",
    "    print(val, end=' ') \n",
    "print()\n",
    "\n",
    "for val in L: \n",
    "    print(val, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "G=(n**2 for n in range(12)) \n",
    "list(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be very useful because it means iteration can be stopped and started:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 9 16 25 36 \n",
      "doing something in between\n",
      "49 64 81 100 121 "
     ]
    }
   ],
   "source": [
    "G = (n**2 for n in range(12)) \n",
    "for n in G:\n",
    "    print(n, end=' ')\n",
    "    if n>30: break\n",
    "        \n",
    "print(\"\\ndoing something in between\")\n",
    "for n in G:\n",
    "    print(n, end=' ')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# genrator functions: using yield"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw in the previous section that list comprehensions are best used to create relatively simple lists, while using a normal for loop can be better in more complicated situations. The same is true of generator expressions: we can make more complicated generators using generator functions, which make use of the yield statement.\n",
    "Here we have two ways of constructing the same list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121]\n",
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121]\n"
     ]
    }
   ],
   "source": [
    "L1 = [n ** 2 for n in range(12)]\n",
    "L2=[]\n",
    "for n in range(12):\n",
    "    L2.append(n ** 2) \n",
    "\n",
    "print(L1)\n",
    "print(L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, here we have two ways of constructing equivalent genera‐ tors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 4 9 16 25 36 49 64 81 100 121\n",
      "---\n",
      "0 1 4 9 16 25 36 49 64 81 100 121\n",
      "--\n",
      "\n",
      "--\n",
      "0 1 4 9 16 25 36 49 64 81 100 121\n"
     ]
    }
   ],
   "source": [
    " G1 = (n ** 2 for n in range(12)) \n",
    "def gen():\n",
    "    for n in range(12):\n",
    "        yield n**2\n",
    "G2 = gen()\n",
    "print(*G1)\n",
    "print('---')\n",
    "print(*G2)\n",
    "print('--')\n",
    "print(*G2)\n",
    "print('--')\n",
    "print(*gen())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A generator function is a function that, rather than using return to return a value once, uses yield to yield a (potentially infinite) sequence of values. Just as in generator expressions, the state of the generator is preserved between partial iterations, but if we want a fresh copy of the generator we can simply call the function again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67\n"
     ]
    }
   ],
   "source": [
    "# genrate prime numbers upto N\n",
    "def gen_primes(N):\n",
    "    \"\"\"Generate primes up to N\"\"\"\n",
    "    primes = set()\n",
    "    for n in range(2, N):\n",
    "        if all(n%p>0for p in primes): \n",
    "            primes.add(n)\n",
    "            yield n\n",
    "print(*gen_primes(70))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That’s all there is to it! While this is certainly not the most computa‐ tionally efficient implementation of the Sieve of Eratosthenes, it illustrates how convenient the generator function syntax can be for building more complicated sequences."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `assert` statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The assert statement is used to assert that something is true. For example, if you are very sure that you will have at least one element in a list you are using and want to check this, and raise an error if it is not true, then assert statement is ideal in this situation. When the assert statement fails, an AssertionError is raised. The pop() method removes and returns the last item from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "i should be grater than 0 ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-42-2c8df5e5cb28>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m10\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----> 2\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'i should be grater than 0 '\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: i should be grater than 0 "
     ]
    }
   ],
   "source": [
    "for i in range(-2,10):\n",
    "    assert i>0, 'i should be grater than 0 '"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.youtube.com/watch?v=r7Dtus7N4pI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "normal functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1(): \n",
    "    print('hi, i am f1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, i am f1\n"
     ]
    }
   ],
   "source": [
    "f1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.f1()>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function f1 at 0x7fdd40c93940>\n"
     ]
    }
   ],
   "source": [
    "print(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f1\n"
     ]
    }
   ],
   "source": [
    "print(f1.__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "f2() missing 1 required positional argument: 'f'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-58-594ac594851e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mf2\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: f2() missing 1 required positional argument: 'f'"
     ]
    }
   ],
   "source": [
    "def f1(): \n",
    "    print('hi, i am f1')\n",
    "    \n",
    "def f2(f):\n",
    "    f\n",
    "    \n",
    "f2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, i am f1\n"
     ]
    }
   ],
   "source": [
    "f2(f1())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = f2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "d(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, i am f1\n"
     ]
    }
   ],
   "source": [
    "def f1(): \n",
    "    print('hi, i am f1')\n",
    "    \n",
    "def f2(f):\n",
    "    f()\n",
    "    \n",
    "f2(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.f1.<locals>.wrapper()>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f1(func):\n",
    "    def wrapper():\n",
    "        print('started')\n",
    "        func()\n",
    "        print('ended')\n",
    "        \n",
    "    return wrapper\n",
    "\n",
    "def f():\n",
    "    print(\"trying to get wrapped\")\n",
    "    \n",
    "f1(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trying to get wrapped\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.f1.<locals>.wrapper()>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1(f())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function f1.<locals>.wrapper at 0x7fdd40c934c0>\n"
     ]
    }
   ],
   "source": [
    "print(f1(f))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "started\n",
      "trying to get wrapped\n",
      "ended\n"
     ]
    }
   ],
   "source": [
    "f3 = f1(f) # can be replaced with something called 'decorator'\n",
    "f3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "started\n",
      "trying to get wrapped\n",
      "ended\n"
     ]
    }
   ],
   "source": [
    "f1(f)()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1(func):\n",
    "    def wrapper():\n",
    "        print('started')\n",
    "        func()\n",
    "        print('ended')\n",
    "        \n",
    "    return wrapper\n",
    "@f1\n",
    "def f():\n",
    "    print(\"trying to get wrapped\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "started\n",
      "trying to get wrapped\n",
      "ended\n"
     ]
    }
   ],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "wrapper() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-80-a13603fb0c08>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'wrapping passed function'\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: wrapper() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "def f1(func):\n",
    "    def wrapper():\n",
    "        print('started')\n",
    "        func()\n",
    "        print('ended')\n",
    "        \n",
    "    return wrapper\n",
    "@f1\n",
    "def f(a):\n",
    "    print(a)\n",
    "    \n",
    "f('wrapping passed function')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "started\n",
      "wrapping passed function with a passed value\n",
      "ended\n"
     ]
    }
   ],
   "source": [
    "def f1(func):\n",
    "    def wrapper(*args,**kwargs):\n",
    "        print('started')\n",
    "        func(*args,**kwargs)\n",
    "        print('ended')\n",
    "        \n",
    "    return wrapper\n",
    "@f1\n",
    "def f(a):\n",
    "    print(a)\n",
    "    \n",
    "f('wrapping passed function with a passed value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "started\n",
      "wrapping passed function with a passed value 9\n",
      "ended\n"
     ]
    }
   ],
   "source": [
    "def f1(func):\n",
    "    def wrapper(*args,**kwargs):\n",
    "        print('started')\n",
    "        func(*args,**kwargs)\n",
    "        print('ended')\n",
    "        \n",
    "    return wrapper\n",
    "@f1\n",
    "def f(a,b=9):\n",
    "    print(a,b)\n",
    "    \n",
    "f('wrapping passed function with a passed value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# return values from decorated functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "started\n",
      "wrapping passed function with a passed value 9\n",
      "ended\n"
     ]
    }
   ],
   "source": [
    "def f1(func):\n",
    "    def wrapper(*args,**kwargs):\n",
    "        print('started')\n",
    "        val = func(*args,**kwargs)\n",
    "        print('ended')\n",
    "        return val\n",
    "    \n",
    "    return wrapper\n",
    "@f1\n",
    "def f(a,b=9):\n",
    "    print(a,b)\n",
    "    \n",
    "@f1    \n",
    "def add(x,y):\n",
    "    return x+y\n",
    "\n",
    "f('wrapping passed function with a passed value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "started\n",
      "ended\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(4,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1(f):\n",
    "    def fwrap():\n",
    "        f()\n",
    "        print('i am wrapper')\n",
    "        f()\n",
    "    return fwrap\n",
    "@f1\n",
    "def f2():\n",
    "    print(\"decorate me\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "decorate me\n",
      "i am wrapper\n",
      "decorate me\n"
     ]
    }
   ],
   "source": [
    "f2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://www.youtube.com/watch?v=FsAPt_9Bf3U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_function():\n",
    "    message = 'Hi' \n",
    "    \n",
    "    def inner_function():\n",
    "        print(message)\n",
    "        \n",
    "    return inner_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n"
     ]
    }
   ],
   "source": [
    "outer_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.outer_function.<locals>.inner_function()>"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def outer_function():\n",
    "    message = 'Hi' \n",
    "    \n",
    "    def inner_function():\n",
    "        print(message)\n",
    "        \n",
    "    return inner_function\n",
    "\n",
    "outer_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_func = outer_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n"
     ]
    }
   ],
   "source": [
    "my_func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_function(msg):\n",
    "    message = msg \n",
    "    \n",
    "    def inner_function():\n",
    "        print(message)\n",
    "        \n",
    "    return inner_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "hi =  outer_function('hi')\n",
    "out =  outer_function('out')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n"
     ]
    }
   ],
   "source": [
    "hi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "out\n"
     ]
    }
   ],
   "source": [
    "out()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_function(msg):\n",
    "    def inner_function():\n",
    "        print(msg)\n",
    "        \n",
    "    return inner_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lol\n"
     ]
    }
   ],
   "source": [
    "outer_function('lol')()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "display function ran\n"
     ]
    }
   ],
   "source": [
    "def decorater_function(OGfunc):\n",
    "    def wrapper_function():\n",
    "        return OGfunc()\n",
    "    return wrapper_function\n",
    "\n",
    "def display():\n",
    "    print('display function ran')\n",
    "    \n",
    "decorated_display = decorater_function(display)\n",
    "decorated_display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrapper executed this before display\n",
      "display function ran\n"
     ]
    }
   ],
   "source": [
    "def decorater_function(OGfunc):\n",
    "    def wrapper_function():\n",
    "        print('wrapper executed this before {}'.format(OGfunc.__name__))\n",
    "        return OGfunc()\n",
    "    return wrapper_function\n",
    "\n",
    "def display():\n",
    "    print('display function ran')\n",
    "    \n",
    "decorated_display = decorater_function(display)\n",
    "decorated_display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrapper executed this before display\n",
      "display function ran\n"
     ]
    }
   ],
   "source": [
    "def decorater_function(OGfunc):\n",
    "    def wrapper_function():\n",
    "        print('wrapper executed this before {}'.format(OGfunc.__name__))\n",
    "        return OGfunc()\n",
    "    return wrapper_function\n",
    "\n",
    "@decorater_function # display = decorator_function(display)\n",
    "def display():\n",
    "    print('display function ran')\n",
    "    \n",
    "\n",
    "display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "# classes as decorator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'decorator_class' object has no attribute 'original_function'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-135-f2227cc74f88>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     13\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'decorated display'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mdisplay\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<ipython-input-135-f2227cc74f88>\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\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[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'call method executed this before {}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moriginal_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\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[1;32m      9\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moriginal_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'decorator_class' object has no attribute 'original_function'"
     ]
    }
   ],
   "source": [
    "class decorator_class(object):\n",
    "    \n",
    "    def __init__(self, original_function):\n",
    "        self.original_funtion = original_function\n",
    "        \n",
    "    def __call__(self, *args,**kwargs):\n",
    "        \n",
    "        print('call method executed this before {}'.format(self.original_function.__name__))\n",
    "        return self.original_function(*args,**kwargs)\n",
    "    \n",
    "@decorator_class\n",
    "def display():\n",
    "    print('decorated display')\n",
    "    \n",
    "display()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}