Advanced_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Advanced_Python.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "MNAjuqXC3ZBX",
        "i8SxW4ne8tkm",
        "hemeVite5Jxd",
        "PMxM6Sn314s-",
        "tZKn4-V8cVEp",
        "OfMmeEVW74GM",
        "5gMvaxz2l2OI",
        "BtfeVeAam9MK",
        "rB3azgyEp_Vy",
        "s03s1OSsq_LS",
        "yt69GZfWuboi",
        "rjS4chBuurIZ",
        "PpY6cdIAu49K",
        "mJHPTdVs7RG1",
        "TmGKR1f55g7-",
        "UPAF3ePpdWlq",
        "s9ji2TJ2EnSg",
        "XRqY7JRHszY7",
        "OtHfxdc5yT-d",
        "UdUK6c57yknm",
        "onON5YG9zjvu",
        "qd6rpD956MEe",
        "k1TuUnpu8wxO",
        "mDa3_2JR8bVe",
        "aH55Rflm9Vie",
        "FvmVnDQ_FvEg",
        "UjpgkSR-kAms",
        "_Hcy2-Jvmn1V",
        "ZlcIOgmFmek4",
        "V7s7i2Lhr9Ho",
        "VjUYIjvX1QAq",
        "OPvRzxSy-B6l",
        "gFtp0aYm82fU",
        "lkfT3rvaN5TH",
        "JthbZ--_X2VO",
        "6t0oU6g5gKQ3",
        "o0WGoYSTcElG",
        "WpUKHakXBlak",
        "YmkuHdZ6B2Ud"
      ],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3.7.7 64-bit ('base': conda)"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.7",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "interpreter": {
      "hash": "b3ba2566441a7c06988d0923437866b63cedc61552a5af99d1f4fb67d367b25f"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/siva-kranthi/Advanced-Python/blob/main/Advanced_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mR1yAqmZg3zl"
      },
      "source": [
        "# Advanced Python \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NNxGG8gPhvW9"
      },
      "source": [
        "## Basics\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zblGkm_gmwvt"
      },
      "source": [
        "### Running Python\n",
        "\n",
        "\n",
        "1. Interactive mode (console)\n",
        "2. Script/Program mode (.py file)\n",
        "3. Notebook mode\n",
        "\n",
        "> In interactive mode, underscore _ holds the last result (This is only true in the interactive mode. You never use _ in a program)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fQLKIkLRm3qW"
      },
      "source": [
        "### Remember\n",
        "\n",
        "\n",
        "* Dynamically typed language. The perceived \"type\" of a variable might change as a program executes depending on the current value assigned to it\n",
        "* Variables do not need to be declared with the type of the value. The type is associated with the value on the right hand side, not name of the variable.\n",
        "* Python is case sensitive. Upper and lower-case letters are considered different letters\n",
        "* Everything in python is an object"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qK0qxcvzuPA-"
      },
      "source": [
        "### Statements\n",
        "\n",
        "A python program is a sequence of statements\n",
        "\n",
        "Each statement is terminated by a newline. Statements are executed one after the other from top to bottom (until control reaches the end of the file)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fdd8uMMduWkF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f9788504-1312-4629-cf9d-5cd76ddbf3fc"
      },
      "source": [
        "a = 3 + 4 # Statement 1\n",
        "b = a * 2 # Statement 2\n",
        "print(b) # End Statement"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "14\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0fbz5Ynmus8_"
      },
      "source": [
        "Python statements are usually written in single line. Python treats each line as a separate statement. (The newline chracter marks the end of the statement)\n",
        "\n",
        "If the statement is very long, we can explicitly divide into multiple lines with the line continuation character **`\\`**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p0rdnEDbvSlE",
        "outputId": "6844de28-ec16-4ffe-821a-2da71dd27005"
      },
      "source": [
        "math_result = 1 + 2 + 3 + 4 + \\\n",
        "              5 + 6 + 7 + 8 + \\\n",
        "              9 + 10\n",
        " \n",
        "message = \"Hello There.\\nYou have come to the right place to learn Python Programming.\\n\" \\\n",
        "          \"Follow the tutorials to become expert in Python.\"  \\\n",
        "          \"Don't forget to share it with your friends too.\"\n",
        "          \n",
        "print(message)\n",
        "print(math_result)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello There.\n",
            "You have come to the right place to learn Python Programming.\n",
            "Follow the tutorials to become expert in Python.Don't forget to share it with your friends too.\n",
            "55\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c3qnjtujvrn-"
      },
      "source": [
        "> **Statements** represent an action or command\n",
        ">\n",
        "> **Expressions** are combinations of values and operators and always evaluate down to a single value. Some statements contain expressions\n",
        "\n",
        "Python supports multi-line continuation inside **parentheses ( ), brackets [ ], and braces { }**\n",
        "\n",
        "The brackets are used by List and the braces are used by dictionary objects. We can use parentheses for expressions, tuples, and strings\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c0jY6sl8zCMH",
        "outputId": "1d70a2f2-0b2f-4ef9-f7c1-0604aad47d53"
      },
      "source": [
        "message = (\"Hello\\n\"\n",
        "           \"Hi\\n\"\n",
        "           \"Namaste\")\n",
        " \n",
        "math_result = (1 + 2 + 3 + 4 +\n",
        "               5 + 6 + 7 + 8 +\n",
        "               9 + 10)\n",
        " \n",
        "prime_numbers_tuple = (2, 3, 5, 7,\n",
        "                       11, 13, 17)\n",
        " \n",
        "list_fruits = [\"Apple\", \"Banana\",\n",
        "               \"Orange\", \"Mango\"]\n",
        " \n",
        "dict_countries = {\"USA\": \"United States of America\", \"IN\": \"India\",\n",
        "                  \"UK\": \"United Kingdom\", \"FR\": \"France\"}\n",
        "\n",
        "print(message, math_result)\n",
        "print(math_result)\n",
        "print(prime_numbers_tuple)\n",
        "print(dict_countries)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello\n",
            "Hi\n",
            "Namaste 55\n",
            "55\n",
            "(2, 3, 5, 7, 11, 13, 17)\n",
            "{'USA': 'United States of America', 'IN': 'India', 'UK': 'United Kingdom', 'FR': 'France'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "19var3MOnN6H"
      },
      "source": [
        "### Pass statement\n",
        "\n",
        "Sometimes you need to specify an empty code block. The keyword `pass` is used for it.\n",
        "\n",
        "This is also called a **no-op** statement. It does nothing. It serves as a placeholder for statements, possibly to be added later."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XFcoWebQnfHF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f39f1829-38cb-4818-bc8f-def72a8aa263"
      },
      "source": [
        "if 1 > 2:\n",
        "    pass\n",
        "else:\n",
        "    print('Computer says false')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computer says false\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OZvSXoMKm8q9"
      },
      "source": [
        "### User Input\n",
        "\n",
        "To read a line of typed user input, use the input() function\n",
        "\n",
        "`input` prints a prompt to the user and returns their response. This is useful for small programs, learning exercises or simple debugging. It is not widely used for real programs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9Gj7-H55lm3e",
        "outputId": "71410805-6b86-4e45-a3b1-79ebd083df03"
      },
      "source": [
        "name = input('Enter your name:')\n",
        "print('Your name is', name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Your name is siva\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MNAjuqXC3ZBX"
      },
      "source": [
        "### Formatting\n",
        "\n",
        "when you work with data, you often want to produce structured output (tables, etc.). For example:\n",
        "\n",
        "```code\n",
        "      Name      Shares        Price\n",
        "----------  ----------  -----------\n",
        "        AA         100        32.20\n",
        "       IBM          50        91.10\n",
        "       CAT         150        83.44\n",
        "      MSFT         200        51.23\n",
        "        GE          95        40.37\n",
        "      MSFT          50        65.10\n",
        "       IBM         100        70.44\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i8SxW4ne8tkm"
      },
      "source": [
        "#### String Formatting\n",
        "\n",
        "One way to format string in Python 3.6+ is with f-strings\n",
        "\n",
        "`f\"{expression:format}\"`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "i8OgoeHV4E_2",
        "outputId": "73038ba4-4376-4e4a-a4c4-3ac8be837097"
      },
      "source": [
        "name = 'IBMem'\n",
        "shares = 100\n",
        "price = 91.1\n",
        "\n",
        "print(f'{name} {shares} {price}') # It is commonly used with print\n",
        "print(f'{name:>4s} {shares:>10d} {price:>10.2f}') # It is commonly used with print\n",
        "print(f'{name}') # It is commonly used with print"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "IBMem 100 91.1\n",
            "IBMem        100      91.10\n",
            "IBMem\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hemeVite5Jxd"
      },
      "source": [
        "Format codes (after the : inside the {}) are similar to C printf(). Common codes include:\n",
        "\n",
        "```code\n",
        "d       Decimal integer\n",
        "b       Binary integer\n",
        "x       Hexadecimal integer\n",
        "f       Float as [-]m.dddddd\n",
        "e       Float as [-]m.dddddde+-xx\n",
        "g       Float, but selective use of E notation\n",
        "s       String\n",
        "c       Character (from integer)\n",
        "```\n",
        "\n",
        "Common modifiers adjust the field width and decimal precision.  This is a partial list:\n",
        "\n",
        "```code\n",
        ":>10d   Integer right aligned in 10-character field\n",
        ":<10d   Integer left aligned in 10-character field\n",
        ":^10d   Integer centered in 10-character field\n",
        ":0.2f   Float with 2 digit precision\n",
        "```\n",
        "\n",
        "https://docs.python.org/3/library/string.html#format-specification-mini-language\n",
        "\n",
        "#### Dictionary Formatting\n",
        "\n",
        "You can use the `format_map()` method to apply string formatting to a dictionary of values:\n",
        "\n",
        "It uses the same codes as `f-strings` but takes the values from the\n",
        "supplied dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zBHLxN4E5v4l",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "d9ab5b7f-402c-4d4f-d569-f283a9cbd3a7"
      },
      "source": [
        "s = {\n",
        "    'name': 'IBM',\n",
        "    'shares': 100,\n",
        "    'price': 91.1\n",
        "}\n",
        "\n",
        "'{name:>10s} {shares:10d} {price:10.2f}'.format_map(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'       IBM        100      91.10'"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PMxM6Sn314s-"
      },
      "source": [
        "### Scoping Rules\n",
        "\n",
        "**Scope** refers to the visibility of object (object lifetime). In other words, which parts of your program can see or use it\n",
        "\n",
        "Python has below 4 scopes (highest to lowest)\n",
        "\n",
        "1. **Local (L):** Within the current function/class. You can access all local variables with `locals()`.\n",
        "2. **Enclosed (E):** inside enclosing functions\n",
        "3. **Global (G):** In the main part of the script. By default, this already contains the built-ins. You can access all global variables with `globals()`. Within the main script, `locals() == globals()`\n",
        "4. **Built-in (B)** : keywords, functions, and other attributes that are built into Python\n",
        "\n",
        "Python uses above **LEGB** rule for scope resolution\n",
        "\n",
        "![6385a29a0cc08eb5fad8382f721a868769a80dc8.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mESaP9DR4zjV",
        "outputId": "d734de26-ca4c-447b-d527-abd64cd38d9e"
      },
      "source": [
        "\n",
        "# Built-in Scope\n",
        "from math import pi\n",
        "  \n",
        "# pi = 'global pi variable' # global scope\n",
        "  \n",
        "def outer():\n",
        "    # pi = 'outer pi variable'\n",
        "    a = \"hi\" # Enclosed Scopr\n",
        "    def inner():\n",
        "        # pi = 'inner pi variable' # Local Scope\n",
        "        print(pi)\n",
        "        print(a)\n",
        "    print(pi)\n",
        "    inner()\n",
        "    print(pi)\n",
        "  \n",
        "outer()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.141592653589793\n",
            "3.141592653589793\n",
            "hi\n",
            "3.141592653589793\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tZKn4-V8cVEp"
      },
      "source": [
        "## Objects"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z-aAdo1Lgn1a"
      },
      "source": [
        "In python everything is an **object**\n",
        "\n",
        "Almost every object has some metadata (called *attributes*) and associated functionality (called *methods*)\n",
        "\n",
        "Even these attributes and methods of objects are themselves objects with their own type information.\n",
        "\n",
        "Every object is **first-class** i.e. it can be assigned to a variable, placed in containers, passed as an argument to a function, returned as a value "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UNdwxnVqtfgT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "846d156e-675a-4cba-ce8d-29b2ec0a9712"
      },
      "source": [
        "import math\n",
        "\n",
        "items = [abs, math, ValueError ]\n",
        "\n",
        "print(items)\n",
        "# [<built-in function abs>,\n",
        "#   <module 'math' (builtin)>,\n",
        "#   <type 'exceptions.ValueError'>]\n",
        "\n",
        "print(items[0](-45)) # 45\n",
        "# abs(-12)\n",
        "\n",
        "print(items[1].sqrt(2)) # 1.4142135623730951\n",
        "\n",
        "try:\n",
        "  x = int('not a number')\n",
        "except items[2]:\n",
        "  print('Failed!')\n",
        "# Failed!"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[<built-in function abs>, <module 'math' (built-in)>, <class 'ValueError'>]\n",
            "45\n",
            "1.4142135623730951\n",
            "Failed!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OfMmeEVW74GM"
      },
      "source": [
        "### Object introspection\n",
        "\n",
        "**introspection** is the ability to examine the object at runtime\n",
        "\n",
        "Below are some widely used built-in introspection functions\n",
        "\n",
        "* **`help()`**: returns the Python documentation of a particular object, method, attributes, etc.\n",
        "* **`dir()`**: returns list of attributes and methods belonging to an object\n",
        "* **`type()`**: returns the type of an object\n",
        "* **`isinstance()`**: is a function, returns `True` if the specified object is of the specified type, otherwise `False`\n",
        "* **`id()`**: returns the unique id of the object. This is address of the object being referenced\n",
        "* **`is`**: operator to check if two values are exactly the same object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gPQX7ODGkzI5"
      },
      "source": [
        "# This can be handy when you are not able to recall a method name\n",
        "help(list)\n",
        "\n",
        "a = [1]\n",
        "print(dir(a))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zcy452-_-0HE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "59cb084e-6e3e-4d53-c082-df61f086ec61"
      },
      "source": [
        "print(type(''))\n",
        "# Output: <type 'str'>\n",
        "\n",
        "print(type([]))\n",
        "# Output: <type 'list'>\n",
        "\n",
        "print(type({}))\n",
        "# Output: <type 'dict'>\n",
        "\n",
        "print(type(dict))\n",
        "# Output: <type 'type'>\n",
        "\n",
        "print(type(3))\n",
        "# Output: <type 'int'>"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "<class 'list'>\n",
            "<class 'dict'>\n",
            "<class 'type'>\n",
            "<class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yTno3aL_s4ms",
        "outputId": "8dcc108d-028a-479d-a6e9-fe734320e280"
      },
      "source": [
        "a = [1]\n",
        "if isinstance(a, list):\n",
        "    print('a is a list')\n",
        "\n",
        "a = (1,)\n",
        "if isinstance(a, (list,tuple, int)):\n",
        "    print('a is a list or tuple')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a is a list\n",
            "a is a list or tuple\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fazvy8-p_gmj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a590021-dbc4-45b7-b8a5-5bd3ec57ab14"
      },
      "source": [
        "name = \"siva\"\n",
        "print(id(name))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "140560164770096\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zhUN_EMdopaE",
        "outputId": "d46d639b-5182-49d6-fd6e-09a908a320da"
      },
      "source": [
        "a = [1,2,3]\n",
        "b = a\n",
        "c = [1, 2, 3]\n",
        "print(a is b) # is compares the object identity\n",
        "print(a is c) # is compares the object identity\n",
        "\n",
        "print(id(a))\n",
        "print(id(b))\n",
        "print(id(c))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "1886647078792\n",
            "1886647078792\n",
            "1886647437896\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kwq0uyRYpChh"
      },
      "source": [
        "> It is almost always better to use == for checking objects. The behavior of is is often unexpected"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f2UruRS0pGri",
        "outputId": "4bb8029d-11f4-47f0-cdf2-c3a0585130cc"
      },
      "source": [
        "a = [1,2,3]\n",
        "b = a\n",
        "c = [1,2,3]\n",
        "print(a is b) # True\n",
        "print(a is c) # False\n",
        "print(a == c) # True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a8LDi9Aj_-L2"
      },
      "source": [
        "There are some more built-in introspection functions, modules like `hasattr(), getattr(), issubclass(), isinstance(), sys` module etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5gMvaxz2l2OI"
      },
      "source": [
        "### Assignment\n",
        "\n",
        "Consider this code fragment.\n",
        "\n",
        "```python\n",
        "a = [1,2,3]\n",
        "b = a\n",
        "c = [a,b] # [[1,2,3], [1,2,3]]\n",
        "```\n",
        "\n",
        "A picture of the underlying memory operations. In this example, there\n",
        "is only one list object `[1,2,3]`, but there are four different\n",
        "references to it.\n",
        "\n",
        "![references.png](data:image/png;base64,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)\n",
        "\n",
        "This means that modifying a value affects *all* references.\n",
        "\n",
        "```python\n",
        ">>> a.append(999)\n",
        ">>> a\n",
        "[1,2,3,999]\n",
        ">>> b\n",
        "[1,2,3,999]\n",
        ">>> c\n",
        "[[1,2,3,999], [1,2,3,999]]\n",
        ">>>\n",
        "```\n",
        "\n",
        "> Assignment operations never make a copy of the value being assigned. All assignments are merely reference copies"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BtfeVeAam9MK"
      },
      "source": [
        "### Reassigning values\n",
        "\n",
        "Reassigning a value *never* overwrites the memory used by the previous value.\n",
        "\n",
        "```python\n",
        "a = [1,2,3]\n",
        "b = a\n",
        "a = [4,5,6]\n",
        "\n",
        "print(a)      # [4, 5, 6]\n",
        "print(b)      # [1, 2, 3]    Holds the original value\n",
        "```\n",
        "\n",
        "Remember: **Variables are names, not memory locations.**\n",
        "\n",
        "If you don't know about this sharing, You modify some data thinking that it's your own private copy and it accidentally corrupts some data in some other part of the program."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rB3azgyEp_Vy"
      },
      "source": [
        "### Shallow Copy\n",
        "Lists and dicts have methods for copying"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2NAP0rSCqOTL",
        "outputId": "813a623c-0f97-430a-904f-674b35f51e42"
      },
      "source": [
        "a = [2,3,[100,101],4]\n",
        "b = list(a) # Make a copy\n",
        "a is b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9oZslpCdqajK"
      },
      "source": [
        "It's a new list, but the list items are shared"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qPEH6qhoqbik",
        "outputId": "75cc089f-7673-4596-fe1b-a6fda460d040"
      },
      "source": [
        "a[2].append(102)\n",
        "print(b[2])\n",
        "\n",
        "print(a[2] is b[2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[100, 101, 102]\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6FOBnuQnqnny"
      },
      "source": [
        "the inner list [100, 101, 102] is being shared. This is known as a **shallow copy**\n",
        "\n",
        "![shallow.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s03s1OSsq_LS"
      },
      "source": [
        "### Deep Copy\n",
        "\n",
        "Sometimes you need to make a copy of an object and all the objects contained within it. You can use the `copy` module for this"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JJJ5Y_0TrSJb",
        "outputId": "367b4d86-573c-41e2-eb35-baf2020f7e5e"
      },
      "source": [
        "import copy\n",
        "\n",
        "a = [2,3,[100,101],4]\n",
        "b = copy.deepcopy(a)\n",
        "\n",
        "a[2].append(102)\n",
        "print(b[2]) # [100,101]\n",
        "print(a[2] is b[2]) # False\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[100, 101]\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yt69GZfWuboi"
      },
      "source": [
        "## Functions\n",
        "\n",
        "Definitions\n",
        "\n",
        "**Parameter:** A named entity in the function/method definition that specifies an argument\n",
        "\n",
        "**Argument:** A value passed to a function\n",
        "\n",
        "**Positional arguments**: are arguments that can be passed by their position in the function definition. (order matters)\n",
        "\n",
        "**Keyword arguments**: are arguments that can be passed by their name. (any order). Also called as named arguments\n",
        "\n",
        "**Required arguments**: are arguments that must passed to the function.\n",
        "\n",
        "**Optional/default arguments**: are arguments that can be not passed to the function. In Python, optional arguments are arguments that have a default value\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xr38LQxwzEtM",
        "outputId": "2410b57e-b676-4fe4-a552-69b1cbc58de5"
      },
      "source": [
        "# Function definition\n",
        "def function_name(parameter_1, parameter_2, parameter_3=2, parameter_4=5): # Parameters\n",
        "  print(locals())\n",
        "\n",
        "# Functon call\n",
        "function_name(1, 2) # positonal\n",
        "function_name(1, parameter_3=2, parameter_4=6, parameter_2=3) # positonal, keyword\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'parameter_1': 1, 'parameter_2': 2, 'parameter_3': 2, 'parameter_4': 5}\n",
            "{'parameter_1': 1, 'parameter_2': 3, 'parameter_3': 2, 'parameter_4': 6}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rjS4chBuurIZ"
      },
      "source": [
        "### Variable Arguments\n",
        "\n",
        "In Python, we can pass a variable number of arguments to a function using special symbols. There are two special symbols\n",
        "\n",
        "1. *args (Non Keyword | positonal Arguments)\n",
        "2. **kwargs (Keyword Arguments)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PpY6cdIAu49K"
      },
      "source": [
        "#### Positional arguments\n",
        "\n",
        "A function that accepts *any number* of positional arguments\n",
        "\n",
        "`*args` packs the arguments passed in into a tuple "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sv0n3ogU4m7j",
        "outputId": "d07a1579-1d64-417c-ba74-d829bc969a18"
      },
      "source": [
        "def f(x, *args):\n",
        "  # x -> 1\n",
        "  # args -> (2,3,4,5)\n",
        "  print(locals())\n",
        "  pass\n",
        "\n",
        "f(1,2,3,4,5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'x': 1, 'args': (2, 3, 4, 5)}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mJHPTdVs7RG1"
      },
      "source": [
        "#### Keyword arguments\n",
        "\n",
        "A function that accepts *any number* of keyword arguments\n",
        "\n",
        "`**kwargs` packs the arguments passed in into a `dict`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AKv9OYdF7RnR",
        "outputId": "cdc3f890-ef18-41d7-c032-cfcdd7f8311b"
      },
      "source": [
        "def f(x, y, **kwargs):\n",
        "  # x -> 2\n",
        "  # y -> 3\n",
        "  # kwargs -> { 'flag': True, 'mode': 'fast', 'header': 'debug' }\n",
        "  print(locals())\n",
        "  pass\n",
        "\n",
        "f(2, 3, flag=True, mode='fast', header='debug')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'x': 2, 'y': 3, 'kwargs': {'flag': True, 'mode': 'fast', 'header': 'debug'}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dHRc5zeq8ULE"
      },
      "source": [
        "A function can also accept any number of variable keyword and non-keyword arguments\n",
        "\n",
        "> `args & kwargs` ares just a convention, you can use any other parameter name\n",
        "\n",
        "> There is no concept of `positional` & `keyword parameters`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uAQFzdzp8U8U",
        "outputId": "09676f62-0f0f-41b8-904d-9c34f06237d5"
      },
      "source": [
        "def f(*args, **kwargs):\n",
        "  # x -> 2\n",
        "  # y -> 3\n",
        "  # kwargs -> { 'flag': True, 'mode': 'fast', 'header': 'debug' }\n",
        "  print(locals())\n",
        "  pass\n",
        "\n",
        "f(2, 3, flag=True, mode='fast', header='debug')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'args': (2, 3), 'kwargs': {'flag': True, 'mode': 'fast', 'header': 'debug'}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TmGKR1f55g7-"
      },
      "source": [
        "### Lambda (Anonymous function)\n",
        "\n",
        "In Python, an `anonymous function` is a function that is defined without a name.\n",
        "\n",
        "While normal functions are defined using the `def` keyword in Python, anonymous functions are defined using the `lambda` keyword.\n",
        "\n",
        "Hence, anonymous functions are also called `lambda functions`.\n",
        "\n",
        "```python\n",
        "lambda arguments: expression\n",
        "```\n",
        "\n",
        "`Lambda functions` can have any number of arguments but only one expression. The expression is evaluated and returned. `Lambda functions` can be used wherever function objects are required"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tCOo8ZT3KpK4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d34e5dfd-f598-4404-e5f7-a29e47c081bf"
      },
      "source": [
        "# Program to show the use of lambda functions\n",
        "double = lambda x: x * 2\n",
        "\n",
        "print(double(5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pC0qpQ_WLshq"
      },
      "source": [
        "In Python, we generally use it as an argument to a *higher-order function* (a function that takes in other functions as arguments)\n",
        "\n",
        "`Lambda functions` are used along with built-in functions like `filter()`, `map()` etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_uPdf3naMNaj",
        "outputId": "6b9c068c-9b42-4274-e08a-cda955fa9702"
      },
      "source": [
        "# Program to filter out only the even items from a list\n",
        "my_list = [1, 5, 4, 6, 8, 11, 3, 12]\n",
        "\n",
        "def even(x):\n",
        "  return x%2 == 0\n",
        "\n",
        "iterator = filter(even, my_list) # Filter object\n",
        "# iterator = filter(lambda x: (x%2 == 0), my_list) # Filter object\n",
        "print(list(iterator))\n",
        "new_list = list()\n",
        "\n",
        "print(new_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 6, 8, 12]\n",
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZGOmL-CYbgUI",
        "outputId": "d333b089-5e4a-4035-83be-1e838d5546ef"
      },
      "source": [
        "# Program to double each item in a list using map()\n",
        "\n",
        "my_list = [1, 5, 4, 6, 8, 11, 3, 12]\n",
        "\n",
        "new_list = list(map(lambda x: x * 2 , my_list))\n",
        "\n",
        "print(new_list)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 10, 8, 12, 16, 22, 6, 24]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eRkwB9RLbw-y"
      },
      "source": [
        "**immediately invoked function expression** (IIFE)\n",
        "\n",
        "the function gets immediately executed after creation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6PW5-7XncJq6",
        "outputId": "b0032b8e-13d4-48cb-e0d8-31af809b9120"
      },
      "source": [
        "(lambda x: x*2)(12)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s3ldGS8wcRSC"
      },
      "source": [
        "**Best Practices**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "70cPjM3iJMUZ"
      },
      "source": [
        "#Bad\n",
        "triple = lambda x: x*3\n",
        "\n",
        "#Good\n",
        "def triple(x):\n",
        "     return x*3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m1r24Srqcb-p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3dc70184-1196-4840-cddd-f63d324cf8c0"
      },
      "source": [
        "list_3 = [1, -2, +3, -4]\n",
        "\n",
        "#Bad\n",
        "map(lambda x:abs(x), list_3)\n",
        "\n",
        "#Good\n",
        "map(abs, list_3)\n",
        "\n",
        "#Good\n",
        "map(lambda x: pow(x, 2), list_3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<map at 0x7fd6b6c29ed0>"
            ]
          },
          "metadata": {},
          "execution_count": 277
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UPAF3ePpdWlq"
      },
      "source": [
        "### Closures\n",
        "\n",
        "A function defined inside another function is called a **nested function**. Nested functions can access variables of the enclosing scope\n",
        "\n",
        "In Python, these *non-local variables* are read-only by default and we must declare them explicitly as non-local (using `nonlocal` keyword) in order to modify them"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "un1yJ3g0d1r6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b8bdc983-a643-459e-a1e1-89a051aaa7b5"
      },
      "source": [
        "def print_msg(msg):\n",
        "    # This is the outer enclosing function\n",
        "    a = 'as'\n",
        "    def printer():\n",
        "        # This is the nested function\n",
        "        # nonlocal a\n",
        "        a = 'ab'\n",
        "        print(msg)\n",
        "\n",
        "    printer()\n",
        "    print(a)\n",
        "\n",
        "# We execute the function\n",
        "# Output: Hello\n",
        "print_msg(\"Hello\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello\n",
            "as\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WtY0ELGAegQC"
      },
      "source": [
        "In the example above, what would happen if the last line of the function `print_msg()` returned the `printer()` function instead of calling it?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kpDgU06Bendi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0f5a2291-3e01-4cb7-cabc-ebc781045f82"
      },
      "source": [
        "def print_msg(msg):\n",
        "    # This is the outer enclosing function\n",
        "\n",
        "    def printer():\n",
        "        # This is the nested function\n",
        "        print(msg)\n",
        "\n",
        "    return printer  # returns the nested function\n",
        "\n",
        "\n",
        "# Now let's try calling this function.\n",
        "# Output: Hello\n",
        "another = print_msg(\"Hello\")\n",
        "another()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ksd6WiUMeqRh"
      },
      "source": [
        "When an nested function references a value in its enclosing scope & returned as a result, that nested/inner function is known as a **closure**\n",
        "\n",
        "*Essential feature:* A closure retains the values of all variables needed for the function to run properly later on. Think of a closure as a function plus an extra environment that holds the values of variables that it depends on\n",
        "\n",
        "**The criteria that must be met to create closure in Python are summarized in the following points.**\n",
        "\n",
        "* We must have a nested function (function inside a function).\n",
        "* The nested function must refer to a value defined in the enclosing function.\n",
        "* The enclosing function must return the nested function.\n",
        "\n",
        "**When to use closures?**\n",
        "\n",
        "* **To replace the unnecessary use of class:** Suppose you have a class that contains just one method besides the __init__ method. In such cases, it is often more elegant to use a closure instead of a class.\n",
        "* **To avoid the use of the global scope:** If you have global variables which only one function in your program will use, think closure. Define the variables in the outer function and use them in the inner function.\n",
        "* **To implement data hiding:** The only way to access the enclosed function is by calling the enclosing function. There is no way to access the inner function directly."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s9ji2TJ2EnSg"
      },
      "source": [
        "### partial function\n",
        "\n",
        "`functools` module is for higher-order functions that work on other functions. Using this we can extend the functions without completely rewriting them\n",
        "\n",
        "**Partial function** allow us to fix a certain number of arguments of a function and generate a new function. They can be created in Python by using `partial` class from the functools library"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FLy_NYb0GxgE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17a9898b-f0a4-43c4-ac70-3195eb0483d3"
      },
      "source": [
        "from functools import partial\n",
        "  \n",
        "# A normal function\n",
        "def f(a, b, c, x):\n",
        "    return 1000*a + 100*b + 10*c + x\n",
        "  \n",
        "# A partial function that calls f with\n",
        "# a as 3, b as 1 and c as 4.\n",
        "g = partial(f, 3, 1, 4)\n",
        "  \n",
        "# Calling g()\n",
        "print(g(5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3145\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XRqY7JRHszY7"
      },
      "source": [
        "## Decorators\n",
        "\n",
        "Python has an interesting feature called **`decorators`** to add functionality to an existing code. `decorator takes in a function, adds some functionality and returns it\n",
        "\n",
        "This is also called **metaprogramming** because a part of the program tries to modify another part of the program at compile time"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D2SM0jOBv7Mj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c38e80fc-9ca3-4807-8147-e49527244f8e"
      },
      "source": [
        "# Decorator\n",
        "def make_pretty(func):\n",
        "    def inner():\n",
        "        print(\"I got decorated\")\n",
        "        func()\n",
        "    return inner\n",
        "\n",
        "\n",
        "def ordinary():\n",
        "    print(\"I am ordinary\")\n",
        "\n",
        "ordinary()\n",
        "pretty = make_pretty(ordinary)\n",
        "pretty()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I am ordinary\n",
            "I got decorated\n",
            "I am ordinary\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eIcUIleGw-7F"
      },
      "source": [
        "The special syntax performs the same exact steps as shown above. A `decorator` is just new syntax. It is said to decorate the function\n",
        "\n",
        "This is just a syntactic sugar to implement `decorator`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EdF86f7hxdz2",
        "outputId": "e9149e0a-fd68-43a0-ec23-c680b79f33a5"
      },
      "source": [
        "# Decorator\n",
        "def make_pretty(func):\n",
        "    def inner():\n",
        "        print(\"I got decorated\")\n",
        "        func()\n",
        "    return inner\n",
        "\n",
        "@make_pretty\n",
        "def ordinary():\n",
        "    print(\"I am ordinary\")\n",
        "\n",
        "ordinary()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I got decorated\n",
            "I am ordinary\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OtHfxdc5yT-d"
      },
      "source": [
        "### Decorating Functions with Parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cQV-CaBtyWv0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c46471d8-9472-4c87-871f-048c9ab00a83"
      },
      "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",
        "\n",
        "@smart_divide\n",
        "def divide(a, b):\n",
        "    print(a/b)\n",
        "\n",
        "divide(2,5)\n",
        "divide(2,0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I am going to divide 2 and 5\n",
            "0.4\n",
            "I am going to divide 2 and 0\n",
            "Whoops! cannot divide\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UdUK6c57yknm"
      },
      "source": [
        "### Chaining Decorators\n",
        "\n",
        "A function can be decorated multiple times with different (or same) decorators. We simply place the decorators above the desired function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rNR91r4Vy9jV",
        "outputId": "9e0759a5-c88e-465d-a770-37dea06bae5b"
      },
      "source": [
        "def star(func):\n",
        "    def inner(*args, **kwargs):\n",
        "        print(\"*\" * 30)\n",
        "        func(*args, **kwargs)\n",
        "        print(\"*\" * 30)\n",
        "    return inner\n",
        "\n",
        "\n",
        "def percent(func):\n",
        "    def inner(*args, **kwargs):\n",
        "        print(\"%\" * 30)\n",
        "        func(*args, **kwargs)\n",
        "        print(\"%\" * 30)\n",
        "    return inner\n",
        "\n",
        "\n",
        "@star\n",
        "@percent\n",
        "def printer(msg):\n",
        "    print(msg)\n",
        "\n",
        "printer(\"Hello\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "******************************\n",
            "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
            "Hello\n",
            "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
            "******************************\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "onON5YG9zjvu"
      },
      "source": [
        "### class decorators\n",
        "\n",
        "We can use decorators in classes also. Some commonly used class decorators are \n",
        "\n",
        "* `@staticmethod`: is used to define a so-called static class methods\n",
        "* `@classmethod`: is used to define class methods. A class method is a method that receives the class object as the first parameter instead of the instance\n",
        "* `@property`: is used to create readonly properties"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oCQnMRe6Hvtw"
      },
      "source": [
        "class Foo:\n",
        "    def bar(self,a):\n",
        "        ...\n",
        "\n",
        "    @staticmethod\n",
        "    def spam(a):\n",
        "        ...\n",
        "\n",
        "    @classmethod\n",
        "    def grok(cls,a):\n",
        "        ...\n",
        "\n",
        "    @property\n",
        "    def name(self):\n",
        "        ..."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qd6rpD956MEe"
      },
      "source": [
        "## Sequences\n",
        "\n",
        "Python has three *sequence* datatypes.\n",
        "\n",
        "1. **String**: 'Hello'. A string is a text sequence type\n",
        "2. **List**: [1, 4, 5].\n",
        "3. **Tuple**: ('GOOG', 100, 490.1)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k1TuUnpu8wxO"
      },
      "source": [
        "\n",
        "### Working with Sequences\n",
        "\n",
        "All sequences are ordered, indexed by integers, and have a length"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0BhhTZzf6sDe",
        "outputId": "5faffb77-2dc3-496e-e202-c3175be48b11"
      },
      "source": [
        "a = 'Hello'               # String\n",
        "b = [1, 4, 5]             # List\n",
        "c = ('GOOG', 100, 490.1)  # Tuple\n",
        "\n",
        "# Indexed order\n",
        "a[0]                      # 'H'\n",
        "b[-1]                     # 5\n",
        "c[1]                      # 100\n",
        "\n",
        "# Length of sequence\n",
        "len(a)                    # 5\n",
        "len(b)                    # 3\n",
        "len(c)                    # 3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 286
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9DuQgzOZ65p-"
      },
      "source": [
        "Sequences can be replicated: s * n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k_UrHV286-pl",
        "outputId": "d74f85bc-f1f5-4058-c886-0afc832ffee6"
      },
      "source": [
        "# String\n",
        "a = 'Hello'\n",
        "print(a * 3) # HelloHelloHello\n",
        "\n",
        "# List\n",
        "b = [1, 2, 3]\n",
        "print(b * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
        "\n",
        "# Tuple\n",
        "b = (1, 2, 3)\n",
        "print(b * 3) # (1, 2, 3, 1, 2, 3, 1, 2, 3)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "HelloHelloHello\n",
            "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
            "(1, 2, 3, 1, 2, 3, 1, 2, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mb-rDLq97jqu"
      },
      "source": [
        "Sequences of the same type can be concatenated: s + t"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kK5ssXzJ7k2u",
        "outputId": "33274530-2845-44d4-d1e7-6f32d7999c74"
      },
      "source": [
        "a = (1, 2, 3)\n",
        "b = (4, 5)\n",
        "print(a + b) # (1, 2, 3, 4, 5)\n",
        "\n",
        "c = [1, 5]\n",
        "# print(a + c)\n",
        "# Traceback (most recent call last):\n",
        "#   File \"<stdin>\", line 1, in <module>\n",
        "# TypeError: can only concatenate tuple (not \"list\") to tuple"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "invalid syntax (<ipython-input-43-ce0eb5ed993b>, line 7)",
          "traceback": [
            "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-43-ce0eb5ed993b>\"\u001b[1;36m, line \u001b[1;32m7\u001b[0m\n\u001b[1;33m    Traceback (most recent call last):\u001b[0m\n\u001b[1;37m                         ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uyTY6MaLslsW"
      },
      "source": [
        "Checking if an object is contained within a sequence"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEwldWEjtUKV",
        "outputId": "1cdb01a0-2111-47cf-8e04-de9c0dd47fdd"
      },
      "source": [
        "# using 'in' and 'not in' for membership checking\n",
        "x = (1, 3, 5)\n",
        "\n",
        "print(3 in x) # True\n",
        "\n",
        "print(0 in x) # False\n",
        "\n",
        "print(0 not in x) # True\n",
        "\n",
        "# strings can also test for sub-sequence membership\n",
        "print(\"cat\" in \"the cat in the hat\" ) #True\n",
        "\n",
        "# Like string you cannot test for sub-sequence membership in other types of sequences\n",
        "print([1, 2] in [1, 2, 3, 4]) # False\n",
        "\n",
        "# The list [1, 2] must be an element of the list to be seen as a member\n",
        "print([1, 2] in [None, [1, 2], None]) # True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "atAtA6-KuSFH"
      },
      "source": [
        "Getting the index of the first occurrence of x in a sequence"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QdEnIeizuS-f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5dc62b42-5012-4720-8de1-69a95e903ecd"
      },
      "source": [
        "\"cat cat cat\".index(\"t\")  # 't' first occurs at index-2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yuj3VcJvubsf"
      },
      "source": [
        "Counting the number of occurrences of x in a sequence: seq.count(x)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PsHYRfdhucbY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ef38b8c9-1677-4a07-e967-3210b3b0bd2d"
      },
      "source": [
        "\"the cat in the hat\".count(\"h\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 291
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mDa3_2JR8bVe"
      },
      "source": [
        "### Slicing\n",
        "\n",
        "Slicing means to take a subsequence from a sequence. The syntax is `s[start:end]`. Where start and end are the indexes of the subsequence you want.\n",
        "\n",
        "* Indices `start` and `end` must be integers.\n",
        "* Slices do *not* include the end value. It is like a half-open interval from math.\n",
        "* If indices are omitted, they default to the beginning or end of the list.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5r07eo-q8-pR",
        "outputId": "077c6720-c905-4bbc-806e-3b4e3b478139"
      },
      "source": [
        "a = [0,1,2,3,4,5,6,7,8]\n",
        "\n",
        "a[2:5]    # [2,3,4]\n",
        "a[-5:]    # [4,5,6,7,8]\n",
        "a[:3]     # [0,1,2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2]"
            ]
          },
          "metadata": {},
          "execution_count": 292
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aH55Rflm9Vie"
      },
      "source": [
        "### Slice re-assignment\n",
        "\n",
        "On lists, slices can be reassigned and deleted.\n",
        "\n",
        "> The reassigned slice doesn't need to have the same length."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DNRo79ML9ehu",
        "outputId": "e30678f7-1902-4623-a3ac-3ec1b0bceed2"
      },
      "source": [
        "# Reassignment\n",
        "a = [0,1,2,3,4,5,6,7,8]\n",
        "a[2:4] = [10,11,12, 14]       # [0,1,10,11,12,4,5,6,7,8]\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 10, 11, 12, 14, 4, 5, 6, 7, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sxhr9SRSFSLV",
        "outputId": "9044ea1b-4254-47e6-9a07-6797a4c34075"
      },
      "source": [
        "# Deletion\n",
        "a = [0,1,2,3,4,5,6,7,8]\n",
        "del a[2:4]                # [0,1,4,5,6,7,8]\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 4, 5, 6, 7, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FvmVnDQ_FvEg"
      },
      "source": [
        "### Sequence Reductions\n",
        "\n",
        "There are some common functions like `min, max, sum` to reduce a sequence to a single value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EdTG7mOXF7ON",
        "outputId": "bbd65ce2-6232-4e04-8b92-8e9e04638747"
      },
      "source": [
        "s = [1, 2, 3, 4]\n",
        "print(sum(s))\n",
        "print(min(s))\n",
        "print(max(s))\n",
        "\n",
        "t = ['Hello', 'World']\n",
        "print(max(t))\n",
        "print(min(t))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "1\n",
            "4\n",
            "World\n",
            "Hello\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ydRxtepgUhRH"
      },
      "source": [
        "## Containers\n",
        "\n",
        "A **Container** is an object that is used to store different objects and provide a way to access the contained objects and iterate over them\n",
        "\n",
        "Python has 4 built-in *container* datatypes\n",
        "\n",
        "1. **List**: Ordered data\n",
        "2. **Tuple**: Ordered data (Immutable)\n",
        "3. **Set**: Unordered collection of unique items\n",
        "4. **Dict**: Unordred data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MiRClFt-IpyQ"
      },
      "source": [
        "**Dict**\n",
        "\n",
        "You can look up a value from `dict` that might not exist and provide a default value in case it doesn't using `get()` method\n",
        "\n",
        "The `get()` method is a dictionary method that returns the value of the specified key. If the key is not present it returns either a default value (if passed) or it returns None"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xgEVM1QDJcC3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "11a5281a-3edc-446a-933c-ac69b709e3be"
      },
      "source": [
        "dict_1 = {\"a\": 1, \"b\":2, \"c\":3}\n",
        "if dict_1.get(\"a\") is not None:\n",
        "    print(\"Exists\")\n",
        "else:\n",
        "    print(\"Does not exist\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Exists\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1pfuZdaHKQv5"
      },
      "source": [
        "Almost any type of value can be used as a dictionary key in Python. A dictionary key must be of a type that is immutable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "1QXlp2YTKT4X",
        "outputId": "c48b201e-b546-44c6-cbef-5384a9bfb94d"
      },
      "source": [
        "holidays = {\n",
        "  (1, 1) : 'New Years',\n",
        "  (3, 14) : 'Pi day',\n",
        "  (9, 13) : \"Programmer's day\",\n",
        "}\n",
        "\n",
        "holidays[3, 14]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Pi day'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 297
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "glSD5fSwKoSh"
      },
      "source": [
        "**Set**\n",
        "\n",
        "Sets are also useful for duplicate elimination."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8K3WurneK9z8",
        "outputId": "ade464ca-56dc-42b3-a89d-b17456b197c4"
      },
      "source": [
        "names = ['IBM', 'AAPL', 'GOOG', 'IBM', 'GOOG', 'YHOO']\n",
        "\n",
        "unique = set(names)\n",
        "\n",
        "print(unique) # {'AAPL', 'GOOG', 'YHOO', 'IBM'}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'YHOO', 'IBM', 'AAPL', 'GOOG'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WxDVaLcgEqjG"
      },
      "source": [
        "### Membership Test\n",
        "\n",
        "**Membership testing** means checking if a collection of items (a list, a set, a dictionary, etc.) contains a specific item\n",
        "\n",
        "The **`in`** operator is used to check if a value exists in a `container/sequence` or not. Evaluates to `True` if it finds a value in the specified sequence and `False` otherwise"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7TGXuRYhHE5W",
        "outputId": "563c738c-69d8-42f2-ba8a-6a5f4cad3d7b"
      },
      "source": [
        "# List Membership Test\n",
        "list1=[1,2,3,4,5]\n",
        "list2=[6,7,8,9]\n",
        "\n",
        "for item in list1:\n",
        "    if item in list2: \n",
        "        print(\"overlapping\")     \n",
        "else:\n",
        "    print(\"not overlapping\")\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "not overlapping\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8C3vzklAIe16",
        "outputId": "32dd4279-0697-4f55-97da-69f48329a55b"
      },
      "source": [
        "# Dict Membership Test\n",
        "dict_1 = {\"a\": 1, \"b\":2, \"c\":3}\n",
        "if \"d\" in dict_1:\n",
        "    print(\"Exists\")\n",
        "else:\n",
        "    print(\"Does not exist\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Does not exist\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8gzP_BU3LMhF"
      },
      "source": [
        "> **Sets are highly optimized for membership tests**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UjpgkSR-kAms"
      },
      "source": [
        "### Collections\n",
        "\n",
        "**`collections`** is a module, which provides specialized container datatypes. Some of them are listed below\n",
        "\n",
        "1. **Counter**: `dict` subclass for counting hashable objects\n",
        "2. **OrderedDict**: `dict` subclass that remembers the order entries were added\n",
        "3. **deque**: `list` like container with fast appends and pops on either end"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Hcy2-Jvmn1V"
      },
      "source": [
        "#### Counter\n",
        "\n",
        "A `Counter` is a `dict` subclass for counting hashable objects. It is a collection where elements are stored as dictionary keys and their counts are stored as dictionary values. \n",
        "\n",
        "In a nutshell, Counter takes an iterable (such as a string, a list, or a dict object) and gives the object counts as long as the objects are hashable\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P7fZK_k9vUPs",
        "outputId": "16b27790-a9d4-432a-addc-18acd73c099b"
      },
      "source": [
        "from collections import Counter\n",
        "\n",
        "a_list = [1,2,2,3,4,4,4]\n",
        "a_string = 'data'\n",
        "a_dict = {'a': 5, 'b':3, 'c':5, 'd':5, 'e':1 }\n",
        "\n",
        "#counting objects in a list\n",
        "c_list = Counter(a_list)\n",
        "\n",
        "#counting characters in a string\n",
        "c_string = Counter(a_string)\n",
        "\n",
        "#counting values in a dictionary\n",
        "c_dict = Counter(a_dict.values())\n",
        "\n",
        "print (c_list)\n",
        "print (c_string)\n",
        "print (c_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Counter({4: 3, 2: 2, 1: 1, 3: 1})\n",
            "Counter({'a': 2, 'd': 1, 't': 1})\n",
            "Counter({5: 3, 3: 1, 1: 1})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2DjzXE2qv4ys"
      },
      "source": [
        "> Please note that you get an error if an element inside the container object is an unhashable type such as a list object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hF07Z5fCv7N7"
      },
      "source": [
        "from collections import Counter\n",
        "\n",
        "a_list  = [1,2,[5,6,7,7],2,3,4,4,4]\n",
        "\n",
        "#counting objects in a list\n",
        "# c_list = Counter(a_list)\n",
        "\n",
        "# print (c_list)\n",
        "# TypeError: unhashable type: 'list'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ClWDvcQ5wLK8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dd27b543-e34f-4521-8796-70fc40007597"
      },
      "source": [
        "from collections import Counter\n",
        "\n",
        "a_list  = [1,2,[5,6,7,7],2,3,4,4,4]\n",
        "\n",
        "# converting any list element into the tuple before passing the object to the Counter class\n",
        "c_list = Counter(tuple(item) if type(item) is list else item for item in a_list)\n",
        "\n",
        "print (c_list) # Counter({4: 3, 2: 2, 1: 1, (5, 6, 7, 7): 1, 3: 1})"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Counter({4: 3, 2: 2, 1: 1, (5, 6, 7, 7): 1, 3: 1})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZlcIOgmFmek4"
      },
      "source": [
        "### List comprehension\n",
        "\n",
        "**List comprehension** is basically creating lists based on existing iterables (`lists, string, tuple` etc.)\n",
        "\n",
        "List comprehension is generally more compact and faster than normal functions and loops for creating list\n",
        "\n",
        "**General Syntax**\n",
        "```python\n",
        "[ <expression> for <variable_name> in <sequence> ]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "39qBBlbCpWxg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "20a93d33-cc2a-417e-aa25-0c4976089187"
      },
      "source": [
        "# Iterating through a string\n",
        "\n",
        "h_letters = []\n",
        "\n",
        "for letter in 'human':\n",
        "    h_letters.append(letter)\n",
        "\n",
        "print(h_letters)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['h', 'u', 'm', 'a', 'n']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YhjDrfNDpaLK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c39d3d99-4c6b-4820-da52-a3ecca30169c"
      },
      "source": [
        "h_letters = [ letter for letter in 'human' ]\n",
        "print( h_letters)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['h', 'u', 'm', 'a', 'n']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "87s5559cqExo"
      },
      "source": [
        "List comprehensions can utilize conditional statement"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wtdx6fpnqNcB",
        "outputId": "26d90626-f26a-4873-8069-66f5b84b220e"
      },
      "source": [
        "# Getting even numbers\n",
        "\n",
        "number_list = [ x for x in range(20) if x % 2 == 0]\n",
        "print(number_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EvWaeiReqwxw"
      },
      "source": [
        "Nested Loops in List Comprehension"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bo-S8dzlqzs5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "10cbae5e-6bf5-4197-8897-6412eddc1faa"
      },
      "source": [
        "# Transpose of a Matrix\n",
        "\n",
        "matrix = [[1, 2], [3,4], [5,6], [7,8]]\n",
        "transpose = [[row[i] for row in matrix] for i in range(2)]\n",
        "print (transpose)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1, 3, 5, 7], [2, 4, 6, 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TiFFJEwaq69C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ed7ff543-8fec-40c2-f6e8-00d0e383a648"
      },
      "source": [
        "transposed = []\n",
        "matrix = [[1, 2, 3, 4], [4, 5, 6, 8]]\n",
        "\n",
        "for i in range(len(matrix[0])):\n",
        "    transposed_row = []\n",
        "\n",
        "    for row in matrix:\n",
        "        transposed_row.append(row[i])\n",
        "    transposed.append(transposed_row)\n",
        "\n",
        "print(transposed)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1, 4], [2, 5], [3, 6], [4, 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qq0xbwuRsWcr"
      },
      "source": [
        "> Set & Dict comprehension are also possible same like list. There is no tuple comprehension"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gn_sQ2AKsosJ",
        "outputId": "ebd3d8bf-019c-43c9-e3b7-b95fc71a87da"
      },
      "source": [
        "[i for i in [1, 2, 3, 4]] # List comprehension\n",
        "\n",
        "{i:j for i, j in {1: 'a', 2: 'b'}.items()} # Dict comprehension\n",
        "\n",
        "{i for i in [1, 2, 3, 3,  4]} # Set comprehension"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1, 2, 3, 4}"
            ]
          },
          "metadata": {},
          "execution_count": 309
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RftZA1Uy1WjN"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bHewescizwT0"
      },
      "source": [
        "## Methods of Sequences & Containers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ag4Ag2qwzzQa"
      },
      "source": [
        "### Some methods on string objects\n",
        "\n",
        "- **`.capitalize()`** to return a capitalized version of the string (only first char uppercase)\n",
        "- **`.upper()`** to return an uppercase version of the string (all chars uppercase)\n",
        "- **`.lower()`** to return an lowercase version of the string (all chars lowercase)\n",
        "- **`.count(substring)`** to return the number of occurences of the substring in the string\n",
        "- **`.startswith(substring)`** to determine if the string starts with the substring\n",
        "- **`.endswith(substring)`** to determine if the string ends with the substring\n",
        "- **`.replace(old, new, count)`** to return a copy of the string with occurences of the `old` replaced by `new`. `count` – the number of times you want to replace the old substring with the new substring\n",
        "- **`.join(iterable)`** to join the elemnts of the iterable. Returns string\n",
        "- **`.split(separator, maxsplit)`** to split a string into a list of strings after breaking the given string by the specified separator\n",
        "- **`.strip([chars])`** to remove both leading and trailing characters. `chars` - a string specifying the set of characters to be removed"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rcnUl2TNz2R5"
      },
      "source": [
        "# Assign a string to a variable\n",
        "a_string = 'tHis is a sTriNg'\n",
        "\n",
        "# Return a capitalized version of the string\n",
        "print(a_string.capitalize()) # This is a string\n",
        "\n",
        "# Return an uppercase version of the string\n",
        "print(a_string.upper()) # THIS IS A STRING\n",
        "\n",
        "# Return a lowercase version of the string\n",
        "print(a_string.lower()) # this is a string\n",
        "\n",
        "# Notice that the methods called have not actually modified the string\n",
        "print(a_string) # tHis is a sTriNg\n",
        "\n",
        "# Count number of occurences of a substring in the string\n",
        "print(a_string.count('i')) # 3\n",
        "\n",
        "# Count number of occurences of a substring in the string after a certain position\n",
        "print(a_string.count('i', 7)) # 1\n",
        "\n",
        "# Count number of occurences of a substring in the string\n",
        "print(a_string.count('is')) # 2\n",
        "\n",
        "# Does the string start with 'this'?\n",
        "print(a_string.startswith('this')) # False\n",
        "\n",
        "# Does the lowercase string start with 'this'?\n",
        "print(a_string.lower().startswith('this')) # True\n",
        "\n",
        "# Does the string end with 'Ng'?\n",
        "print(a_string.endswith('Ng')) # True\n",
        "\n",
        "# Return a version of the string with a substring replaced with something else\n",
        "print(a_string.replace('is', 'XYZ')) # tHXYZ XYZ a sTriNg\n",
        "\n",
        "# Return a version of the string with a substring replaced with something else\n",
        "print(a_string.replace('i', '!')) # tH!s !s a sTr!Ng\n",
        "\n",
        "# Return a version of the string with the first 2 occurences a substring replaced with something else\n",
        "print(a_string.replace('i', '!', 2)) # tH!s !s a sTriNg\n",
        "\n",
        "list1 = ['1','2','3','4'] \n",
        "# joins elements of list1 by '-'\n",
        "# and stores in sting s\n",
        "s = '-'.join(list1)\n",
        "\n",
        "# Joining with empty separator\n",
        "list1 = ['S','R','I','-', 'B'] \n",
        "print(\"\".join(list1)) # SRI-B\n",
        "\n",
        "# Splits at space\n",
        "text = 'I am from SE'\n",
        "print(text.split()) # ['I', 'am', 'from', 'SE']\n",
        "  \n",
        "# Splits at ','\n",
        "word = 'I, am, from, SE'  \n",
        "print(word.split(',')) # ['I', ' am', ' from', ' SE']\n",
        "\n",
        "# maxsplit: 0\n",
        "print(word.split(', ', 0)) # ['I, am, from, SE']\n",
        "\n",
        "# maxsplit: 1\n",
        "print(word.split(', ', 1)) # ['I', 'am, from, SE']\n",
        "\n",
        "string = \"\"\"Hi!    SRI-B    \"\"\"\n",
        " \n",
        "# prints the string by removing leading and trailing whitespaces\n",
        "print(string.strip()) # Hi!    SRI-B\n",
        "\n",
        "print(string.strip('H!')) # i!    SRI-B   "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dx5vti_nz3L0"
      },
      "source": [
        "### Some methods on list objects\n",
        "\n",
        "- **`.append(item)`** to add a single item to the list\n",
        "- **`.extend([item1, item2, ...])`** to add multiple items to the list\n",
        "- **`.remove(item)`** to remove a single item from the list\n",
        "- **`.pop()`** to remove and return the item at the end of the list\n",
        "- **`.pop(index)`** to remove and return an item at an index"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ID_gW1K2z547"
      },
      "source": [
        "### Some methods on set objects\n",
        "\n",
        "- **`.add(item)`** to add a single item to the set\n",
        "- **`.update([item1, item2, ...])`** to add multiple items to the set\n",
        "- **`.update(set2, set3, ...)`** to add items from all provided sets to the set\n",
        "- **`.remove(item)`** to remove a single item from the set\n",
        "- **`.pop()`** to remove and return a random item from the set\n",
        "- **`.difference(set2)`** to return items in the set that are not in another set\n",
        "- **`.intersection(set2)`** to return items in both sets\n",
        "- **`.union(set2)`** to return items that are in either set\n",
        "- **`.symmetric_difference(set2)`** to return items that are only in one set (not both)\n",
        "- **`.issuperset(set2)`** does the set contain everything in the other set?\n",
        "- **`.issubset(set2)`** is the set contained in the other set?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CY2R08X4z7uJ"
      },
      "source": [
        "### Some methods on dict objects\n",
        "\n",
        "- **`.update([(key1, val1), (key2, val2), ...])`** to add multiple key-value pairs to the dict\n",
        "- **`.update(dict2)`** to add all keys and values from another dict to the dict\n",
        "- **`.pop(key)`** to remove key and return its value from the dict (error if key not found)\n",
        "- **`.pop(key, default_val)`** to remove key and return its value from the dict (or return default_val if key not found)\n",
        "- **`.get(key)`** to return the value at a specified key in the dict (or None if key not found)\n",
        "- **`.get(key, default_val)`** to return the value at a specified key in the dict (or default_val if key not found)\n",
        "- **`.keys()`** to return a list of keys in the dict\n",
        "- **`.values()`** to return a list of values in the dict\n",
        "- **`.items()`** to return a list of key-value pairs (tuples) in the dict"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hCA1qlaADJcw"
      },
      "source": [
        "## Classes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7PuxtQ9cDOo1"
      },
      "source": [
        "### Object Oriented (OO) programming\n",
        "\n",
        "Python is an object-oriented programming language. Unlike procedure-oriented programming, where the main emphasis is on functions, object-oriented programming stresses on objects\n",
        "\n",
        "We have already been using OO. For example, manipulating a list\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IfPbSFOBD8d-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d4c976ad-8123-4897-a710-11997c541ec3"
      },
      "source": [
        "nums = [1, 2, 3] # nums is an instance of a list\n",
        "nums.append(4)      # Method\n",
        "nums.insert(1,10)   # Method\n",
        "nums # [1, 10, 2, 3, 4]  # Data"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 10, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jmFR8_X_Ea-2"
      },
      "source": [
        "A **class** is a user-defined blueprint or prototype from which objects are created\n",
        "\n",
        "Use the `class` keyword to define a class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5r0yU6lOGdB-"
      },
      "source": [
        "class Player:\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "    self.health = 100\n",
        "\n",
        "  def move(self, dx, dy):\n",
        "    self.x += dx\n",
        "    self.y += dy\n",
        "    print(self.x, self.y)\n",
        "\n",
        "  def damage(self, pts):\n",
        "    self.health -= pts"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S14ZcXqWJX5P"
      },
      "source": [
        "Class creates a user-defined data structure, which holds its own data members and member functions, which can be accessed and used by creating an instance of that class\n",
        "\n",
        "An object is also called an **instance of a class** and the process of creating this object is called **instantiation** (copy of the class with actual values)\n",
        "\n",
        "we can create many objects from a class\n",
        "\n",
        "An *object* consists of:\n",
        "\n",
        "* **Data/State**: represented by the *attributes* (variables in the class)\n",
        "* **Behavior**: represented by *methods* which are functions act on data\n",
        "* **Identity**: It gives a unique name to an object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rfRmOxNKJtkg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "67854ab3-99c1-4c49-c372-4e53615380cf"
      },
      "source": [
        "a = Player(2, 3)\n",
        "b = Player(10, 20)\n",
        "print(a, b) # a and b are instances of Player"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.Player object at 0x7f7ae8a42c50> <__main__.Player object at 0x7f7ae8a42f90>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zsKv4CqgVIpL"
      },
      "source": [
        "Attributes & methods are always public and can be accessed using the dot `.` operator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SxxeMjC_VbdA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8f1c35a-8993-4c05-b4da-734e754911e7"
      },
      "source": [
        "a.x # Getting attribute value\n",
        "a.move(3, 4) # Calling method"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6 9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SbEIsm9sNJOO"
      },
      "source": [
        "### Instance attributes\n",
        "\n",
        "Each instance has its own attributes\n",
        "\n",
        "Instance Attributes are unique to each instance, (an instance is another name for an object). Every object/instance has its own attribute and can be changed without affecting other instance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fyZPqIg6Ol35",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f461bf8c-58c6-4f78-c2ec-89f062c16f18"
      },
      "source": [
        "print(a.x)\n",
        "print(b.x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xCDNAotZRuCw"
      },
      "source": [
        "This data is initialized by the __init__()\n",
        "\n",
        "> Any value stored on `self` is instance data\n",
        "\n",
        "```python\n",
        "class Player:\n",
        "  def __init__(self, x, y):\n",
        "    # Any value stored on `self` is instance data\n",
        "    self.x = x \n",
        "    self.y = y\n",
        "    self.health = 100\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9iHSNDOlSlyf"
      },
      "source": [
        "### Instance Methods\n",
        "\n",
        "Instance methods are functions applied to instances of an object\n",
        "\n",
        "> Any class function which has `self` as first parameter is instance method\n",
        "\n",
        "```python\n",
        "class Player:\n",
        "    ...\n",
        "    # `move` is a instance method\n",
        "    def move(self, dx, dy):\n",
        "        self.x += dx\n",
        "        self.y += dy\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D9y_5JecTbmn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f11b1739-27e7-47f6-ab5c-a6febd92972f"
      },
      "source": [
        "a.move(1, 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CHf_O8xHU3cB"
      },
      "source": [
        "### self\n",
        "`self` represents the instance of the class. This is always pointing to *Current Object*."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "75X7HGHeWydv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "06616a23-ec41-4d3f-9aea-397e1f7ca069"
      },
      "source": [
        "#it is clearly seen that self and obj is referring to the same object\n",
        " \n",
        "class check:\n",
        "    def __init__(self):\n",
        "        print(\"Address of self = \",id(self))\n",
        " \n",
        "obj = check()\n",
        "print(\"Address of class object = \",id(obj))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Address of self =  140165865918864\n",
            "Address of class object =  140165865918864\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0XUvsjdcXddK"
      },
      "source": [
        "since the `class` is just a blueprint, `self` allows access to the attributes and methods of each object inside the class. This allows each object to have its own attributes and methods"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rLHn4-e1YQHX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9be3884b-2c90-4cf2-ee6e-4f8080fc4735"
      },
      "source": [
        "class car():\n",
        "     \n",
        "  def __init__(self, model, color):\n",
        "    self.model = model\n",
        "    self.color = color\n",
        "        \n",
        "  def show(self):\n",
        "    print(\"Model is\", self.model )\n",
        "    print(\"color is\", self.color )\n",
        "         \n",
        "# both objects have different self which contain their attributes\n",
        "audi = car(\"audi a4\", \"blue\")\n",
        "ferrari = car(\"ferrari 488\", \"green\")\n",
        " \n",
        "audi.show()     # same output as car.show(audi)\n",
        "ferrari.show()  # same output as car.show(ferrari)\n",
        " \n",
        "# Behind the scene, in every instance method call, python sends the instances also with that method call like car.show(audi)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model is audi a4\n",
            "color is blue\n",
            "Model is ferrari 488\n",
            "color is green\n",
            "Model is audi a4\n",
            "color is blue\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QWXgaHu2ZlG5"
      },
      "source": [
        "### Constructor\n",
        "\n",
        "\\_\\_init__() is aspecial function gets called whenever a new object of that class is instantiated\n",
        "\n",
        "This type of function is also called **constructors** in Object Oriented Programming (OOP). We normally use it to initialize all the variables\n",
        "\n",
        "Technically speaking, a constructor is a method which creates the object itself. In Python, this method is __new__(). A common signature of this method is:\n",
        "\n",
        "`__new__(cls, *args, **kwargs)`\n",
        "\n",
        "override `__new__` inside the class to restrict the number of objects created from a class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2aLrvCFDcy_b"
      },
      "source": [
        "class SqPoint:\n",
        "    MAX_Inst = 1\n",
        "    Inst_created = 0\n",
        "\n",
        "    def __new__(cls, *args, **kwargs):\n",
        "        if (cls.Inst_created >= cls.MAX_Inst):\n",
        "            raise ValueError(\"Cannot create more objects\")\n",
        "        cls.Inst_created += 1\n",
        "        return super(SqPoint, cls).__new__(cls, *args, **kwargs)\n",
        "\n",
        "p1 = SqPoint(0,0)\n",
        "# p2 = SqPoint(1,0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LlfnsEariEAo"
      },
      "source": [
        "### Destructor \n",
        "\n",
        "**Destructor** is called when all references to the object have been deleted\n",
        "\n",
        "The `__del__()` method is a known as a destructor method in Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lGWR9b5cic4Z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "28509db9-ea40-4dca-c1f9-2551c4119ff7"
      },
      "source": [
        "class Employee:\n",
        "  \n",
        "  # Initializing\n",
        "  def __init__(self):\n",
        "    print('Employee created.')\n",
        "\n",
        "  # Deleting (Calling destructor)\n",
        "  def __del__(self):\n",
        "    print('Destructor called, Employee deleted.')\n",
        "  \n",
        "obj = Employee()\n",
        "del obj"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Employee created.\n",
            "Destructor called, Employee deleted.\n",
            "Destructor called, Employee deleted.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZkRGz3VNf1mV"
      },
      "source": [
        "### Class attributes\n",
        "\n",
        "**class attributes** are shared by all instances of the class. *Instance attributes* are variables whose value is assigned inside a `constructor` or `method` with `self` whereas class variables are variables whose value is assigned in the class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gAtLRoG3fNYY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9fb43a99-94a4-4980-8106-d4ce18f53814"
      },
      "source": [
        "# declare a class\n",
        "class Employee:\n",
        "\t\n",
        "\t# class attribute\n",
        "\tcount = 0\t\n",
        "\t\t\n",
        "\t# define a method\n",
        "\tdef increase(self):\n",
        "\t\tEmployee.count += 1\n",
        "\t\n",
        "# create an Employee\n",
        "# class object\n",
        "a1 = Employee()\n",
        "\n",
        "# calling object's method\n",
        "a1.increase()\n",
        "\n",
        "# print value of class attribute\n",
        "print(a1.count)\n",
        "\t\n",
        "a2 = Employee()\n",
        "\n",
        "a2.increase()\n",
        "\n",
        "print(a2.count)\n",
        "\t\n",
        "print(Employee.count)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vT-kPc5ekBux"
      },
      "source": [
        "### Class methods\n",
        "\n",
        "A class method is a method that is bound to a class rather than its object. \n",
        "\n",
        "It doesn't require creation of a class instance. So, they are not dependent on the state of the object\n",
        "\n",
        "Class methods can be called by both class and object\n",
        "\n",
        "We use `@classmethod` decorator to create a class method"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F8ejocAelO3z"
      },
      "source": [
        "### Static methods\n",
        "\n",
        "Static methods, much like class methods, are methods that are bound to a class rather than its object\n",
        "\n",
        "we use `@staticmethod` decorator to create a static method"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AasmD7rFlRgS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9fe3d9e7-3307-4041-cac7-614dea3a89b4"
      },
      "source": [
        "from datetime import date\n",
        "  \n",
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "  # a class method to create a\n",
        "  # Person object by birth year.\n",
        "  @classmethod\n",
        "  def fromBirthYear(cls, name, year):\n",
        "    return cls(name, date.today().year - year)\n",
        "  # Above method is also called Factory method. Factory methods are those methods that return a class object\n",
        "\n",
        "  # a static method to check if a\n",
        "  # Person is adult or not.\n",
        "  @staticmethod\n",
        "  def isAdult(age):\n",
        "    return age > 18\n",
        "  \n",
        "person1 = Person('mayank', 21)\n",
        "person2 = Person.fromBirthYear('mayank', 1996)\n",
        "  \n",
        "print(person1.age)\n",
        "print(person2.age)\n",
        "  \n",
        "# print the result\n",
        "print(Person.isAdult(22))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "21\n",
            "25\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ioxakMssmKRA"
      },
      "source": [
        "**Class method vs Static Method**\n",
        "* A `class method` takes `cls` as the first parameter while a static method needs no specific parameters.\n",
        "* A `class method` can access or modify the class state while a `static method` can’t access or modify it.\n",
        "* In general, `static methods` know nothing about the class state. They are utility-type methods that take some parameters and work upon those parameters. On the other hand class methods must have class as a parameter."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v7s6APPUmTd2"
      },
      "source": [
        "### Inheritance\n",
        "\n",
        "**Inheritance** is the capability of one class to derive or inherit the properties from another class. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8AmxgoeDrJ5k"
      },
      "source": [
        "class Parent:\n",
        "    ...\n",
        "\n",
        "class Child(Parent):\n",
        "    ..."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PMGocOA3rPfN"
      },
      "source": [
        "The new class `Child` is called a **derived class** or **subclass**.  The\n",
        "`Parent` class is known as **base class** or **superclass**.  `Parent` is\n",
        "specified in `()` after the class name, `class Child(Parent):`.\n",
        "\n",
        "With inheritance, you are taking an existing class and:\n",
        "\n",
        "* Adding new methods\n",
        "* Redefining some of the existing methods\n",
        "* Adding new attributes to instances\n",
        "\n",
        "In the end you are **extending existing code**.\n",
        "\n",
        "`object` is the parent of all objects in Python\n",
        "\n",
        "In Python 3.x `class Person` is equivalent to `class Person(object)`\n",
        "\n",
        "If omitted, the class still implicitly inherits from object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RPuftQtkmpiU",
        "outputId": "6be8ece3-5f2e-4c72-a13f-7d645778eef2"
      },
      "source": [
        "# Base or Super class. Note object in bracket.\n",
        "class Person(object):\n",
        "       \n",
        "    # Constructor\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "   \n",
        "    # To get name\n",
        "    def getName(self):\n",
        "        return self.name\n",
        "   \n",
        "    # To check if this person is an employee\n",
        "    def isEmployee(self):\n",
        "        return False\n",
        "\n",
        "    def dummy(self):\n",
        "        print(\"Parent dummy method\") \n",
        "   \n",
        "# Inherited or Subclass (Note Person in bracket)\n",
        "class Employee(Person):\n",
        "\n",
        "    # Constructor\n",
        "    def __init__(self, name, id):\n",
        "        super().__init__(name)\n",
        "        self.id = id # Adding new attribute\n",
        "\n",
        "    # Adding new method\n",
        "    def isPerson(self):\n",
        "      return True\n",
        "   \n",
        "    # Redefining an existing method\n",
        "    # Mehod overriding\n",
        "    def isEmployee(self):\n",
        "        return True\n",
        "\n",
        "    # To get name\n",
        "    def getName(self):\n",
        "        name = super().getName()\n",
        "        return f\"{self.name} ({self.id})\"\n",
        "   \n",
        "# Driver code\n",
        "pers = Person(\"person\")  # An Object of Person\n",
        "print(pers.getName())\n",
        "print(pers.isEmployee())\n",
        "print(pers.dummy())\n",
        "   \n",
        "emp = Employee(\"employee\", 55555) # An Object of Employee\n",
        "print(emp.dummy())\n",
        "print(emp.getName())\n",
        "print(emp.isEmployee())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "person\n",
            "False\n",
            "Parent dummy method\n",
            "None\n",
            "Parent dummy method\n",
            "None\n",
            "employee (55555)\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xo2UUnrQz9gs"
      },
      "source": [
        "#### super()\n",
        "`super()` provides the access to those methods of the super-class (parent class) which have been overridden in a sub-class (child class) that inherits from it\n",
        "\n",
        "We can use `self` to access parent class methods & attributes which are not overridden"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4MnkyyVZ1BiF"
      },
      "source": [
        "#### Different forms of Inheritance\n",
        "\n",
        "1. **Single inheritance:** When a child class inherits from only one parent class, it is called single inheritance. We saw an example above.\n",
        "2. **Multiple inheritance:** When a child class inherits from multiple parent classes, it is called multiple inheritance. \n",
        "Unlike Java and like C++, Python supports multiple inheritance. We specify all parent classes as a comma-separated list in the bracket.\n",
        "3. **Multilevel inheritance:** When we have a child and grandchild relationship\n",
        "4. **Hierarchical inheritance:** More than one derived classes are created from a single base.\n",
        "5. **Hybrid inheritance:** This form combines more than one form of inheritance. Basically, it is a blend of more than one type of inheritance.\n",
        "\n",
        "![unnamed.jpg](data:image/jpeg;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HAyyhBEUQmZQ"
      },
      "source": [
        "### Encapsulation\n",
        "\n",
        "By default all the members of the class are `public`\n",
        "\n",
        "Encapsulation is a way to ensure security. This puts restrictions on accessing variables and methods directly and can prevent the accidental modification of data\n",
        "\n",
        "1. **private**: You can make any members of the class `private` using `__` prefix\n",
        "Private members in python is more or less a hack: the interpreter intentionally renames (mangles) the variables & methods. The Python interpreter rewrites any identifier with `__var` as `_ClassName__var`\n",
        "\n",
        "2. **protected**: You can make any members of the class `protected` usinfg `_` prefix. This is just as a coding convention, it tells that you should use these attributes/methods within the scope of the class. But you can still access the variables and methods which are defined as protected, as usual\n",
        "\n",
        "> You don't play around with another class's members that look like `__foo` or `_bar`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NA2HjwqzSCmM",
        "outputId": "8e096ab9-2b5a-4f28-8d60-25a0632409bf"
      },
      "source": [
        "class A:\n",
        "    def __init__(self):\n",
        "        self.__b = 123\n",
        "        self._a = 5\n",
        "    def printB(self):\n",
        "        print(self.__b)\n",
        "\n",
        "x = A()\n",
        "\n",
        "# print(x.__b)\n",
        "print(x._a)\n",
        "print(x.printB())\n",
        "print( x.__dict__) # this will show everything that is contained in object x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "123\n",
            "None\n",
            "{'_A__b': 123, '_a': 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YQzqJxyJZtwX"
      },
      "source": [
        "### Polymorphism\n",
        "Polymorphism simply means having many forms. For example, we need to determine if the given species of birds fly or not, using polymorphism we can do this using a single function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QgtH1imIZ8uB",
        "outputId": "74b1e17e-156a-4a14-a663-f66aef8c94d1"
      },
      "source": [
        "class Bird:\n",
        "    \n",
        "    def intro(self):\n",
        "        print(\"There are many types of birds.\")\n",
        "  \n",
        "    def flight(self):\n",
        "        print(\"Most of the birds can fly but some cannot.\")\n",
        "  \n",
        "class sparrow(Bird):\n",
        "    \n",
        "    def flight(self):\n",
        "        print(\"Sparrows can fly.\")\n",
        "  \n",
        "class ostrich(Bird):\n",
        "  \n",
        "    def flight(self):\n",
        "        print(\"Ostriches cannot fly.\")\n",
        "  \n",
        "obj_bird = Bird()\n",
        "obj_spr = sparrow()\n",
        "obj_ost = ostrich()\n",
        "  \n",
        "obj_bird.intro()\n",
        "obj_bird.flight()\n",
        "  \n",
        "obj_spr.intro()\n",
        "obj_spr.flight()\n",
        "  \n",
        "obj_ost.intro()\n",
        "obj_ost.flight()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "There are many types of birds.\n",
            "Most of the birds can fly but some cannot.\n",
            "There are many types of birds.\n",
            "Sparrows can fly.\n",
            "There are many types of birds.\n",
            "Ostriches cannot fly.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V7s7i2Lhr9Ho"
      },
      "source": [
        "## Iterables\n",
        "\n",
        "**Iteration** is a general term for taking each item of something, one after another\n",
        "\n",
        "An **`Iterable`** is an object that can be looped over (`list, tuple, string, dict, set`)\n",
        "\n",
        "`Iterable` object follows *iteration protocol*. It contains either `__iter__` or `__getitem__`\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iuOHnELAyC1p",
        "outputId": "4acace7b-a1f1-4fc6-8b0f-fb2bf8ed3e8f"
      },
      "source": [
        "a = [1, 2]\n",
        "print(dir(a)) # Iterbale"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VjUYIjvX1QAq"
      },
      "source": [
        "### Iterators\n",
        "\n",
        "An **`Iterator`** is an object with state that remembers where it is during iteration\n",
        "\n",
        "`Iterator` object follows *iterator protocol*. It contains `__next__` & `__iter__` methods\n",
        "\n",
        "Calling `__iter__` method of `iterable` object returns the `iterator` object\n",
        "\n",
        "Calling `__next__` method of `iterator` object returns the next value in the iteration\n",
        "\n",
        "* `iterable` is an object it can be used in iteration\n",
        "\n",
        "* While `iterator` is an object that defines how to actually do the iteration, specifically what is the next element\n",
        "\n",
        ">  `iterator` is self-iterable (meaning that it has an `__iter__` method that returns `self`)\n",
        "\n",
        "> There are 2 builtin functions `iter` & `next`\n",
        "> * Calling `iter(iterable)` function in turn calls `__iter__` method\n",
        "> * Calling `next(iterator)` function in turn calls `__next__` method"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cxFv1nXs5Voj",
        "outputId": "e7b448e5-450d-4461-c993-c95084818c23"
      },
      "source": [
        "s = 'cat'     # s is an ITERABLE\n",
        "              # s is a str object that is immutable\n",
        "              # s has no state\n",
        "              # s has a __getitem__() method \n",
        "\n",
        "t = iter(s)   # t is an ITERATOR\n",
        "              # t has state (it starts by pointing at the \"c\"\n",
        "              # t has a next() method and an __iter__() method\n",
        "\n",
        "next(t)       # the next() function returns the next value and advances the state\n",
        "# 'c'\n",
        "\n",
        "next(t)       # the next() function returns the next value and advances\n",
        "# 'a'\n",
        "\n",
        "next(t)       # the next() function returns the next value and advances\n",
        "# 't'\n",
        "\n",
        "iter(t) is t   # the iterator is self-iterable\n",
        "\n",
        "# next(t)       # next() raises StopIteration to signal that iteration is complete\n",
        "# Traceback (most recent call last):\n",
        "# ...\n",
        "# StopIteration\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 311
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nneApJdi_Iv1"
      },
      "source": [
        "Iterators can be materialized as lists or tuples by using the `list()` or `tuple()` constructor functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XzsMAaFT_PTU",
        "outputId": "62c64637-1de9-42cd-e9fb-398f11ab0a50"
      },
      "source": [
        "l1=[1,2,3,4,5] #Converting to iterator object\n",
        "\n",
        "l2=iter(l1) #Converting iterator(l2) to tuple using tuple() constructor\n",
        "\n",
        "t1=tuple(l2)\n",
        "\n",
        "print (t1) # (1, 2, 3, 4, 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3, 4, 5)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OPvRzxSy-B6l"
      },
      "source": [
        "### Limits of Iterator\n",
        "* We can only go forward in an iterator.\n",
        "* We can’t make a copy of it.\n",
        "* No way to get the previous element.\n",
        "* We can’t reset the iterator\n",
        "\n",
        "> The `itertools` module contains a number of commonly-used iterators as well as functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gFtp0aYm82fU"
      },
      "source": [
        "### 'for' internals\n",
        "\n",
        "Whenever you use a `for` loop, or `map`, or a `list comprehension`, etc. in Python, the next method is called automatically to get each item from the iterator, thus going through the process of iteration\n",
        "Consider the `for`-statement.\n",
        "\n",
        "```python\n",
        "for x in obj:\n",
        "    # statements\n",
        "```\n",
        "\n",
        "What happens under the hood?\n",
        "\n",
        "```python\n",
        "_iter = obj.__iter__()        # Get iterator object\n",
        "while True:\n",
        "    try:\n",
        "        x = _iter.__next__()  # Get next item\n",
        "        # statements ...\n",
        "    except StopIteration:     # No more items\n",
        "        break\n",
        "```\n",
        "\n",
        "All the objects that work with the `for-loop` implement this low-level\n",
        "iteration protocol.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lkfT3rvaN5TH"
      },
      "source": [
        "## Generators\n",
        "\n",
        "A `generator` is a function that returns an `iterator object` which we can iterate over (one value at a time)\n",
        "\n",
        "Normal functions return a single value using `return`. However, there is an alternative, called `yield`. Using one or more `yield` expressions anywhere in a function makes it a `generator`\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "Suppose you wanted to create your own custom iteration pattern.\n",
        "\n",
        "For example, a sequence of power of 2  (2^1, 2^2 ...)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xae9BZVKTZKW",
        "outputId": "c58484f0-c3e8-4c16-b5a3-c76c2fa79838"
      },
      "source": [
        "class PowTwo:\n",
        "    def __init__(self, max=1):\n",
        "        self.n = 1\n",
        "        self.max = max\n",
        "\n",
        "    def __iter__(self):\n",
        "        return self\n",
        "\n",
        "    def __next__(self):\n",
        "        if self.n > self.max:\n",
        "            raise StopIteration\n",
        "\n",
        "        result = 2 ** self.n\n",
        "        self.n += 1\n",
        "        return result\n",
        "\n",
        "a = PowTwo(5)\n",
        "print(next(a))\n",
        "print(next(a))\n",
        "print(next(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "4\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X24qmtXETlBP"
      },
      "source": [
        "The above program was lengthy and confusing. We can do same using a generator function easily\n",
        "\n",
        "`generators` provide a convenient way to implement the iterator protocol"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nGIe0ijRTvTY",
        "outputId": "b92254ce-f1b2-4a57-f078-c0b6add96823"
      },
      "source": [
        "def PowTwoGen(max=1):\n",
        "    n = 1\n",
        "    while n < max:\n",
        "        yield 2 ** n\n",
        "        n += 1\n",
        "\n",
        "a = PowTwoGen(5) # generator object\n",
        "print(next(a))\n",
        "print(next(a))\n",
        "print(next(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "4\n",
            "8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dYpnaPmeVsgD"
      },
      "source": [
        "`generator object` is generated once, but its code is not run all at once. Only calls to `next` actually execute (part of) the code. Execution of the code in a generator function pauses once a `yield` statement has been reached, upon which it returns a value. The next call to `next` then causes execution to resume in the state in which the `generator` was left after the last yield. This is a fundamental difference with regular functions: those always start execution at the \"top\" and discard their state upon returning a value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JthbZ--_X2VO"
      },
      "source": [
        "### Generator Expression\n",
        "\n",
        "Simple generators can be easily created on the fly using **generator expressions**\n",
        "\n",
        "Similar to the lambda functions which create anonymous functions, generator expressions create *anonymous generator functions*\n",
        "\n",
        "The syntax for generator expression is similar to that of a list comprehension. But the square brackets are replaced with round parentheses\n",
        "\n",
        "```python\n",
        "(<expression> for i in s if <conditional>)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DcTl_Hs4YOl-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "27873ce1-9f86-42b7-c33f-7ee36b37244a"
      },
      "source": [
        "# Initialize the list\n",
        "my_list = [1, 3, 6, 10]\n",
        "\n",
        "# square each term using list comprehension\n",
        "list_ = [x**2 for x in my_list]\n",
        "\n",
        "# same thing can be done using a generator expression\n",
        "# generator expressions are surrounded by parenthesis ()\n",
        "generator = (x**2 for x in my_list)\n",
        "\n",
        "print(list_)\n",
        "print(generator)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 9, 36, 100]\n",
            "<generator object <genexpr> at 0x7fd6b6ad8150>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "slFr5HSoaKW_"
      },
      "source": [
        "We can see above that the generator expression did not produce the required result immediately. Instead, it returned a generator object, which produces items only on demand\n",
        "\n",
        "Differences with List Comprehensions.\n",
        "\n",
        "* Does not construct a list.\n",
        "* Only useful purpose is iteration.\n",
        "* Once consumed, can't be reused."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6t0oU6g5gKQ3"
      },
      "source": [
        "### Generator Pipelines\n",
        "\n",
        "Multiple generators can be used to pipeline a series of operations. This is best illustrated using an example.\n",
        "\n",
        "Suppose we have a generator that produces the numbers in the Fibonacci series. And we have another generator for squaring numbers.\n",
        "\n",
        "If we want to find out the sum of squares of numbers in the Fibonacci series, we can do it in the following way by pipelining the output of generator functions together"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_mGbYemrfpGH",
        "outputId": "10fdac8f-313a-4128-d520-c0c28f66903f"
      },
      "source": [
        "def fibonacci_numbers(nums):\n",
        "    x, y = 0, 1\n",
        "    for _ in range(nums):\n",
        "        x, y = y, x+y\n",
        "        yield x\n",
        "\n",
        "def square(nums):\n",
        "    for num in nums:\n",
        "        yield num**2\n",
        "\n",
        "print(sum(square(fibonacci_numbers(10))))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4895\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o0WGoYSTcElG"
      },
      "source": [
        "### Why Generators?\n",
        "\n",
        "* Many problems are much more clearly expressed in terms of iteration\n",
        "* Better memory efficiency.\n",
        "  * Only produce values when needed (**Lazy evaluation**)\n",
        "* Represent Infinite Stream\n",
        "* Can operate on streaming data\n",
        "* Pipelining Generators"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yv-fjGp30rZb"
      },
      "source": [
        "## Concurrency & Parallelism\n",
        "\n",
        "* **Process**: When we execute a program, the OS will generate a *process* to execute the same. The program code will be loaded into main memory (RAM)\n",
        "\n",
        "* **Thread**: A thread is an entity within a process. More than one thread can exist as part of process. Thread shares some of the process resources. But has its own program area and memory area\n",
        "\n",
        "* **Task:** A task is a set of program instructions that are loaded in memory"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rr0qd1ynpYAU"
      },
      "source": [
        "### Concurrency\n",
        "\n",
        "**Concurrency:**  is when two or more tasks can start, run, and complete in overlapping time periods. A condition that exists when at least two threads are making progress\n",
        "\n",
        "  e.g. multitasking (multithreading, multiprocessing) on a single-core\n",
        "\n",
        "  ![concurrency-vs-parallelism-1.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAr0AAADYCAYAAADmglsYAAAACXBIWXMAACTpAAAk6QFQJOf4AAAAB3RJTUUH5AsPFB8Uoh0DPAAAIABJREFUeJzt3Xd4HOW99vHvzGzRqldbsiX3jo1cwWB6iTExJSEEEghwgECAUEJ5IZyQk+SkQAIpJKSRAiE5hEBCKKFXG0xxAWODC+6WLVcVS1ptmfL+sbJx1cpG9kqj+3Nde13Sambnt6vZ2XufeeZ5DM/zPEREREREfMzMdAEiIiIiIgebQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPheINMF7I95DVt5c+tG5jVuZUVLE012kqTrknQdwMh0edIBYcsiaBiUhiKMzC9gYmEpx5eWUxnJyXRpIiIi4mOG53lepotI55GaFfx6xUfMrt9Ca6wVDCN12x50lXe7D2+nHzwPDIOy7FxO7dWHawePZnJxWSarExEREZ/q0qF3dsMWbp7/NjM2rgM8sAJgqkeGv3jguuDYBANhLhkwnB+OnkhpKJzpwkRERMRHumzovX/VEm6c/zbN8VYIBNtadsXXXBfsBNWlFTww8XjGFhRnuiIRERHxiS4Zeu/6eAG3zX8LMMCyMl2OHGrJBL1z8vjnUacypbhXpqsRERERH+hyofcva5Zx8buvpFp2TQXeHstO0De3kBnHfZZBOXmZrkZERES6uS7VQXbBtnquf39W6hcF3p4tEGLdtnounfcGccfJdDUiIiLSzXWp0PuNBe/Q0NqSumBNJBTm9fWr+O3KxZmuRERERLq5LtO94akNaznzjWdTLby6aE22c5JU5hby/klnU9JJIzokPbhrWZxNMbeLfe3rQRwYXxzgkspgpivpdp7cmOSljTboZNieHDiyJMAFfbVficieukyT6n0rFqWu3lcrr+zMClLTWMc/alZy1aARnfKQMcfjex/HSLZ6Cr2ZkvQ4ujKo0HsAHqtN8tCSOITUOLCHpMeH/UMKvSKyV10iYS5v2cZbdRs1UoPsnWHw79rVnRZ6AYqCBpscFHozxYC8gELbgci2jFTgVejdkwG5ll4XEdm7LvGR/07dZra1RnXxmuydZTGnYSsbYtFMVyIiIiLdVJcIvXMatqampBXZG8OkIRFjwbaGTFciIiIi3VSXCL0rW5oyXYJ0ZQa4dpI1rc2ZrkRERES6qS4RepudZKZLkC7NAM+lxbYzXYiIiIh0U10i9CZcN9MlSFfnQdLVJBUiIiJyYLpE6E16Cr2ShueRVL9vEREROUBdYsgyDTAjHaH9REREMmHTps28V7ONgNV+W6HtePTr25uRvXM6acseS1euY8U2lyNHVlH0qYcqdJm3uIbC8nIGFYY6pcLupEuEXhEREZH2LNvYSEVhNjnhQz/5yOuvz+KLv5uDmdM2M6gB2ZEwIVwaW5NtA1C5uM02l155Hn/84mGdtGWHPz36HHfNjzPzZ1dxTK9PF3o/eHc2J/1sJt+56WJumFjWSTV2Hwq9IiIi0uV9VFPHtX96jVvPmsgJo/oe0m0PHjyAi88wyQ5vj0028xaspNbI4XOH9WmbK8ajNe5wwuDiTt12VjhEbsTj0867smzRh1z5hzdoNLPIDXaJ3q2HnEKviIiIdHnTxvbn189/wBd++gwXHjucqz4zhuEVRYdk2+PHV/PA+Oqd7nG47o7f8IRZwW+vmnbQw9Snybt2rJWnX32Hm/5vNi1mgMIsk556hYxCr4iIiHR5Qcvk3KOGMm/lZh6auYSXFq7lkuNHcemJIynOyTq0xXhxki6AyzYHivcyoezq9RuYv7KO5qSDaYYZM6icwyrz91huycoa5qypx3MtBvTtzVHDSkg3P228qYHH31mJl1fC9In9yNvnCi73/OEffPPFdXzxrBOYXhLlukcX4PTQ1KvQKyIiIt3CiYf1pSQvi1jSZls0wY+fnMvT81ZyzWcO59zJQzJdHgDJxnp+8NCL/HHuWhJJj6Tr4boe4XA2502dwvfOHUdhELxYlJ8/9AI/ff1jtrlgegaWGWBi9Sju/eoJDCva9UKz7QMYec2NXH/Xw/zuwyg/vP482r22zXUo6t2be28+gWuO7c+8GTNIJHto4kWhV0QyRKNxyMGg/crfyvIjVJXk8lFNPVkhi1DAYun6Bq778+v8e/YKbjh9LJMG98pcgW6Cu/7wON99uZabr5jG5UcPJts02Na0ld8++jr3/fN1jhw3iAtGFvDK629y+zOLufz807j+5EGEcXjnzTl86devcnkkh5evnUKwbY/2PAiHTXCbueXeR/nzklZ+/d8XcNXE8vbrMQJcce5pO36NJpwe/SZR6BWRzDB68JFXDh7tV76WlxViaEUR81dvJautE0B2OIDreby0YC1vfVzLOUcO4apTRzOoV8Ehr8+zk/QaMIAf33gMt5wy7JM/lOZzw6lbefidF1mxpQUoYMGK9dg5hZxzwmiGlKbiWNVZp+AGslhsFmID28epCISCWIkWfnH/E/xpSZSf3/rl9IEX9H7YjUKvdHsvL1zLgzMWEw5YxJI2X54ynGlj+2e6LGlPOMDCtVu5eu6bRF0YUJbPbWdPJCvYfk+2d5dv5DcvLsAyTWIJm+njB3D+0cPaXQfgz68t4uWFa9se3+D606sZU1XS7jpNsQQ/fHwOtQ1R8DwqS/K4/ewJZKcZLum9VZv55XMfYBoGsaTN1Op+fOXYEWlrfGjmEp6fv5qsYOoD/NrTDmfcgJ43pNCnEg7w/qpNXD17KUnTImk7XHHKaI4eVtHuagnb5a4n57JsQwOmaVCUk8XtZ0+kNK/9fqLLNjTyk6fnYTsuCdth8tAKrvnMmLRlPjFnBY+9s4xwMEDSdrjsxFEcN7L90Qgc1+PHT85l0fp6LNMkPxLk9rMn0rsgu931Vm3exo+fnEvcTtU4aVBvrptW3e46AM++v5r/e3MJWcEAcdvh4uNGcPLoqnbX8Ty4++l5LFizlYBlkhMOcNtZE+hbnNvuejV1zdz5xFyicZuk4zC2fxk3TR+3z+WzghbubpMVmYZBXiSI7bo88NpHvLxgLRceO5yLjhtBaV4k7fPtLEYohyvOOQmAlTUb+GDVJtY3RqmtqeflBauww8Ed/XWPGjOEwpdf4/IfPcIXjxrM0cMqOPKwSr742WN3ekQPwzQJOFG+++vHeX7uMr7w5XM6FnhlDwq90u0t39jIY28vIyccoDlmM2FQL4Xers4y2dQY5fF3l9PkwLgBZdx85nhIc/lGTV0z/3p3OUHLpLk1Sb/SPM4/Ov3m5q7clNpHslKB9fyjh6YNvfGkwwsfrGVpbQOe5zG6qoSbp48jO9z+tmrrW3h89nIsw6A5lqR3YaRDoXf+6s089vYycrOCOJ7HF44crNC7vwImGxqiPP7uMmwrQCzhcNrY/mlDr+N5vPZRDW8v3UgwYFBRlMsNp1cD7Yferc0xnpizgoTt0Bp3MAyjQ6F38bp6Hn17OblZAVoTDicdVsVxI9tfx/U8Xl+0jhmL1hMKWJTlZXHdadX0TtOYWd8S58m5K4nGbVoTDknb61DoXVJbz2NtNbbEbY4ZXpE+9OIxc3EtLy1YQzhoUZgd4urPjCHd4GKN0QRPz11JY2uCWMKhJWa3G3pDARNvH+MPBEyTnHCQZRsaefD1RRw7os8hDb0Am9at5aY/vshzi+sIBU1cEypLyhgzsJgV9S3QVvuRU47gt00J7npqAT/7+wp+YgSp7FvM8eOGcc20I5hUkfpCY1oWLfUNzMahenAFM2a9z9snD2NyWZqDkexBoVe6venjBzK8TxGmaeA6HoPTfQpI5sVtxg4o4+dHnUHSg9ysEJFg+sPRscP78NT/OwODVMtXv9L2W5C2u+60ar5w5BAsM3Wqb3SawAtQkB3md189kWg8CUBOOEhuVvpB8Y8cUs6Tt0yHthor07Rybfe1U8YwffzAHTWO6tu5Y332CDGbSYN785MpZ2IbBq7rMaJP+iGtwpbJPRceQ2NrAsMwCAcseuW334IKMLJvEf/8xum4XupCpV4FHQtX508ZxuSh5ZhWqsaODLsVMA3u+vIUGqJxDMMgZJn0KUo/69eQ8kL+ccM0nLaLqUrzO1bjF44Ywrj+ZTtqHFpemHYdwzD4wXmTuWn6WAzDIGga9C/dc7SC3Q0oy+fh66Zit9VYnKaFPZqwMffSMdX1PJpiSYpzwtw4fSxXnDy6Q69RZ4q31HHTL5/k3+sNbvn8SUyr7kNVRQHF4Sw2fvwBz7y9End7XjeCnDPtRM464QhmLlzNeyvW8cr8VfzjqRnMXFrHs986m2G5Jq7j4IYifO/r5/GZ7M1Mue0xbnnobZ658XjyDumz6/4UeqXb61OUc8gPbPIp2S6leVkcNWL/gl1ZfoSyDn5o72xYRSHDKtJ/aO8saJlMHLT/F8SU5GVx7Ig++73ekPIChpTrC9unYrv0ys9m8n7uV6ZpMPYAWtXzIyGmDG+/FXlv+pfm0b90/+KKYRhU9y/d723lZQXTtnTvTWVJLpUlHfvCtp0BjOmX/gvl7nLCAY7qYI2261LfHMfaaTpgz4NoIollmpw1YRDXTB2TsbMkW1av5aml9Vz0lS/w7c/teoZnyaqNNLguQdMEPJ547m0WeQXcMm0UJ05K3W78Ypw//fUprnx8BS8tb2RYdRGe6xLOzmXCwFIq84q5/bPD+drjb3HvxMH893GVGXme3VXPnJJDRDLLSLWCinQqIxWKxL/qW+J8WLOVUFvojScdmloTVPcv5fdfPZE/XHlSRrsFhbPCFAVN1jU0Ye90/9Kli/mfJz/ECwRpTdqAwbKlS/jmr57mj+9t+mRBI4ztAoEAvXdq8fY8l2jMBUwuPutYTqm0+Nk/ZvBho3OInpk/qKVXREREuoUl6+qpb47j4dEYjdO/NJ/LThrFRceNICfNRaadLZFIEjWdXXoXl1ZVcd6Ecu564hVO37CO6vIcGhobePmjDQyr6kOf5pUs3dgIVHHZ+afw+vLHuPGnDzPzqGGURwI01G7m4bmrOOO0k5k6IAI4JJM20bi9o1tEVnEFd15wNCfe+TzX/+Vt/nX1FPLTzWbRxnEcovEkdg9tdFDoFRERkW7hqXkrWdfQQmVRLl86cRhXn3o4/csy0bPVpKpPGaPNgl2DVDCHO678HFX93+Fvs1fzn1roW1nOnV8/h7OH5XHdPY/RGI0SBwp7VfLQHefzmyfn8p/31zDP88jvVcwPrj2HS44ZTq4J4FHeq5jq/glydtrQhKMm8s1p63hw6TJeXnYYnxvese5buXl5VA/sRWmkZ8Y/w/O8jMf9KTOeZtaGGgiG0i8sPVM8xp3jj+HWYYd/6odqsj2GvNrEppinDj6ZkvSY2ifIc0eoL/b++tqCVn63LE770zD1UEmPMytDPDEx/UVo0v0s29DI9B8/xeH9S7n1jPFMOIA+94eax55zQTiui2nueSme5+3/sLqe45D0DEIBfZh1RM+M+iIiItKtLKzZym1njufi40d1mzkX9lamZe49oB7IczIsCzUXdpxCr4iIiHR5Z08clOkSpJtTe7iIiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J7G6ZUexwMakh4kNCNbxiQ9muyMTwbZLUWdtn1X9pT0aHb02ojI3in0So8TMQ1uHhxmY6sLZjeZ1sdvHI9JJTr8HIizyoOEPMDSvrsHx+PoUu1XIrJ3OjpIjxM04QfDszJdhsgBOac8yDnlwUyXISLS7ejkroiIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPheINMF+Jrn7fq7YXRsud3tbb2d1+nI4+5rGREREZEeQC29B4NrQzKRCp0GqZvnfnLf7gzjk+V2v+GBnQDH2cc67YTZHY+jwCsiIiI9m1p6O5UHySS52WVc2K8/Z5f3pSoSAaClpY7H1q/kT2tWsMUGLAtwwIlw55EnckZhzl4fMZqMMnfreu5f/hFzm2IQCEDS47Ixx3JjZS+wW/ja7JeZuS0BVtt3GCdBr8J+PDLpaHqZML/2Iy56fwF2MHhoXgYRERGRLkaht9N4kLQZ0/cwHqiezPjc3QJmXiGTygdxSb+BXPz2TGbHEmABGAzKK2ZUXmQfj1vIxOI+XNCnijPeeIHXmlrBs6jILmBUXiF4YQqs3VpyPY9gIMTYgkIKgWRjNka6LhQiIiIiPqbQ21nsJAPLRvDs5GPpa6XuWlm/jpe21pMwsjipzwBGRgKMLB3EwxPjTJr1OvVuasG4Y7c9RisPr1tFnZ0KqNlZuZzRux+lAcjN6c29ow9nwluzSHoWSbetu4Nj4+wlz3qeR9SFQhNaXfdgP3sRERGRLk2htzN4LpjZ3DFmUlvgdXl06dt8beEC6uI2YFBcUMlfjzmVafkRBpeP5PZ+y7hlRc2uvaoTjdz8/musb3ZSXRUMgzF9DufZo4+ir2UypqySCZEwb29TiBURERHZH7qQrTM4SSpL+/P5klS/3E0Nq7hq4XzqXAuyIpAVpm7bWr4xfz4rW6O8sXENy21jz1ffMCkKZUG47WaZLNiwgveibS3BZpCSgAnqqSAiIiKyX9TS2xkckwlFZRS0da19a2MNW5NAaHuqNSCcxZLNi6h+eRktiRiuC1gB2HlQBs+lLhGDuANWauiFgeUDGBNJ/Zs8J84G22kb1UFEREREOkqh91PzwLQoDWfvuKcm1spemnHBcGmKx1JDiFkGuyZeIJTHtw87ms1JFwwoy8pjWp/B9A+kUu4Hm2uY35oAI3RQn5GIiIiI3yj0dhJjp7Fw3XTdD/Y1bm4gh68Nqd7rnzY21fLVDxdgY6Xy884Pl6bpVw3DIiIi0tMp9HYGz6PVTu74NTdg7WOWNYPcoEVzLApmqG3Isp0fx2VDvJXk9lVdl/p4M69tXsP9y5ewsCUOAQsccLd37LUCRIJB8Fp3faidfnY8T92ARUREpEdT6P3UDDBsljY34KV+Y3xhCZhL2HEHQDJOafFgnp80jo+2rOGBNct5pa5+1zAa28rpM57lo5a20RvwsF0HJ5kEM5AKvHiATUMysWM113X3uLjN3Sl0t9gJ7IPwzEVERES6C43e0Bksk/c2r+ejthw6pnwIF/Qqhngr2DYk4+AGuWLIaMYXlHHh4Anc0b8Kw9k9inpEnSRxO0ncSRLfPgZvMPTJbGsYYDhsiLdtzAgzvawMnBjYydQtYTM4r4zStlWadmqFFhEREemJ1NLbGcwAdssGvv/xMh4+bAhmII/fT57G8EVz+dfmrSSCES4cVM3N/fuklrebuXv5clxjz5c/YJhgemC0833EtHh3y3oaGE4hJpeOnIJjRfj9uo1E8RhR0J8fjD6M1OVuHrPqtoCp7zciIiLScyn0dgoDAgZ/X/wWo/KyuaNfH7KzCrlj3MncsceyDj/96A2erm9OdVc4kHkmzAAbtqzg+8uHcPfgKrAifHXkFL46cs9FP1i/gD+u3wLW7h2IRURERHoONf91FsMCWvn27Bf4r/kfMK+5ede/ezZL6tdxyzvPc9PSVRAI7ejvmx0Ipn4IBlMjmaXdlgGmyz3zX+WGRYv5uCW2xyINsWYeWT6b02e/S4Nn7nvECBEREZEewPC8vQ4zcEhNmfE0szbUpPqudneeC3aSQFY+RxSV0isYwAOaY9t4q34r0aQDgWBb4PXAs5hQWkFVKABunJe3bKDJ9joWUj0HbJe87GImFxaQE7Da7k6yeNtWljQ1gRUE0weBNx7jzvHHcOuwwzNdiYiIiHRD6t7Q2QwTgmHsZJRZtSs/GbrMtFJdDILBnRcGw2XuxpXMddv68QaCHW+VNSwIWjTF63lx/dZPtmUYbdvywZcIERERkU6g0HuwmFbq1hGBTxlOzYA6qoiIiIi0Q1FJRERERHxPoVdEREREfE+hV0RERER8T6FXRERERHxPoVdEREREfE+hV0RERER8T6FXRERERHxPoVdEREREfE+hV0RERER8T6FXRERERHxPoVdEREREfE+hV0RERER8T6FXRERERHxPoVdEREREfE+hV0RERER8T6FXRERERHxPoVdEREREfE+hV0RERER8T6FXRERERHwvkOkCRET2zqNl7SacWByMHvD93PMwgha5VeUYVg94vpngebTU9KB96iDzXJdIr2JChbmZLkWkQxR6RaRLchM2C3/6N6IbtmIG/X+ocl2XQFaYSXd+nazSwkyX40tOwmbBPX+jdWPP2KcOtmRzK0MunMaAz5+Y6VJEOkTvehHpkjzPw/PADAZ6REAxXBcwwPMyXYp/9bB96mAzAxau62a6DJEO07teRLoswzTAaLv5nWGknq8cVD1qnzrYDANDr6N0I+rUJCIiIiK+p9ArIiIiIr6n0CsiIiIivqfQKyIiIiK+p9ArIiIiIr6n0CsiIiIivqchy0RERETa43nEbQfXg/YGafMAwzAIBa1Oa1X0PJdY0sGyLEKfarZGh9aEC5hEQlYnVde9KPSKiIhIlzd35SbK8iL0K8079Btv2sJF9zzB+1tssoOp4GkYJkHLwHFcnLZJZZJJm7zSPjxw69kMz+6cTW9esZSp9zzPSdOmcs8ZI/b/AewYz706jz+9vZRFm2MYRpDDhldx6bQjOXVgQecU2U2oe4OIiIh0eXXNcc792bM8NHMJrnuIZy70PGIJm2j8k9u25iirNzWypTm+0/1JWhOpFuHOYieTrN7UwObm5AGsneQ3f/0PZ/3iBZ5bUk8y6RKLtfD4i+9w7vf/xT8Wb+u8QrsBtfSKiIhIl3fqmCruf3khV97/Ck/OWcE1Uw/nhFF9D83G80v56x2X4OwUZue//Q6fu/9drrnsTK6d2GvH/YZhkhvpvE0bhkFWMEDQ2v/Z75Yv/JD/fWohoyeO484vHcGkyiKSiVb++cq7fOuR2dz52FucevtUinpIE6hCr4iIiHQL5xwxhDcW1/L6onW8u3wjn5s0iKs/czjDKgoP7oYNk7zsrF3uKsoO4nmQk51FYU7WXleLxeI0x2wcDLLDYfIie+9Lu62llWjSJWgFKckLdaikZDxObWMrkZxcynL2Huc+WrUZq7g3t194KqcOaetvkZPF1845mcVLVvPnFWtZWu9xZEnPmE5aoVdERES6haOHV1CcG6Y5lsQwDP7vjaW8srCGi08YyeUnjqIgO3zIakm2Nfs6jrvH35o3b+RXz87mX3PXsm5rlBgmFUVFnHFcNdefPpbynFTIjDfUcd+/3+R3s1ayuSVBbiSP4yeO4Prpk5hYue9OwXXr1vDlux5nWaAPv79hOiftI/ROnXoCi089kezw7n8PMKRXAcbHjXiHuKdIJin0ioh0IYFPdXW2iL+V5GUxsCyfeas2EwkFyM8O0RBNcOe/5/Cfeau4dmo1Z08ahJHBhsvm+lou+d7DPF1ncPlpE6guz8MkwTvvL+Xuvz7Dmhb4yyXjsOwo//P7J7h3TiOXnzmJ6t7ZNNZt5r5/zeSlRbW8+N0vMLrwk5i2PZw219dy2ff/yVuJHB765lRO6rfvvhShYJC9thu3buXFD2oorRjKgIKe0coLCr3iA47rYbd90/aAoGVimenfxEnHxXG91PAzBoQsEyPNkdLzIOE4qQ0Bhml0aAiZnWsEsCyDgJl+vV1qBIIBE3N/azQMQoEDqNE0OhTADrTGpOPgeakyTQNCgZ45hM7uovEkYdshaKV/HQEStrPjw9AwIBiw2h1SCcD1PJL2J++ZQAf/17bjYu/8v7ZMzA681xI7DfVkGBC0rLShZPcaLdMg2MEanZ2uIgp08HggnSNpp0Yy+OS4mv5/vfMxywMswyC4j2NWdijAgF75vLt84477QgGTUCDM4vX1XP2nV3n0nY+59rTDOWpoRac9r/2x6KOVfJiM8JPrpnPtkVU77r/s1LEktv6eNxevYhvjiGxYz2PvrWXatDO498JxO5YbW5LFVY8v4f11TYwuLAJSr1EkO4wb3cY19zzK63YuD3/rS5w+MPcAKkxyz0PP8+Ral1/cfgTlwU/7jLsPhV7p9p6at5KfP/M+WUGL1oTD1Z8Zw3lHDU273vf+OZsZi9YRDppkBQPcfeEUhlUUtbvO+vpmbnhwJvXROLbjMm5AGT+5YErawPD8/NX85On3CAdMWhMOl580iq8cm37omR/9ew4vL6whHDQJWhY/vmAKh1UWt7vOpm1Rrn9wJluaWnEcj9FVxdz9lWMIpwmVr3xYw51PzCFopWq86LgRXHbiqLQ13v3Uezw7fxWRYADTNPjR+UcxdkBZu+vUNce4/sEZ1Da04HkwrKKQn110LJFQzz0kWaaJ7bpccf+rbAyE+cEXJnH0sPY/tJtjCW548A1WbGrEMKCyJJdfXHQchTntn+Kdu2Iz33rkLQBakzZnTRzETZ8d1+46APe/8iEPz1pKdiiA7Xp86/OTOGFk+xcStSZsvvGXmSytbcAwoKIwh19cfBwleXvvA7ndgtVbue3vs3Bdj9akzbTqAXzz7Alpa3xwxmL+MmMxkZBF0na57ewJnDqmX9r15NNzPY//fuQt3l3uZO9SAAAMaElEQVS+kaBlkpcV5KcXHcuAsvx211u1eRs3PjST5liShO1y1NBy7vzy0ftcPito7RgibGfZoQCe5/HygrW88/EGPjt+IDdPH3fIhzgbN3kyi6ak6o/FYtQ1tdLSHOe9RatYWp8kXOaR8CA3J5s+BVnMef8j7p9ZwKnDS+nfK5+TTjmOJacct8uXt2AwQP2GdVz78zf5d02Av33nQk4fcABXy3lx7n3gKW5+agUXn3cGX5tU3llPu1vouZ8w4huN0Tgf1zaQHQrQErepb4l1aL3a+hY+rm0gK2iRHQ4QSzpp10nYLis3bWNLU4yk41CWF6Ej3aG2tSZ2bKslblPX3MEaG6Kp9UIWoYBFa8JOu07ScVm1aRsbGlqwHY+C7FCH+mw1tSb4uLaRUMCkJW6ztYM1bmiMtr3+QSzT6FCNtuuyanMTa7c04XoekWAAtyd1LGvH6s1NrDFaaYmlH57IcT3WbGni49oGDMPAcb1dPij3JRpPsmxDY+rnRJKNja0dqm1LUysf1zaQEw6SdFyaWxNp13E9j7Vbmvm4tgHTMIgnXWx3zz6Qu2tN2Czf0IjjekQTScYNiHaoxq3NMZbWNpATDpBIOjR1oEbpPOvqUsfVUMCiIDtE3E5/XI3bDis2bmNba4J40kkbUs12zpKlzmxZNEQTfFizlYZonH4c2tAbsEzWrFjBL599n5nLt1C7dRuNcY/yghwSSY/CgIVjQ7CoD985bwpXP/gmV97zd3oX5FA9qpKjRw3gguPHMDj/k44JkXCQl16bjWtAMJjLhoYWYP9Cb6J+M7f+4Rl+/sY6Lj53GvddWL33rg8+Znhe5j9ppsx4mlkbaiDY015+6bB4jDvHH8Otww7f40+N0QSbtkUxDAPP8yjNi1CUpqULUqG3OZ7EwEi1khXnEg623xqatF1q6ppxXA8Pj0goQN+i3LSn77a1JtjY+EmNJblZFOe239IFqdDbHEvsqLFvcQ5Zwfa/qyadthqdthqDAfoW56TtutHUmmRDYwsGBh4exTlZaVvjADY2RmlsTWC21dinKCdti63dVmOyrTtFVtCib3HuLqfznXiCOd+8j9jWRsw0z9kXXBcCAXp940LMkkL6FETICbd/3tF1PWrqmncEi1DAorI4N+3p/GjcZn19S+ox8CjMDtMrP/0H6JamVupa4phtHRzKC7PJzUpTo+exrq55x5fKoGVSWZyb9uxIayJVo+elaiyIhOhdkH60/61NMepaYjv24/KCbPIiqc8WJ5Zg9jfvI17XQ/apgyzZFGXgF09h4Dkn7bhvXV0L0XjqIjPTTB1X03VdStgONXXNuC54eOSEg/Qpytnn8tc9MIO/z1pKfmTXzGA7Ls3xJIN7F3DFyaP58pRhB/Xs0dw33uSUX87i9m98hVsmf9JiumbpYs6+6ylWJyOcMX4oxxxeTmluLmMH5nPPb/7N89FiXvnfc6hse+tsXL+BZ+ct4z/vreKjtZtYvLGFssoqfnvtmZw9opjaJQuZ8sNnCPeu4s7zjuTvf3+aF6MlvPaD8xld2LFuYevXruLSnz/J82tsbv+vaXzn9JH0oF4NO+hdL91eQXaIguz9/8JU0c5BdV+CAZOBvdo/Vbc3+ZHQHgfojqgozAb2b1qfoGUyMM3pxL3JiwTJi+z/sD+9C7I7FEZ2FrDMtKc8exqP1GxBwysKobBjr41pGgd06jY7HGBI+f7PxFSaF6E0b/9al0zDoKpk/2uMhAIM7r3/NZbkdezLmhwcfYv3/7gaClgM6tWx/3XCdtjYEN3lmgjX9WiOJynKyeLSE0dx+UmHtRuaDy6bB555h4WxHP71nQuZPnTn93IrW1uiYJUSNCDa3MRH65sZPrSCS6aXc8n0Y6jfuoWXZn/ArX+exd3PfchZI44lYEAskeTkI8Zy1oRBDEoewXN3vcBtj8zh8SuPTBteN6xewTk/fIyFiSL+8q0z+Up174P5AnRpukxYRKQL6Ug3G5Geqr4lzpLaeoIBEw9oiSeJ2w7Txw/gHzecxrfPOSKDgRfAozluk5tfwMiBu355nTPrfWauaiIUNAkEoGndCqbd8nuufGTBjmWKSko597RxDM0P0hSL79J9znNTx4Yxkydww7FV/Oe5WTy0oK7dapxYA7f++j+sNit56fsX9ejAC2rpFRERkW7i/VVbqG9JXUjcmrCZMLAX10wdw/TxAzNSj+d5u13XEeSEUX352aw5XPOrl7nlM8OJ4DLzvQX88fVlBLNziLbGqYvC0MFDuOiIvvziXy9SlRXnrBHlkEzy1AuzeKnO4H8vHIYJOF5qO+5O27juSyfy7MK/872/vMoJ3/k8g3L23qVp5hvzeHpZE1VDivnT4y/wq+QnI/vguTQZWdz4xRM4rp0xgf1EoVdERES6hSfmrqC2oYUxVSVceuIoLjp2xI4+24ea67rEEjb2bhePTj11CnfWxfnVq3P57BvvEMgKM6SqnG9+9fOEls/l4idqWLKxhaEDc/jB188k8tCrPPSPV7kvYeMELCp6l/Cdy87gxuP67bKd5E5DShZVDODbnx/LWfe9zc2P9uOvF00ie49z9w4vzVtBsxWgZu06lixfs9sTsImZuXx+6hSOqzwIL1AXpNArIiIiXd68lZt5dWEN1502lhtOr6ay+EDGqO08I8dW89qdA6nsW7LL/VZWHjddfBbnTt3EuoYEVlaYkVVl5FkQG1nIgOpGBpalgnpWQS++//XzuOLMTdRGE7jBAAMqSqjI/qSnbumAITz/o8soKtl1O6dPO4k5Q0fRYoX3MTa3waXnT2f62Q7WXi9k9rCxGFqZ2dfxUFLoFRERkS5vc1Mrv/qv4zl5TFX6hQ+B3Px8Jufv+6LTfuW96LfbMLhZuXlMGbnnhZ39+vViX6NJhyLZHDF8L90PrBDVw9sbg9pkUL9yBrWzRE/TJUJvxNJMTJKGYZCl/UREpMeaergmGZFPp0uM3hA0FGYkDcMgYHSJ3VVERES6oS6RIirCBzCVnvQcngemRW/tJyIiInKAukToHVNQnOkSpCvzPCKhMCPy9n+gehERERHoIqF3UlEpZiCYatET2Z3nMiA7l2G5Cr0iIiJyYLpE6J1QWMLQ/CJw7EyXIl2RbXNa776EzC6xu4qIiEg31CVSRMQKcH7fgeC66ReWnsVzCYSzOL9Sg66IiIjIgesSoRfgqkEj6JVXqNZe2VUywef6DuSIorJMVyIiIiLdWJcYpxegdzjC/4wYxzVzXgPTg73OHiI9imOTH8nluyPHZboSyRA3aeMme8YXYc91wUXXNhxkPWmfOtjcRBLPcTJdhkiHdZnQC3D1oBG8tqWWR1cuhlA40+VIJrkueB4/q57MyLzCTFcjGWCYJtkVpWAamMFg+hW6Oc9xCESyMEP+f66ZYlgm2RUlGFbP2KcOKg8CORHCRfuekUykqzE8r2s1K2xNxDl91gu8u3EthLIyXY5kguuCneSmwyZy9+hJma5GMsiznVQLaE9hGpiBLtUW4Tuu7ej6kU5kBAIYps7MSvfQ5UIvwPpYlAtmv85r61dBMAiaiavnaOvTfdvI8fzosIkZLkZERET8okuGXoAWx+b2D+dw78cLUkEoEFI/Xz9zXbAT9MrJ5yeHT+aifkMyXZGIiIj4SJcNvdu9tGk9P14ynxc31oBrg2GBaX4SgBWEu5/tu5zrgueC65CTlc2FVUO4cdgYTUIhIiIina7Lh97tXtq0nqdq1/DallrWtLbQkIiD67SFJo320G0YBhgGphWgd1Y2Q3Ly+Gx5JaeX92NMflGmqxMRERGf6jahdzvH81jWso31rVFaHBvbc7HdbvUUerSQaWKZBkWBMP2zc+kbyc50SSIiItIDdLvQKyIiIiKyvzQsgoiIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj4nkKviIiIiPieQq+IiIiI+J5Cr4iIiIj43v8HFrOW2XaDFx4AAAAASUVORK5CYII=)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pgtfYhIQpnqI"
      },
      "source": [
        "### Parallelism\n",
        "* **Parallelism:** is when tasks literally run at the same time. A condition that arises when at least two threads are executing simultaneously\n",
        "\n",
        "  e.g. multitasking on a multicore processor\n",
        "\n",
        "  ![concurrency-vs-parallelism-2.png](data:image/png;base64,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)\n",
        "\n",
        "* **Parallel Concurrent Execution:** It is possible to have parallel concurrent execution, where threads are distributed among multiple CPUs. Thus, the threads executed on the same CPU are executed concurrently, whereas threads executed on different CPUs are executed in parallel\n",
        "\n",
        "![concurrency-vs-parallelism-3.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xFzciU9ZsYx8"
      },
      "source": [
        "### Asynchronous Programming\n",
        "\n",
        "So far whaever we have seen is **sequential programming**, all the instructions you send to the interpreter will be executed one by one\n",
        "\n",
        "Say you have a script that requests data from 3 different servers. Sometimes, depending on N/W condition, the request to one of those servers may take unexpectedly too much time to execute. For instance, imagine that it takes 10 seconds to get data from the second server. While you are waiting, the whole script is actually doing nothing. However, what if you could write a script that instead of waiting for the second request could simply skip it and start executing the third request, then go back to the second one, and proceed from where it left. That’s it. You minimize idle time by switching tasks. For this purpose we can use **Asynchronous Programming**\n",
        "\n",
        "1. **Threading**\n",
        "2. **Multiprocessing**\n",
        "3. **Asyncio**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9BrW2-uut8dV"
      },
      "source": [
        "### Threading\n",
        "\n",
        "Python has `threading` module to create the threads\n",
        "\n",
        "\n",
        "* To create a new thread, we create an object of `Thread` class. It takes following arguments:\n",
        "\n",
        "  ```python\n",
        "  threading.Thread(target=func, args=arguments)\n",
        "  ```\n",
        "  1. **target:** the function to be executed by thread\n",
        "  2. **args:** the arguments to be passed to the target function\n",
        "\n",
        "* To start a thread, we use `start` method of `Thread` class\n",
        "```python\n",
        "thread.start()\n",
        "```\n",
        "* Once the threads start, the current program (you can think of it like a main thread) also keeps on executing. In order to stop execution of current program until a thread is complete, we use join method.\n",
        "```python\n",
        "thread.join()\n",
        "```\n",
        "\n",
        "> There can only be one thread running at any given time in a python process"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V2qROTpSuKdM",
        "outputId": "a94b656f-eeb7-4ec0-845c-abb99a9afc8d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "\n",
        "# Python program to illustrate the concept\n",
        "# of threading\n",
        "# importing the threading module\n",
        "import threading\n",
        "  \n",
        "def print_cube(num):\n",
        "    \"\"\"\n",
        "    function to print cube of given num\n",
        "    \"\"\"\n",
        "    print(\"Cube: {}\".format(num * num * num))\n",
        "  \n",
        "def print_square(num):\n",
        "    \"\"\"\n",
        "    function to print square of given num\n",
        "    \"\"\"\n",
        "    print(\"Square: {}\".format(num * num))\n",
        "  \n",
        "if __name__ == \"__main__\":\n",
        "    # creating thread\n",
        "    t1 = threading.Thread(target=print_square, args=(10,))\n",
        "    t2 = threading.Thread(target=print_cube, args=(10,))\n",
        "  \n",
        "    # starting thread 1\n",
        "    t1.start()\n",
        "    # starting thread 2\n",
        "    t2.start()\n",
        "  \n",
        "    # wait until thread 1 is completely executed\n",
        "    t1.join()\n",
        "    # wait until thread 2 is completely executed\n",
        "    t2.join()\n",
        "  \n",
        "    # both threads completely executed\n",
        "    print(\"Done!\")"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Square: 100\n",
            "Cube: 1000\n",
            "Done!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nZ0lNwARxkie"
      },
      "source": [
        "### Multi processing\n",
        "\n",
        "Multiprocessing refers to the ability of a system to support more than one processor at the same time. \n",
        "\n",
        "A multiprocessing system can have:\n",
        "\n",
        "* **multiprocessor**, i.e. a computer with more than one central processor.\n",
        "* **multi-core processor**, i.e. a single computing component with two or more independent actual processing units (called “cores”).\n",
        "\n",
        "program in a multiprocessing system are broken to smaller tasks that run independently.\n",
        "\n",
        "* To create a process, we create an object of `Process` class. It takes following arguments:\n",
        "  ```python\n",
        "  multiprocessing.Process(target=func, args=arguments)\n",
        "  ```\n",
        "  1. **target:** the function to be executed by process\n",
        "  2. **args:** the arguments to be passed to the target function\n",
        "\n",
        "* To start a process, we use start method of Process class\n",
        "```python\n",
        "process.start()\n",
        "```\n",
        "* Once the processes start, the current program also keeps on executing. In order to stop execution of current program until a process is complete, we use join method.\n",
        "```python\n",
        "process.join()\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ts4sljw2y-X7",
        "outputId": "8e7ab9cc-ec2b-4f75-97dc-7bf81161416f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# importing the multiprocessing module\n",
        "import multiprocessing\n",
        "\n",
        "def print_cube(num):\n",
        "\t\"\"\"\n",
        "\tfunction to print cube of given num\n",
        "\t\"\"\"\n",
        "\tprint(\"Cube: {}\".format(num * num * num))\n",
        "\n",
        "def print_square(num):\n",
        "\t\"\"\"\n",
        "\tfunction to print square of given num\n",
        "\t\"\"\"\n",
        "\tprint(\"Square: {}\".format(num * num))\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "\t# creating processes\n",
        "\tp1 = multiprocessing.Process(target=print_square, args=(10, ))\n",
        "\tp2 = multiprocessing.Process(target=print_cube, args=(10, ))\n",
        "\n",
        "\t# starting process 1\n",
        "\tp1.start()\n",
        "\t# starting process 2\n",
        "\tp2.start()\n",
        "\n",
        "\t# wait until process 1 is finished\n",
        "\tp1.join()\n",
        "\t# wait until process 2 is finished\n",
        "\tp2.join()\n",
        "\n",
        "\t# both processes finished\n",
        "\tprint(\"Done!\")\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Square: 100\n",
            "Cube: 1000\n",
            "Done!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jHcCIPBEzz8d"
      },
      "source": [
        "### Asyincio\n",
        "\n",
        "**Asynchronous IO** is one of the big reasons for the popularity of Node.js. `AsyinIO` is python implementation of same\n",
        "\n",
        "`asyncio` is the new concurrency module introduced in Python 3.4. It is designed to simplify asynchronous code and make it almost as readable as synchronous code as there are no callbacks\n",
        "\n",
        "asyncio uses below concepts\n",
        "\n",
        "* **Coroutines:** are special functions that work similarly to Python generators. It's generator that consumes data, but doesn’t generate it\n",
        "\n",
        "* **Tasks:** schedulers for coroutines\n",
        "\n",
        "* **event loop:** manages and distributes the execution of different tasks. \n",
        "\n",
        "> asyncio is single-process and single-thread\n",
        "\n",
        "Compared to threads here race conditions will be less as we are controlling the context switch"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qPshQpvh6sRu",
        "outputId": "3c83e15a-2672-4561-dea3-103664f40c3f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 340
        }
      },
      "source": [
        "import asyncio\n",
        "\n",
        "# Coroutine\n",
        "async def io_related(name):\n",
        "    print(f'{name} started')\n",
        "    await asyncio.sleep(1)\n",
        "    print(f'{name} finished')\n",
        "\n",
        "\n",
        "async def main():\n",
        "    await asyncio.gather(\n",
        "        io_related('first'), # Task 1\n",
        "        io_related('second'), # # Task 2\n",
        "    )  # 1s + 1s = over 1s\n",
        "\n",
        "\n",
        "if __name__ ==  '__main__':\n",
        "    loop = asyncio.get_event_loop() # event loop\n",
        "    loop.run_until_complete(main())"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "error",
          "ename": "RuntimeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-17-6849bfaf316c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[0;34m==\u001b[0m  \u001b[0;34m'__main__'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m     \u001b[0mloop\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0masyncio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_event_loop\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---> 18\u001b[0;31m     \u001b[0mloop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_until_complete\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmain\u001b[0m\u001b[0;34m(\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/usr/lib/python3.7/asyncio/base_events.py\u001b[0m in \u001b[0;36mrun_until_complete\u001b[0;34m(self, future)\u001b[0m\n\u001b[1;32m    561\u001b[0m         \"\"\"\n\u001b[1;32m    562\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_check_closed\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--> 563\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_check_runnung\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    564\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    565\u001b[0m         \u001b[0mnew_task\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mfutures\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misfuture\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfuture\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/asyncio/base_events.py\u001b[0m in \u001b[0;36m_check_runnung\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    521\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_check_runnung\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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    522\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_running\u001b[0m\u001b[0;34m(\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--> 523\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'This event loop is already running'\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    524\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mevents\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_running_loop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    525\u001b[0m             raise RuntimeError(\n",
            "\u001b[0;31mRuntimeError\u001b[0m: This event loop is already running"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dUcw1rDouAns"
      },
      "source": [
        "### Making the Right Choice\n",
        "\n",
        "**CPU Bound** means the rate at which process progresses is limited by the speed of the CPU. A task that performs calculations on a small set of numbers, for example multiplying small matrices, is likely to be CPU bound.\n",
        "\n",
        "**I/O Bound** means the rate at which a process progresses is limited by the speed of the I/O subsystem. A task that processes data from disk, for example, counting the number of lines in a file is likely to be I/O bound.\n",
        "\n",
        "* CPU Bound => **Multi Processing**\n",
        "* I/O Bound, Fast I/O, Limited Number of Connections => **Multi Threading**\n",
        "* I/O Bound, Slow I/O, Many connections => **Asynci**o\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "14iqrotH-Eg3"
      },
      "source": [
        "## Logging\n",
        "\n",
        "Logging is important for software developing, debugging and running. The `logging` module is a standard library module for recording diagnostic information to a file or any other output streams\n",
        "\n",
        "Levels of Log Message\n",
        "\n",
        "* **Debug :** These are used to give Detailed information, typically of interest only when diagnosing problems.\n",
        "* **Info :** These are used to Confirm that things are working as expected\n",
        "* **Warning :** These are used an indication that something unexpected happened, or indicative of some problem in the near future\n",
        "* **Error :** This tells that due to a more serious problem, the software has not been able to perform some function\n",
        "* **Critical :** This tells serious error, indicating that the program itself may be unable to continue running\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "faLmpc11BBg-"
      },
      "source": [
        "#importing module\n",
        "import logging\n",
        "  \n",
        "#Create and configure logger\n",
        "# logging.basicConfig(filename=\"newfile.log\",\n",
        "#                     format='%(asctime)s %(message)s',\n",
        "#                     filemode='w')\n",
        "  \n",
        "#Creating an object\n",
        "logger=logging.getLogger()\n",
        "  \n",
        "#Setting the threshold of logger to DEBUG\n",
        "logger.setLevel(logging.DEBUG)\n",
        "  \n",
        "#Test messages\n",
        "logger.debug(\"Harmless debug Message\")\n",
        "logger.info(\"Just an information\")\n",
        "logger.warning(\"Its a Warning\")\n",
        "logger.error(\"Did you try to divide by zero\")\n",
        "logger.critical(\"Internet is down\")"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WpUKHakXBlak"
      },
      "source": [
        "## Best Practices"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YmkuHdZ6B2Ud"
      },
      "source": [
        "### Lazy Evaluation \n",
        "\n",
        "**Lazy Evaluation** is an evaluation strategy which delays the evaluation of an expression until its value is needed \n",
        "\n",
        " It can improve the efficiency of your code and save plenty of resources\n",
        "\n",
        " Some of the built-in functions `range(), map(), open(), zip()` returns lazy iterator object\n",
        "\n",
        " Use `generator` & `decorator`to create custom Lazy Evaluation function & class"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ftFqbEZC4Mvn"
      },
      "source": [
        "# References\n",
        "\n",
        "https://github.com/dabeaz-course/practical-python"
      ]
    }
  ]
}