02_Python_Foundations/05_Python_OOPs.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "05_Python_OOPs.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOtNPVRm26T7pIyLjHYBYRx",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mohd-faizy/Python-Concept-Jupyer-Notebooks/blob/master/05_Python_OOPs.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fA_3SBWAfh38"
      },
      "source": [
        "--- \r\n",
        "<strong> \r\n",
        "    <h1 align='center' style=\"color:red;\">Python Classes and Objects</h1> \r\n",
        "</strong>\r\n",
        "\r\n",
        "---\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u-l80noVhHeo"
      },
      "source": [
        "## __Classes and Objects__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IzMPz-B4hVZ7",
        "outputId": "25e3cc0a-c198-406f-bb7c-20c9c0443e0e"
      },
      "source": [
        "class Person:\r\n",
        "    # __init__ is called automatically every time the\r\n",
        "    # class is being used to create a new object\r\n",
        "    def __init__(self, name, age):\r\n",
        "        self.name = name\r\n",
        "        self.age = age\r\n",
        "\r\n",
        "p1 = Person(\"John\", 36) # Object of Class\r\n",
        "\r\n",
        "print(p1.name)\r\n",
        "print(p1.age)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "John\n",
            "36\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rWq1nv6tidTm",
        "outputId": "f6f59554-e013-4fee-e05e-c5a9911d2a54"
      },
      "source": [
        "class Person:\r\n",
        "    def __init__(self, name, age):\r\n",
        "        self.name = name\r\n",
        "        self.age = age\r\n",
        "\r\n",
        "    def myfunc(self):\r\n",
        "         print(\"Hello my name is \" + self.name)\r\n",
        "\r\n",
        "p1 = Person(\"John\", 36)\r\n",
        "p1.myfunc()"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello my name is John\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FihNmJ_7osoB"
      },
      "source": [
        "## __Python Inheritance__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZUkW1b_ioudB",
        "outputId": "dd8c1bb1-db6d-4697-80b4-95ea5384f87c"
      },
      "source": [
        "class Person:                        # Parent Class\r\n",
        "    def __init__(self, fname, lname):# Arguments\r\n",
        "        self.firstname = fname       # properties\r\n",
        "        self.lastname = lname        # properties\r\n",
        "\r\n",
        "    def printname(self):             # Method\r\n",
        "        print(self.firstname, self.lastname)\r\n",
        "\r\n",
        "'''\r\n",
        "Use the Person class to create an object,\r\n",
        "and then execute the printname method\r\n",
        "''' \r\n",
        "x = Person(\"John\", \"Doe\")             # Object\r\n",
        "x.printname()\r\n",
        "\r\n",
        "'''----------------------------------------------------'''\r\n",
        "\r\n",
        "class Student(Person):                # Child Class\r\n",
        "  pass \r\n",
        "'''\r\n",
        "Use the pass keyword when you do not want to add any\r\n",
        "other properties or methods to the class.\r\n",
        "'''\r\n",
        "x = Student(\"Mike\", \"Olsen\")           # Object\r\n",
        "x.printname()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "John Doe\n",
            "Mike Olsen\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aAjCkn-dsSVr",
        "outputId": "678511fe-dcba-4a90-eeb3-87e73e5fa9c4"
      },
      "source": [
        "# Create a Parent Class\r\n",
        "\r\n",
        "class Person:\r\n",
        "    def __init__(self, fname, lname):\r\n",
        "        self.firstname = fname\r\n",
        "        self.lastname = lname\r\n",
        "\r\n",
        "    def printname(self):\r\n",
        "        print(self.firstname, self.lastname)\r\n",
        "\r\n",
        "#Use the Person class to create an object, and then execute the printname method:\r\n",
        "\r\n",
        "x = Person(\"John\", \"Doe\")\r\n",
        "x.printname()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "John Doe\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6b8zNYqsr9Ea",
        "outputId": "7ba96a5d-2e52-45a8-d442-60e2f9c24a65"
      },
      "source": [
        "# Create a Child Class\r\n",
        "\r\n",
        "class Person:\r\n",
        "  def __init__(self, fname, lname):\r\n",
        "    self.firstname = fname\r\n",
        "    self.lastname = lname\r\n",
        "\r\n",
        "  def printname(self):\r\n",
        "    print(self.firstname, self.lastname)\r\n",
        "\r\n",
        "class Student(Person):\r\n",
        "  pass\r\n",
        "\r\n",
        "x = Student(\"Mike\", \"Olsen\")\r\n",
        "x.printname()"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mike Olsen\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w26veCMMvOsi"
      },
      "source": [
        "```python\r\n",
        "class Person:                        # Parent Class\r\n",
        "\r\n",
        "    def __init__(self, fname, lname):\r\n",
        "        self.firstname = fname       # properties\r\n",
        "        self.lastname = lname        # properties\r\n",
        "\r\n",
        "    def printname(self):             # Method\r\n",
        "        print(self.firstname, self.lastname)\r\n",
        "\r\n",
        "x = Person(\"John\", \"Doe\")             # Object\r\n",
        "x.printname()\r\n",
        "\r\n",
        "\r\n",
        "class Student(Person):                # Child Class\r\n",
        "    def __init__(self, fname, lname):\r\n",
        "        #add properties etc.\r\n",
        "\r\n",
        "x = Student(\"Mike\", \"Olsen\")\r\n",
        "x.printname()\r\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VrenM-shrahx",
        "outputId": "94e22c2b-df26-43a9-b0bd-d7a263bbf5ef"
      },
      "source": [
        "class Person:                        # Parent Class\r\n",
        "    def __init__(self, fname, lname):\r\n",
        "        self.firstname = fname       # properties\r\n",
        "        self.lastname = lname        # properties\r\n",
        "\r\n",
        "    def printname(self):             # Method\r\n",
        "        print(self.firstname, self.lastname)\r\n",
        "'''\r\n",
        "Note: The child's __init__() function overrides the\r\n",
        "inheritance of the parent's __init__() function\r\n",
        "'''\r\n",
        "class Student(Person):                # Child Class\r\n",
        "    def __init__(self, fname, lname):\r\n",
        "        Person.__init__(self, fname, lname)\r\n",
        "\r\n",
        "'''\r\n",
        "To keep the inheritance of the parent's __init__() \r\n",
        "function, add a call to the parent's __init__() function\r\n",
        "'''\r\n",
        "x = Student(\"Mike\", \"Olsen\")\r\n",
        "x.printname()"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mike Olsen\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-mm-133uuGtu"
      },
      "source": [
        "__`super()`__ function that will make the **child class** inherit **all the methods and properties** from its **parent**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L_twWw20qkJV",
        "outputId": "76d20d7c-b0be-4b2d-d26b-d3e74304dd5a"
      },
      "source": [
        "class Person:\r\n",
        "  def __init__(self, fname, lname):\r\n",
        "    self.firstname = fname\r\n",
        "    self.lastname = lname\r\n",
        "\r\n",
        "  def printname(self):\r\n",
        "    print(self.firstname, self.lastname)\r\n",
        "\r\n",
        "class Student(Person):\r\n",
        "  def __init__(self, fname, lname):\r\n",
        "    super().__init__(fname, lname)\r\n",
        "\r\n",
        "x = Student(\"Mike\", \"Olsen\")\r\n",
        "x.printname()"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mike Olsen\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pHlsB8BLueK2",
        "outputId": "4c5194ee-cb15-462e-cc80-281f50e76256"
      },
      "source": [
        "class Person:\r\n",
        "  def __init__(self, fname, lname):\r\n",
        "    self.firstname = fname\r\n",
        "    self.lastname = lname\r\n",
        "\r\n",
        "  def printname(self):\r\n",
        "    print(self.firstname, self.lastname)\r\n",
        "\r\n",
        "class Student(Person):\r\n",
        "  def __init__(self, fname, lname):\r\n",
        "    super().__init__(fname, lname)\r\n",
        "    self.graduationyear = 2019      # Adding Properties\r\n",
        "\r\n",
        "x = Student(\"Mike\", \"Olsen\")\r\n",
        "\r\n",
        "print(x.firstname)\r\n",
        "print(x.lastname)\r\n",
        "print(x.graduationyear)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mike\n",
            "Olsen\n",
            "2019\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2hzDc-IUvpGQ",
        "outputId": "e162ef4a-a8b5-415c-ca2c-48cc46909112"
      },
      "source": [
        "class Person:\r\n",
        "  def __init__(self, fname, lname):\r\n",
        "    self.firstname = fname\r\n",
        "    self.lastname = lname\r\n",
        "\r\n",
        "  def printname(self):\r\n",
        "    print(self.firstname, self.lastname)\r\n",
        "\r\n",
        "class Student(Person):\r\n",
        "  def __init__(self, fname, lname, year): # adding a new argument \r\n",
        "    super().__init__(fname, lname)        # inheritance from the Parent Class\r\n",
        "    self.graduationyear = year            # Adding a new Property to child\r\n",
        "\r\n",
        "x = Student(\"Mike\", \"Olsen\", 2019)\r\n",
        "\r\n",
        "print(x.printname())\r\n",
        "print(x.graduationyear)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mike Olsen\n",
            "None\n",
            "2019\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JSxViz_oxECZ",
        "outputId": "9a57c9f9-34b5-4af8-8f9b-0c88df696624"
      },
      "source": [
        "# Adding Methods\r\n",
        "\r\n",
        "class Person:\r\n",
        "  def __init__(self, fname, lname):\r\n",
        "    self.firstname = fname\r\n",
        "    self.lastname = lname\r\n",
        "\r\n",
        "  def printname(self):\r\n",
        "    print(self.firstname, self.lastname)\r\n",
        "\r\n",
        "class Student(Person):\r\n",
        "  def __init__(self, fname, lname, year):\r\n",
        "    super().__init__(fname, lname)\r\n",
        "    self.graduationyear = year\r\n",
        "\r\n",
        "  def welcome(self):\r\n",
        "    print(\"Welcome\", self.firstname, self.lastname, \"to the class of\", self.graduationyear)\r\n",
        "\r\n",
        "x = Student(\"Mike\", \"Olsen\", 2019)\r\n",
        "x.welcome()"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Welcome Mike Olsen to the class of 2019\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-mpodFmU1Gfn"
      },
      "source": [
        "$\\color{red}{\\textbf{Note:}}$ If we add a method in the child class with the __same name__ as a function in the parent class, the inheritance of the parent method will be **overridden**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6BPj5bP12-70"
      },
      "source": [
        "## __Python Iterators__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IjKCyI0y3F6n",
        "outputId": "3e9819c8-4f56-4da2-fda4-b29a65cd8bd8"
      },
      "source": [
        "mytuple = (\"apple\", \"banana\", \"cherry\")\r\n",
        "myit = iter(mytuple)\r\n",
        "\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))   "
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2eMPEuGo3IRo",
        "outputId": "e4aa954a-ca6d-4a96-cb32-250d1e0fe8b1"
      },
      "source": [
        "mystr = \"banana\"\r\n",
        "myit = iter(mystr)\r\n",
        "\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "b\n",
            "a\n",
            "n\n",
            "a\n",
            "n\n",
            "a\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NvANC91A3kxt",
        "outputId": "a8c40d31-4ecd-43e1-eb34-f5b2e6f19472"
      },
      "source": [
        "mytuple = (\"apple\", \"banana\", \"cherry\")\r\n",
        "\r\n",
        "for x in mytuple:\r\n",
        "  print(x)\r\n",
        "\r\n",
        "'''-----------------------'''\r\n",
        "\r\n",
        "mystr = \"banana\"\r\n",
        "\r\n",
        "for x in mystr:\r\n",
        "  print(x)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "apple\n",
            "banana\n",
            "cherry\n",
            "b\n",
            "a\n",
            "n\n",
            "a\n",
            "n\n",
            "a\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8UQK0huO39n2",
        "outputId": "70fd5ce2-a99e-4eb0-bd2f-dd2fd2303490"
      },
      "source": [
        "class MyNumbers:\r\n",
        "  def __iter__(self):\r\n",
        "    self.a = 1\r\n",
        "    return self\r\n",
        "\r\n",
        "  def __next__(self):\r\n",
        "    x = self.a\r\n",
        "    self.a += 1\r\n",
        "    return x\r\n",
        "\r\n",
        "myclass = MyNumbers()\r\n",
        "myiter = iter(myclass)\r\n",
        "\r\n",
        "print(next(myiter))\r\n",
        "print(next(myiter))\r\n",
        "print(next(myiter))\r\n",
        "print(next(myiter))\r\n",
        "print(next(myiter))"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0rluvy534udO"
      },
      "source": [
        "__StopIteration__\r\n",
        "\r\n",
        "- The example above would continue forever if you had enough `next()` statements, or if it was used in a for loop.\r\n",
        "\r\n",
        "\r\n",
        "```python\r\n",
        "mytuple = (\"apple\", \"banana\", \"cherry\")\r\n",
        "myit = iter(mytuple)\r\n",
        "\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))\r\n",
        "print(next(myit))  \r\n",
        "---------------------------------------------------------------------------\r\n",
        "StopIteration                             Traceback (most recent call last)\r\n",
        "<ipython-input-39-d15994af4a28> in <module>()\r\n",
        "      5 print(next(myit))\r\n",
        "      6 print(next(myit))\r\n",
        "----> 7 print(next(myit))\r\n",
        "```\r\n",
        "- To prevent the iteration to go on forever, we can use the `StopIteration` statement.\r\n",
        "\r\n",
        "- In the `__next__()` method, we can add a terminating condition to raise an error if the iteration is done a specified number of times."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lo3Gj4Bg4F74",
        "outputId": "bde5b11a-3307-426e-c5f1-6b7163844a7b"
      },
      "source": [
        "class MyNumbers:\r\n",
        "  def __iter__(self):\r\n",
        "    self.a = 1\r\n",
        "    return self\r\n",
        "\r\n",
        "  def __next__(self):\r\n",
        "    if self.a <= 20:\r\n",
        "      x = self.a\r\n",
        "      self.a += 1\r\n",
        "      return x\r\n",
        "    else:\r\n",
        "      raise StopIteration\r\n",
        "\r\n",
        "myclass = MyNumbers()\r\n",
        "myiter = iter(myclass)\r\n",
        "\r\n",
        "for x in myiter:\r\n",
        "  print(x)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n",
            "13\n",
            "14\n",
            "15\n",
            "16\n",
            "17\n",
            "18\n",
            "19\n",
            "20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Hb8Q_JW53Nf"
      },
      "source": [
        "## __Python Scope__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1S4Xj90D5EEA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "84debb02-8a86-41d9-c561-681d891cd2a1"
      },
      "source": [
        "# A variable created inside a function is available inside that function\r\n",
        "\r\n",
        "def myfunc():\r\n",
        "    x = 300\r\n",
        "    print(x)\r\n",
        "\r\n",
        "myfunc()"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "300\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g_7b-qLR_YEd",
        "outputId": "9b2db9b9-85f2-4b4b-f350-d1b558a2c067"
      },
      "source": [
        "# Function Inside Function\r\n",
        "\r\n",
        "def myfunc():\r\n",
        "    x = 300\r\n",
        "    def myinnerfunc():\r\n",
        "        print(x)\r\n",
        "    myinnerfunc()\r\n",
        "\r\n",
        "myfunc()"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "300\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e2GbS9LZ_p8T",
        "outputId": "0ef03f9a-a609-484d-8f10-7a70cb3ca4b4"
      },
      "source": [
        "# Global Scope\r\n",
        "\r\n",
        "x = 300\r\n",
        "\r\n",
        "def myfunc():\r\n",
        "     print(x)\r\n",
        "\r\n",
        "myfunc()\r\n",
        "\r\n",
        "print(x)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "300\n",
            "300\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3yCDIipF__Kg",
        "outputId": "5510055a-9b9d-4a99-eb2b-4f1ebe2c1ff0"
      },
      "source": [
        "x = 300\r\n",
        "\r\n",
        "def myfunc():\r\n",
        "    x = 200\r\n",
        "    print(x)\r\n",
        "\r\n",
        "myfunc()\r\n",
        "\r\n",
        "print(x)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "200\n",
            "300\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bbokfu16AObl",
        "outputId": "806f0289-e110-4d84-b0bb-ca405e51d977"
      },
      "source": [
        "# Global Keyword\r\n",
        "\r\n",
        "def myfunc():\r\n",
        "    global x\r\n",
        "    x = 300\r\n",
        "\r\n",
        "myfunc()\r\n",
        "\r\n",
        "print(x)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "300\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EfPhl6vlAoSj",
        "outputId": "a31eca38-a91a-4921-d27c-a346801e6cf0"
      },
      "source": [
        "x = 300\r\n",
        "\r\n",
        "def myfunc():\r\n",
        "    global x\r\n",
        "    x = 200\r\n",
        "    \r\n",
        "myfunc()\r\n",
        "\r\n",
        "print(x)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "200\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QgSeofURAvpA"
      },
      "source": [
        "## __Python Modules__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tYAnBzVNA8ZI"
      },
      "source": [
        "- module Can be considere same as a code library.\r\n",
        "- To create a module just save the code you want in a file with the file extension `.py`\r\n",
        "\r\n",
        "```python\r\n",
        "# Save it as mymodule.py\r\n",
        "def greeting(name):\r\n",
        "  print(\"Hello, \" + name)\r\n",
        "```\r\n",
        "```python\r\n",
        "import mymodule\r\n",
        "mymodule.greeting(\"Jonathan\")\r\n",
        "\r\n",
        "# Output\r\n",
        "Hello, Jonathan\r\n",
        "```\r\n",
        "\r\n",
        "```python\r\n",
        "# Save it as mymodule.py\r\n",
        "\r\n",
        "person1 = {\r\n",
        "  \"name\": \"John\",\r\n",
        "  \"age\": 36,\r\n",
        "  \"country\": \"Norway\"\r\n",
        "}\r\n",
        "\r\n",
        "import mymodule as mx\r\n",
        "\r\n",
        "a = mx.person1[\"age\"]\r\n",
        "print(a)\r\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "65DxlhhkAqgc",
        "outputId": "4e38ad10-ec43-4eb0-f3f8-b2208369c1e7"
      },
      "source": [
        "# There is a built-in function to list all the function names\r\n",
        "# (or variable names) in a module. The dir() function\r\n",
        "\r\n",
        "import tensorflow as tf\r\n",
        "\r\n",
        "x = dir(tf)\r\n",
        "print(x)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['AggregationMethod', 'Assert', 'CriticalSection', 'DType', 'DeviceSpec', 'GradientTape', 'Graph', 'IndexedSlices', 'IndexedSlicesSpec', 'Module', 'Operation', 'OptionalSpec', 'RaggedTensor', 'RaggedTensorSpec', 'RegisterGradient', 'SparseTensor', 'SparseTensorSpec', 'Tensor', 'TensorArray', 'TensorArraySpec', 'TensorShape', 'TensorSpec', 'TypeSpec', 'UnconnectedGradients', 'Variable', 'VariableAggregation', 'VariableSynchronization', '_API_MODULE', '_LazyLoader', '__all__', '__builtins__', '__cached__', '__compiler_version__', '__cxx11_abi_flag__', '__doc__', '__file__', '__git_version__', '__loader__', '__monolithic_build__', '__name__', '__operators__', '__package__', '__path__', '__spec__', '__version__', '_absolute_import', '_api', '_compat', '_current_file_location', '_current_module', '_distutils', '_division', '_estimator_module', '_fi', '_inspect', '_ll', '_logging', '_main_dir', '_major_api_version', '_module_dir', '_module_util', '_names_with_underscore', '_os', '_plugin_dir', '_print_function', '_running_from_pip_package', '_s', '_site', '_site_packages_dirs', '_six', '_sys', '_tf2', '_tf_api_dir', '_typing', 'abs', 'acos', 'acosh', 'add', 'add_n', 'argmax', 'argmin', 'argsort', 'as_dtype', 'as_string', 'asin', 'asinh', 'assert_equal', 'assert_greater', 'assert_less', 'assert_rank', 'atan', 'atan2', 'atanh', 'audio', 'autodiff', 'autograph', 'batch_to_space', 'bfloat16', 'bitcast', 'bitwise', 'bool', 'boolean_mask', 'broadcast_dynamic_shape', 'broadcast_static_shape', 'broadcast_to', 'case', 'cast', 'clip_by_global_norm', 'clip_by_norm', 'clip_by_value', 'compat', 'compiler', 'complex', 'complex128', 'complex64', 'concat', 'cond', 'config', 'constant', 'constant_initializer', 'control_dependencies', 'convert_to_tensor', 'core', 'cos', 'cosh', 'cumsum', 'custom_gradient', 'data', 'debugging', 'device', 'distribute', 'divide', 'double', 'dtypes', 'dynamic_partition', 'dynamic_stitch', 'edit_distance', 'eig', 'eigvals', 'einsum', 'ensure_shape', 'equal', 'errors', 'estimator', 'executing_eagerly', 'exp', 'expand_dims', 'experimental', 'extract_volume_patches', 'eye', 'feature_column', 'fill', 'fingerprint', 'float16', 'float32', 'float64', 'floor', 'foldl', 'foldr', 'function', 'gather', 'gather_nd', 'get_logger', 'get_static_value', 'grad_pass_through', 'gradients', 'graph_util', 'greater', 'greater_equal', 'group', 'guarantee_const', 'half', 'hessians', 'histogram_fixed_width', 'histogram_fixed_width_bins', 'identity', 'identity_n', 'image', 'import_graph_def', 'init_scope', 'initializers', 'int16', 'int32', 'int64', 'int8', 'io', 'is_tensor', 'keras', 'less', 'less_equal', 'linalg', 'linspace', 'lite', 'load_library', 'load_op_library', 'logical_and', 'logical_not', 'logical_or', 'lookup', 'losses', 'make_ndarray', 'make_tensor_proto', 'map_fn', 'math', 'matmul', 'matrix_square_root', 'maximum', 'meshgrid', 'metrics', 'minimum', 'mixed_precision', 'mlir', 'multiply', 'name_scope', 'negative', 'nest', 'newaxis', 'nn', 'no_gradient', 'no_op', 'nondifferentiable_batch_function', 'norm', 'not_equal', 'numpy_function', 'one_hot', 'ones', 'ones_initializer', 'ones_like', 'optimizers', 'pad', 'parallel_stack', 'pow', 'print', 'profiler', 'py_function', 'python', 'qint16', 'qint32', 'qint8', 'quantization', 'queue', 'quint16', 'quint8', 'ragged', 'random', 'random_normal_initializer', 'random_uniform_initializer', 'range', 'rank', 'raw_ops', 'realdiv', 'recompute_grad', 'reduce_all', 'reduce_any', 'reduce_logsumexp', 'reduce_max', 'reduce_mean', 'reduce_min', 'reduce_prod', 'reduce_sum', 'register_tensor_conversion_function', 'repeat', 'required_space_to_batch_paddings', 'reshape', 'resource', 'reverse', 'reverse_sequence', 'roll', 'round', 'saturate_cast', 'saved_model', 'scalar_mul', 'scan', 'scatter_nd', 'searchsorted', 'sequence_mask', 'sets', 'shape', 'shape_n', 'sigmoid', 'sign', 'signal', 'sin', 'sinh', 'size', 'slice', 'sort', 'space_to_batch', 'space_to_batch_nd', 'sparse', 'split', 'sqrt', 'square', 'squeeze', 'stack', 'stop_gradient', 'strided_slice', 'string', 'strings', 'subtract', 'summary', 'switch_case', 'sysconfig', 'tan', 'tanh', 'tensor_scatter_nd_add', 'tensor_scatter_nd_max', 'tensor_scatter_nd_min', 'tensor_scatter_nd_sub', 'tensor_scatter_nd_update', 'tensordot', 'test', 'tile', 'timestamp', 'tools', 'tpu', 'train', 'transpose', 'truediv', 'truncatediv', 'truncatemod', 'tuple', 'type_spec_from_value', 'uint16', 'uint32', 'uint64', 'uint8', 'unique', 'unique_with_counts', 'unravel_index', 'unstack', 'variable_creator_scope', 'variant', 'vectorized_map', 'version', 'where', 'while_loop', 'xla', 'zeros', 'zeros_initializer', 'zeros_like']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XcS2fwHlGHE-"
      },
      "source": [
        "```python \r\n",
        "# we can also choose to import only parts\r\n",
        "# from a module, by using the from keyword\r\n",
        "\r\n",
        "# Save it as mymodule.py\r\n",
        "def greeting(name):\r\n",
        "  print(\"Hello, \" + name)\r\n",
        "\r\n",
        "person1 = {\r\n",
        "  \"name\": \"John\",\r\n",
        "  \"age\": 36,\r\n",
        "  \"country\": \"Norway\"\r\n",
        "}\r\n",
        "\r\n",
        "person2 = {\r\n",
        "  \"name\": \"Mike\",\r\n",
        "  \"age\": 64,\r\n",
        "  \"country\": \"Russia\"\r\n",
        "}\r\n",
        "'''--------calling the only the person1--------'''\r\n",
        "\r\n",
        "from mymodule import person1\r\n",
        "\r\n",
        "print (person1[\"age\"])\r\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "40dcIVilHdor"
      },
      "source": [
        "$\\color{red}{\\textbf{NOTE:}}$ When importing using the `from` **keyword, do not use the module name when referring to elements in the module. Example:** `person1[\"age\"]`, **not** `mymodule.person1[\"age\"]`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "An1gik4oIEgW"
      },
      "source": [
        "## __Python Datetime__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i5J9qipXFYFc",
        "outputId": "80505228-7a9d-4af0-d93d-e43b7f7f6144"
      },
      "source": [
        "import datetime\r\n",
        "\r\n",
        "x = datetime.datetime.now()\r\n",
        "print(x)"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2020-12-12 13:45:37.838833\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KbDLdsM-IPsL",
        "outputId": "7ca406c6-cf0d-4a91-c413-53417c7d00be"
      },
      "source": [
        "import datetime\r\n",
        "\r\n",
        "x = datetime.datetime.now()\r\n",
        "\r\n",
        "print(x.year)\r\n",
        "print(x.strftime(\"%a\"))\r\n",
        "print(x.strftime(\"%A\"))\r\n",
        "print(x.strftime(\"%w\"))\r\n",
        "print(x.strftime(\"%d\"))\r\n",
        "print(x.strftime(\"%b\"))\r\n",
        "print(x.strftime(\"%B\"))\r\n",
        "print(x.strftime(\"%m\"))\r\n",
        "print(x.strftime(\"%y\"))\r\n",
        "print(x.strftime(\"%Y\"))\r\n",
        "print(x.strftime(\"%H\"))\r\n",
        "print(x.strftime(\"%I\"))\r\n",
        "print(x.strftime(\"%p\"))\r\n",
        "print(x.strftime(\"%M\"))"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2020\n",
            "Sat\n",
            "Saturday\n",
            "6\n",
            "12\n",
            "Dec\n",
            "December\n",
            "12\n",
            "20\n",
            "2020\n",
            "13\n",
            "01\n",
            "PM\n",
            "45\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tOEWzGKmKmHf",
        "outputId": "e5fdf457-ba05-4056-ca2f-c7e9bc133b19"
      },
      "source": [
        "import datetime\r\n",
        "\r\n",
        "x = datetime.datetime(2018, 6, 1)\r\n",
        "\r\n",
        "print(x.strftime(\"%B\"))"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "June\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lxxrenFPKs2o"
      },
      "source": [
        "## __Python Math__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ICoIMKNYK7wf"
      },
      "source": [
        "__`min()` and `max()`__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nfpem-aGKsHB",
        "outputId": "908da196-ae44-4ae0-9216-f5e6af3b8706"
      },
      "source": [
        "x = min(5, 10, 25)\r\n",
        "y = max(5, 10, 25)\r\n",
        "\r\n",
        "print(x)\r\n",
        "print(y)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gjNBlLN3LHBO"
      },
      "source": [
        "`abs()` function returns the **absolute(positive)** value of the specified number"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6greIhsbLMJN",
        "outputId": "48f666d6-3bc3-4c96-d198-52e6b614446c"
      },
      "source": [
        "x = abs(-7.25)\r\n",
        "\r\n",
        "print(x)"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7.25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p3ad51C8LSpa"
      },
      "source": [
        "`pow(x, y)` function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UE_8Bv7ULPK6",
        "outputId": "c8f6d226-1cfc-4692-f8b9-a36e5857f889"
      },
      "source": [
        "x = pow(4, 3)\r\n",
        "\r\n",
        "print(x)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y85FjrxvLevN",
        "outputId": "e477e4c8-75bc-4e1b-a079-e6083d1fdaa5"
      },
      "source": [
        "import math\r\n",
        "\r\n",
        "x = math.sqrt(64)\r\n",
        "\r\n",
        "print(x)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CK24_wxrLifh",
        "outputId": "a085fd0d-26e6-4da1-b432-2da2fa6e7bb5"
      },
      "source": [
        "import math\r\n",
        "\r\n",
        "x = math.ceil(1.4)\r\n",
        "y = math.floor(1.4)\r\n",
        "\r\n",
        "print(x) # returns 2\r\n",
        "print(y) # returns 1"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fcaCrQsCLm-5",
        "outputId": "a634e40c-8391-40ac-ba52-34e238eabb73"
      },
      "source": [
        "import math\r\n",
        "\r\n",
        "x = math.pi\r\n",
        "\r\n",
        "print(x)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KIt1aiVGL-68"
      },
      "source": [
        "## __Python JSON__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ruXkVv0PL-Uu",
        "outputId": "da5346f8-9163-465d-cd43-1d872e78ac54"
      },
      "source": [
        "# Convert from JSON to Python\r\n",
        "# If you have a JSON string, we canparse it by using the json.loads() method\r\n",
        "\r\n",
        "import json\r\n",
        "\r\n",
        "# some JSON:\r\n",
        "x =  '{ \"name\":\"John\", \"age\":30, \"city\":\"New York\"}'\r\n",
        "\r\n",
        "# parse x:\r\n",
        "y = json.loads(x)\r\n",
        "\r\n",
        "# the result is a Python dictionary:\r\n",
        "print(y[\"age\"])"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "30\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uCVpUsCNMb0R",
        "outputId": "5fd291a1-a115-4f1e-ca2b-66d8bdef915b"
      },
      "source": [
        "# Convert from Python to JSON\r\n",
        "\r\n",
        "import json\r\n",
        "\r\n",
        "# a Python object (dict):\r\n",
        "x = {\r\n",
        "  \"name\": \"John\",\r\n",
        "  \"age\": 30,\r\n",
        "  \"city\": \"New York\"\r\n",
        "}\r\n",
        "\r\n",
        "# convert into JSON:\r\n",
        "y = json.dumps(x)\r\n",
        "\r\n",
        "# the result is a JSON string:\r\n",
        "print(y)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MlErvkAKMldN"
      },
      "source": [
        "__We can convert Python objects of the following types, into JSON strings:__\r\n",
        "\r\n",
        "- __dict__\r\n",
        "- __list__\r\n",
        "- __tuple__\r\n",
        "- __string__\r\n",
        "- __int__\r\n",
        "- __float__\r\n",
        "- __True__\r\n",
        "- __False__\r\n",
        "- __None__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "16AnZ1hfM6cd",
        "outputId": "0a2b70bc-a2b3-40f7-de6c-7a1526f03421"
      },
      "source": [
        "import json\r\n",
        "\r\n",
        "print(json.dumps({\"name\": \"John\", \"age\": 30}))\r\n",
        "print(json.dumps([\"apple\", \"bananas\"]))\r\n",
        "print(json.dumps((\"apple\", \"bananas\")))\r\n",
        "print(json.dumps(\"hello\"))\r\n",
        "print(json.dumps(42))\r\n",
        "print(json.dumps(31.76))\r\n",
        "print(json.dumps(True))\r\n",
        "print(json.dumps(False))\r\n",
        "print(json.dumps(None))"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{\"name\": \"John\", \"age\": 30}\n",
            "[\"apple\", \"bananas\"]\n",
            "[\"apple\", \"bananas\"]\n",
            "\"hello\"\n",
            "42\n",
            "31.76\n",
            "true\n",
            "false\n",
            "null\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XjbG35zqNFtu"
      },
      "source": [
        "|Python|JSON|\r\n",
        "|------|-----|\r\n",
        "|dict|Object|\r\n",
        "|list|Array|\r\n",
        "|tuple|Array|\r\n",
        "|str|String|\r\n",
        "|int|Number|\r\n",
        "|float|Number|\r\n",
        "|True|true|\r\n",
        "|False|false|\r\n",
        "|None|null|"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D_nZj7LrNEmu",
        "outputId": "54498fd8-922c-4e28-9c68-aff287ae38df"
      },
      "source": [
        "# Convert a Python object containing all the legal data types\r\n",
        "\r\n",
        "import json\r\n",
        "\r\n",
        "x = {\r\n",
        "  \"name\": \"John\",\r\n",
        "  \"age\": 30,\r\n",
        "  \"married\": True,\r\n",
        "  \"divorced\": False,\r\n",
        "  \"children\": (\"Ann\",\"Billy\"),\r\n",
        "  \"pets\": None,\r\n",
        "  \"cars\": [\r\n",
        "    {\"model\": \"BMW 230\", \"mpg\": 27.5},\r\n",
        "    {\"model\": \"Ford Edge\", \"mpg\": 24.1}\r\n",
        "  ]\r\n",
        "}\r\n",
        "\r\n",
        "print(json.dumps(x))"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{\"name\": \"John\", \"age\": 30, \"married\": true, \"divorced\": false, \"children\": [\"Ann\", \"Billy\"], \"pets\": null, \"cars\": [{\"model\": \"BMW 230\", \"mpg\": 27.5}, {\"model\": \"Ford Edge\", \"mpg\": 24.1}]}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yYu58TnoOGaG",
        "outputId": "8dc35940-885f-4f0e-ecc3-6d3505ac3f29"
      },
      "source": [
        "# Format the Result\r\n",
        "\r\n",
        "import json\r\n",
        "\r\n",
        "x = {\r\n",
        "  \"name\": \"John\",\r\n",
        "  \"age\": 30,\r\n",
        "  \"married\": True,\r\n",
        "  \"divorced\": False,\r\n",
        "  \"children\": (\"Ann\",\"Billy\"),\r\n",
        "  \"pets\": None,\r\n",
        "  \"cars\": [\r\n",
        "    {\"model\": \"BMW 230\", \"mpg\": 27.5},\r\n",
        "    {\"model\": \"Ford Edge\", \"mpg\": 24.1}\r\n",
        "  ]\r\n",
        "}\r\n",
        "\r\n",
        "# use four indents to make it easier to read the result:\r\n",
        "print(json.dumps(x, indent=4))"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{\n",
            "    \"name\": \"John\",\n",
            "    \"age\": 30,\n",
            "    \"married\": true,\n",
            "    \"divorced\": false,\n",
            "    \"children\": [\n",
            "        \"Ann\",\n",
            "        \"Billy\"\n",
            "    ],\n",
            "    \"pets\": null,\n",
            "    \"cars\": [\n",
            "        {\n",
            "            \"model\": \"BMW 230\",\n",
            "            \"mpg\": 27.5\n",
            "        },\n",
            "        {\n",
            "            \"model\": \"Ford Edge\",\n",
            "            \"mpg\": 24.1\n",
            "        }\n",
            "    ]\n",
            "}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NSrD65Y5OVT8",
        "outputId": "91ceac60-87cc-42d5-8c2d-fa1007c0955b"
      },
      "source": [
        "# Use the separators parameter to change the default separator\r\n",
        "\r\n",
        "import json\r\n",
        "\r\n",
        "x = {\r\n",
        "  \"name\": \"John\",\r\n",
        "  \"age\": 30,\r\n",
        "  \"married\": True,\r\n",
        "  \"divorced\": False,\r\n",
        "  \"children\": (\"Ann\",\"Billy\"),\r\n",
        "  \"pets\": None,\r\n",
        "  \"cars\": [\r\n",
        "    {\"model\": \"BMW 230\", \"mpg\": 27.5},\r\n",
        "    {\"model\": \"Ford Edge\", \"mpg\": 24.1}\r\n",
        "  ]\r\n",
        "}\r\n",
        "\r\n",
        "# use . and a space to separate objects, and a space, a = and a space to separate keys from their values:\r\n",
        "print(json.dumps(x, indent=4, separators=(\". \", \" = \")))\r\n"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{\n",
            "    \"name\" = \"John\". \n",
            "    \"age\" = 30. \n",
            "    \"married\" = true. \n",
            "    \"divorced\" = false. \n",
            "    \"children\" = [\n",
            "        \"Ann\". \n",
            "        \"Billy\"\n",
            "    ]. \n",
            "    \"pets\" = null. \n",
            "    \"cars\" = [\n",
            "        {\n",
            "            \"model\" = \"BMW 230\". \n",
            "            \"mpg\" = 27.5\n",
            "        }. \n",
            "        {\n",
            "            \"model\" = \"Ford Edge\". \n",
            "            \"mpg\" = 24.1\n",
            "        }\n",
            "    ]\n",
            "}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wo4WpRIKOl34",
        "outputId": "f7bfeb98-d3d5-4fbd-957f-e56e98296aa5"
      },
      "source": [
        "# Use the sort_keys parameter to specify if the result should be sorted or not\r\n",
        "\r\n",
        "import json\r\n",
        "\r\n",
        "x = {\r\n",
        "  \"name\": \"John\",\r\n",
        "  \"age\": 30,\r\n",
        "  \"married\": True,\r\n",
        "  \"divorced\": False,\r\n",
        "  \"children\": (\"Ann\",\"Billy\"),\r\n",
        "  \"pets\": None,\r\n",
        "  \"cars\": [\r\n",
        "    {\"model\": \"BMW 230\", \"mpg\": 27.5},\r\n",
        "    {\"model\": \"Ford Edge\", \"mpg\": 24.1}\r\n",
        "  ]\r\n",
        "}\r\n",
        "\r\n",
        "# sort the result alphabetically by keys:\r\n",
        "print(json.dumps(x, indent=4, sort_keys=True))"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{\n",
            "    \"age\": 30,\n",
            "    \"cars\": [\n",
            "        {\n",
            "            \"model\": \"BMW 230\",\n",
            "            \"mpg\": 27.5\n",
            "        },\n",
            "        {\n",
            "            \"model\": \"Ford Edge\",\n",
            "            \"mpg\": 24.1\n",
            "        }\n",
            "    ],\n",
            "    \"children\": [\n",
            "        \"Ann\",\n",
            "        \"Billy\"\n",
            "    ],\n",
            "    \"divorced\": false,\n",
            "    \"married\": true,\n",
            "    \"name\": \"John\",\n",
            "    \"pets\": null\n",
            "}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S0dLNuEQO2LQ"
      },
      "source": [
        "## __Python RegEx__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DmTHne9uPDby"
      },
      "source": [
        "- A RegEx, or Regular Expression, is a sequence of characters that forms a search pattern.\r\n",
        "\r\n",
        "- RegEx can be used to check if a string contains the specified search pattern.\r\n",
        "\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1JhGGE2SwW31"
      },
      "source": [
        "__RegEx Functions__\r\n",
        "\r\n",
        "- `search` - Returns a Match object if there is a match anywhere in the string.\r\n",
        "\r\n",
        "- `findall` - Returns a list containing all matches.\r\n",
        "\r\n",
        "- `split` - Returns a list where the string has been split at each match.\r\n",
        "\r\n",
        "- `sub` - Replaces one or many matches with a string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jCZEL4aTO1l3",
        "outputId": "71f67923-7fc5-4d13-9ed0-8d7a0890d20a"
      },
      "source": [
        "import re\r\n",
        "\r\n",
        "#Check if the string starts with \"The\" and ends with \"Spain\":\r\n",
        "\r\n",
        "txt = \"The rain in Spain\"\r\n",
        "x = re.search(\"^The.*Spain$\", txt)\r\n",
        "\r\n",
        "if x:\r\n",
        "    print(\"YES! We have a match!\")\r\n",
        "else:\r\n",
        "    print(\"No match\")\r\n",
        "    "
      ],
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "YES! We have a match!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-092FKbPxlt7"
      },
      "source": [
        "__Metacharacters__\r\n",
        "\r\n",
        "<p align='center'>\r\n",
        "  <a href=\"#\">\r\n",
        "    <img src='https://www.engineeringbigdata.com/wp-content/uploads/python-regular-expression-regex-metacharacters-meanings.jpg'>\r\n",
        "  </a>\r\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CU3x6-ytyY5Z"
      },
      "source": [
        "__Special Sequences__\r\n",
        "\r\n",
        "<p align='center'>\r\n",
        "  <a href=\"#\">\r\n",
        "    <img src='https://www.engineeringbigdata.com/wp-content/uploads/python-regular-expression-regex-special-sequences.jpg'>\r\n",
        "  </a>\r\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bb7URt7nO_7g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3157a5ac-2b70-477d-ec4e-a42cf1317b50"
      },
      "source": [
        "import re\r\n",
        "\r\n",
        "#Return a list containing every occurrence of \"ai\":\r\n",
        "\r\n",
        "txt = \"The rain in Spain\"\r\n",
        "\r\n",
        "x = re.findall(\"ai\", txt)\r\n",
        "print(x)\r\n",
        "\r\n",
        "x = re.findall(\"Portugal\", txt) # Return an empty list if no match was found\r\n",
        "print(x)"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['ai', 'ai']\n",
            "[]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NCsj8UnF9qSF",
        "outputId": "8aea93ec-6e0f-4e06-d699-9fa8aed1379d"
      },
      "source": [
        "import re\r\n",
        "\r\n",
        "txt = \"The rain in Spain\"\r\n",
        "x = re.search(\"\\s\", txt)\r\n",
        "\r\n",
        "print(\"The first white-space character is located in position:\", x.start())"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The first white-space character is located in position: 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FAEdwCxh91-0",
        "outputId": "7c6ce039-e515-48ea-9e3f-4ff893f4f658"
      },
      "source": [
        "# Split\r\n",
        "\r\n",
        "import re\r\n",
        "\r\n",
        "txt = \"The rain in Spain\"\r\n",
        "\r\n",
        "x = re.split(\"\\s\", txt)    # Split at each white-space character\r\n",
        "print(x)\r\n",
        "\r\n",
        "x = re.split(\"\\s\", txt, 1) # Split the string only at the first occurrence\r\n",
        "print(x)"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['The', 'rain', 'in', 'Spain']\n",
            "['The', 'rain in Spain']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "udwGF1xm99Vb",
        "outputId": "42512a8f-fa35-44bc-c757-6cfa0826b0da"
      },
      "source": [
        "import re\r\n",
        "\r\n",
        "txt = \"The rain in Spain\"\r\n",
        "\r\n",
        "x = re.sub(\"\\s\", \"9\", txt)    # Replace every white-space character with - 9\r\n",
        "print(x)\r\n",
        "\r\n",
        "\r\n",
        "x = re.sub(\"\\s\", \"9\", txt, 2) # Replace the first 2 occurrences\r\n",
        "print(x)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The9rain9in9Spain\n",
            "The9rain9in Spain\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vdMP-j7l-oCt",
        "outputId": "7c6347e0-25a5-4e34-e232-dbd2c2fc8289"
      },
      "source": [
        "import re\r\n",
        "\r\n",
        "#The search() function returns a Match object:\r\n",
        "\r\n",
        "txt = \"The rain in Spain\"\r\n",
        "x = re.search(\"ai\", txt)\r\n",
        "print(x)"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<_sre.SRE_Match object; span=(5, 7), match='ai'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2LdjquqN_GtT"
      },
      "source": [
        "The Match object has properties and methods used to retrieve information about the search, and the result:\r\n",
        "\r\n",
        "- `.span()` returns a tuple containing the start-, and end positions of the match.\r\n",
        "- `.string` returns the string passed into the function.\r\n",
        "- `.group()` returns the part of the string where there was a match"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hERbGghZ_OIw",
        "outputId": "30e6ca27-6b8b-448e-82ae-19fe18295e6b"
      },
      "source": [
        "import re\r\n",
        "\r\n",
        "txt = \"The rain in Spain\"\r\n",
        "x = re.search(r\"\\bS\\w+\", txt)\r\n",
        "print(x.span())"
      ],
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(12, 17)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y6Fd9-Z7FDzp",
        "outputId": "0b6f4fc6-6932-4b79-9f86-fc2ea0a7db89"
      },
      "source": [
        "import re\r\n",
        "\r\n",
        "txt = \"The rain in Spain\"\r\n",
        "x = re.search(r\"\\bS\\w+\", txt)\r\n",
        "print(x.string)"
      ],
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The rain in Spain\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q6JVSukYFanh"
      },
      "source": [
        "## __PIP__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VQ-SjDSlGiiD"
      },
      "source": [
        "- PIP is a package manager for Python packages.\r\n",
        "\r\n",
        "\r\n",
        "- $\\color{red}{\\textbf{Note:}}$ If you have Python version 3.4 or later, PIP is included by default."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KnpRU8BSHDc0"
      },
      "source": [
        "```\r\n",
        "# Remove a Package\r\n",
        "\r\n",
        "C:\\Users\\Your Name\\AppData\\Local\\Programs\\Python\\Python36-32\\Scripts>pip uninstall camelcase\r\n",
        "\r\n",
        "# List Packages\r\n",
        "\r\n",
        "C:\\Users\\Your Name\\AppData\\Local\\Programs\\Python\\Python36-32\\Scripts>pip list\r\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TdUEodnuHi9-"
      },
      "source": [
        "## __Python Try Except__"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ax7Nd_A8Hv6J"
      },
      "source": [
        "- The `try` block lets you test a block of code for errors.\r\n",
        "\r\n",
        "- The `except` block lets you handle the error.\r\n",
        "\r\n",
        "- The `finally` block lets you execute code, regardless of the result of the try- and except blocks."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nD2cLHKTIAej"
      },
      "source": [
        "```python\r\n",
        "# This statement will raise an error, because x is not defined:\r\n",
        "\r\n",
        "print(x)\r\n",
        "\r\n",
        "-------------------------------------\r\n",
        "NameError                                 Traceback (most recent call last)\r\n",
        "<ipython-input-15-c01ac3f50fdc> in <module>()\r\n",
        "----> 1 print(z)\r\n",
        "\r\n",
        "NameError: name 'z' is not defined\r\n",
        "\r\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GBllLJOCFdLV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37bf6263-8611-4a89-ab81-c9f391ebd240"
      },
      "source": [
        "try:\r\n",
        "  print(z)\r\n",
        "except:\r\n",
        "  print(\"An exception occurred\")"
      ],
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "An exception occurred\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p9lPux5EIiZ6",
        "outputId": "e17eda03-fb98-41fd-824a-5d30f20fceba"
      },
      "source": [
        "# Print one message if the try block raises\r\n",
        "# a NameError and another for other errors\r\n",
        "\r\n",
        "try:\r\n",
        "  print(z)\r\n",
        "except NameError:\r\n",
        "  print(\"Variable z is not defined\")\r\n",
        "except:\r\n",
        "  print(\"Something else went wrong\")"
      ],
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Variable z is not defined\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GQqndyjnI_Em",
        "outputId": "b16a49d0-e577-476c-9f97-ab646b6ed4a7"
      },
      "source": [
        "#The try block does not raise any errors, so the else block is executed:\r\n",
        "\r\n",
        "try:\r\n",
        "  print(\"Hello\")\r\n",
        "except:\r\n",
        "  print(\"Something went wrong\")\r\n",
        "else:\r\n",
        "  print(\"Nothing went wrong\")"
      ],
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello\n",
            "Nothing went wrong\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P2ncE9FuJOTw",
        "outputId": "1e3a425b-3c3d-4b1c-e4ef-e0a6ddb877f8"
      },
      "source": [
        "try:\r\n",
        "  print(z)\r\n",
        "except:\r\n",
        "  print(\"Something went wrong\")\r\n",
        "else:\r\n",
        "  print(\"Nothing went wrong\")"
      ],
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Something went wrong\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AYDuJbDbJHKJ",
        "outputId": "9edc0ce6-6ff7-468d-a97d-b2f071864afb"
      },
      "source": [
        "#The finally block gets executed no matter if the try block raises any errors or not:\r\n",
        "\r\n",
        "try:\r\n",
        "  print(x)\r\n",
        "except:\r\n",
        "  print(\"Something went wrong\")\r\n",
        "finally:\r\n",
        "  print(\"The 'try except' is finished\")"
      ],
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<_sre.SRE_Match object; span=(12, 17), match='Spain'>\n",
            "The 'try except' is finished\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3USgZuWuKHln"
      },
      "source": [
        "```python\r\n",
        "#The try block will raise an error when trying to write to a read-only file:\r\n",
        "\r\n",
        "try:\r\n",
        "  f = open(\"demofile.txt\")\r\n",
        "  f.write(\"Lorum Ipsum\")\r\n",
        "except:\r\n",
        "  print(\"Something went wrong when writing to the file\")\r\n",
        "finally:\r\n",
        "  f.close()\r\n",
        "\r\n",
        "#The program can continue, without leaving the file object open\r\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XieBvkW_Kelr"
      },
      "source": [
        "```python \r\n",
        "'''As a Python developer you can choose to\r\n",
        "throw an exception if a condition occurs.\r\n",
        "\r\n",
        "To throw (or raise) an exception, use the\r\n",
        "raise keyword.\r\n",
        "'''\r\n",
        "\r\n",
        "x = -1\r\n",
        "\r\n",
        "if x < 0:\r\n",
        "  raise Exception(\"Sorry, no numbers below zero\")\r\n",
        "\r\n",
        "---------------------------------------------------------------------------\r\n",
        "Exception                                 Traceback (most recent call last)\r\n",
        "<ipython-input-25-2edc57024fbc> in <module>()\r\n",
        "      2 \r\n",
        "      3 if x < 0:\r\n",
        "----> 4   raise Exception(\"Sorry, no numbers below zero\")\r\n",
        "\r\n",
        "Exception: Sorry, no numbers below zero\r\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5mxzlo_cK_ku"
      },
      "source": [
        "```python\r\n",
        "x = \"hello\"\r\n",
        "\r\n",
        "if not type(x) is int:\r\n",
        "  raise TypeError(\"Only integers are allowed\")\r\n",
        "\r\n",
        "-------------------------------------\r\n",
        "File \"<ipython-input-26-762250dd0e82>\", line 4\r\n",
        "    raise TypeError(\"Only integers are allowed\"\r\n",
        "                                               ^\r\n",
        "SyntaxError: unexpected EOF while parsing\r\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TrOaLAroLXFd"
      },
      "source": [
        "## __User Input__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NPuF7fHgLWtr",
        "outputId": "23b926ad-56ce-4cee-a557-1b3a2486ccd8"
      },
      "source": [
        "username = input(\"Enter username:\")\r\n",
        "print(\"Username is: \" + username)"
      ],
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter username:faizy\n",
            "Username is: faizy\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OAOVtDT9Lkr2"
      },
      "source": [
        "## __Python String Formatting__"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n4rynjCmLqFD",
        "outputId": "799f6dd5-f151-4530-d8e6-28ee46602ec3"
      },
      "source": [
        "price = 49\r\n",
        "txt = \"The price is {} dollars\"\r\n",
        "print(txt.format(price))"
      ],
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The price is 49 dollars\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BjurP_I8Luxg",
        "outputId": "1f0b18ea-2300-4db2-d2af-82dd9300f420"
      },
      "source": [
        "price = 49\r\n",
        "txt = \"The price is {:.2f} dollars\"\r\n",
        "print(txt.format(price))"
      ],
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The price is 49.00 dollars\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XJPMc9mUL8Jq",
        "outputId": "8c58aa2a-395a-4c43-cf8f-27ada2135646"
      },
      "source": [
        "quantity = 3\r\n",
        "itemno = 567\r\n",
        "price = 49\r\n",
        "myorder = \"I want {} pieces of item number {} for {:.2f} dollars.\"\r\n",
        "print(myorder.format(quantity, itemno, price))"
      ],
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I want 3 pieces of item number 567 for 49.00 dollars.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-ZlaLVMqMFSQ",
        "outputId": "40be3b65-6c55-4321-a60c-5246787de274"
      },
      "source": [
        "quantity = 3\r\n",
        "itemno = 567\r\n",
        "price = 49\r\n",
        "myorder = \"I want {0} pieces of item number {1} for {2:.2f} dollars.\"\r\n",
        "print(myorder.format(quantity, itemno, price))"
      ],
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I want 3 pieces of item number 567 for 49.00 dollars.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k20sPkT2MY70",
        "outputId": "56db8811-2655-4036-bf55-9001dde156ad"
      },
      "source": [
        "age = 36\r\n",
        "name = \"John\"\r\n",
        "txt = \"His name is {1}. {1} is {0} years old.\"\r\n",
        "print(txt.format(age, name))"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "His name is John. John is 36 years old.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vvLwOMFoMls8",
        "outputId": "573386b4-8730-44c1-a355-f6c6b8067aa8"
      },
      "source": [
        "age = 36\r\n",
        "name = \"John\"\r\n",
        "txt = \"His name is {1}. {1} is {0} years old.\"\r\n",
        "print(txt.format(age, name))"
      ],
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "His name is John. John is 36 years old.\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}