Python_Intermediate.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python_Intermediate.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNTDUmssU8uB32EhHac4QN8",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Benjamindavid03/python_exercises/blob/main/Python_Intermediate.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VW4Vhn9Ein_Y"
      },
      "source": [
        "# Functions in Python contd.\n",
        "## Default Parameter value\n",
        "If we call a function without giving any argument value, then the default value will be used."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iVVbDgOShy9Y"
      },
      "source": [
        "def eat(fruit = \"grapes\"):\n",
        "  print(\"I want to eat\", fruit);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-_nOAQB0iFsS",
        "outputId": "0b97b738-8f26-4bc9-caad-7a473254259d"
      },
      "source": [
        "# error will not be thrown\n",
        "eat(\"mango\"); # fruit is passed\n",
        "#error will be thrown\n",
        "eat(); # error will be thrown if not given default value\n",
        "#eat(input(\"Enter the fruit name\"));"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "I want to eat mango\n",
            "I want to eat grapes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tSqmvdbgkkR6"
      },
      "source": [
        "## Pass statement\n",
        "If we want to have certain functions,<br/>\n",
        "But, we don't want to give empty functions as they will throw an error. <br/>\n",
        "<br/>\n",
        "<u>We can give a function definition without any content using the pass statement within the function.</u>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pXsPqIf9ictZ"
      },
      "source": [
        "def calculateGrade():\n",
        "  pass;\n",
        "\n",
        "def calculateAge():\n",
        "  pass;"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TrOTIZhtke3O"
      },
      "source": [
        "calculateAge();"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r30nsxB2lNeW"
      },
      "source": [
        "## Recursion\n",
        "\n",
        "A function that needs to be called again and again by the same function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CpxL3FkmlaWD"
      },
      "source": [
        "# we need to call count inside of the count\n",
        "def count(k): \n",
        "  if(k>0): #check if k is greater than 0\n",
        "    sum = k + count(k-1);  # sum = k + call the function again with param {k-1}\n",
        "    # count is a recursive function\n",
        "    print(\"k=\",k);\n",
        "    print(\"sum=\",sum);\n",
        "  else:\n",
        "    sum=0;\n",
        "  return sum;\n",
        "\n",
        "v = int(input(\"Enter number :\"));\n",
        "sum = count(v);\n",
        "print(\"The total sum is \",sum);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZuBBFLgpwMBW"
      },
      "source": [
        "## Lambda Functions\n",
        "A lambda function is a small function that is anonymous and can be simple<br/>\n",
        "<b>SYNTAX  :</b>\n",
        "<code>\n",
        " fun = lambda arguments : expression\n",
        "</code>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g61t_oVAwX9G"
      },
      "source": [
        "# ordinary functions\n",
        "def x1(q):\n",
        "  return q*q;\n",
        "\n",
        "def sum1(a,b):\n",
        "  return a+b;"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hegNRIFMyVI4"
      },
      "source": [
        "#lambda functions\n",
        "x2 = lambda q : q*q;\n",
        "sum2 = lambda a,b : a+b;\n",
        "print(x1(3))     #calling function\n",
        "print(x2(3))     #calling lambda function\n",
        "print(sum1(3,2)) #calling function\n",
        "print(sum2(3,1)) #calling lambda function"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Sq3UniGvyYg-",
        "outputId": "5d01b611-6d12-49e4-b091-a10943c01875"
      },
      "source": [
        "area_rect = lambda l,b : l*b;\n",
        "area_square = lambda s : s*s;\n",
        "\n",
        "print(\"Area of rectangle \", area_rect(3,2));\n",
        "print(\"Area of square \", area_square(10));"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Area of rectangle  6\n",
            "Area of square  100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j2IjnTSnIz5-"
      },
      "source": [
        "# Object Oriented Programming\n",
        "1. Everything around us can be modelled and programmed using OOP\n",
        "2. Every object has a set of properties and methods\n",
        "\n",
        "We create a template for object and then use those for our program"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T8sz467hKIBX"
      },
      "source": [
        "## Class\n",
        "A class is like a template for an object. In other words, a class is a \"blueprint\" for creating an object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MOKmzubEI7hl",
        "outputId": "ffcbc2b8-bbdc-4f10-bdb8-137a148b5ccc"
      },
      "source": [
        "#creating a class for Human\n",
        "class Human:\n",
        "  height=5;  #property 1\n",
        "  weight=56; #property 2\n",
        "  name=\"No name\"; # property 3\n",
        "\n",
        "  #constructor - a method that is called when the \n",
        "  #              instance of the object is created\n",
        "  def __init__(self):\n",
        "    print(\"Constructor called\"); #a constructor will be called when an instance\n",
        "                                 #of the object is created\n",
        "\n",
        "  #ShowDetail - a method called to print all the details of the object\n",
        "  def ShowDetail(self): #self refers to the instance of the called object\n",
        "    print(\"The Details are:\");\n",
        "    print(\"Name :\",self.name);\n",
        "    print(\"Weight :\",self.weight);\n",
        "    print(\"Height :\",self.height);\n",
        "\n",
        "print(Human);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class '__main__.Human'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qSj-Q2X8RXir"
      },
      "source": [
        "### Creating the Objects and assigning the values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Aislo3EOKnbK",
        "outputId": "5c1b5473-b5d8-4b91-91b3-614803e40cb8"
      },
      "source": [
        "#creating a student object of type Human\n",
        "student = Human();\n",
        "student.height=6.5;\n",
        "student.weight=54;\n",
        "student.name=\"Kumar\";\n",
        "\n",
        "#creating a teacher object of type Human\n",
        "teacher = Human();\n",
        "teacher.height=5.98;\n",
        "teacher.weight=67;\n",
        "teacher.name=\"John\";"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Constructor called\n",
            "Constructor called\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bjWCy14HRm3u"
      },
      "source": [
        "### Access the properties of the class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WO4-uwAGL134",
        "outputId": "1fb4d394-be0d-4b9e-963e-4a8b09a997b4"
      },
      "source": [
        "# Type 1  : Access the properties using . operator\n",
        "#print the student details\n",
        "print(\"The student Details are:\");\n",
        "print(\"Name :\",student.name);\n",
        "print(\"Weight :\",student.weight);\n",
        "print(\"Height :\",student.height);\n",
        "\n",
        "#print the teacher details\n",
        "print(\"The Teacher Details are:\");\n",
        "print(\"Name :\",teacher.name);\n",
        "print(\"Weight :\",teacher.weight);\n",
        "print(\"Height :\",teacher.height);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The student Details are:\n",
            "Name : Kumar\n",
            "Weight : 54\n",
            "Height : 6.5\n",
            "The Teacher Details are:\n",
            "Name : John\n",
            "Weight : 67\n",
            "Height : 5.98\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RYjbmpBNRvpe"
      },
      "source": [
        "### Calling the method ShowDetail from the Human class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Vlv42y3Pgjj",
        "outputId": "763a1378-173a-46bf-c113-33379e6e397a"
      },
      "source": [
        "# Type 2: call the method defined inside the class using . operator\n",
        "# Easily, you can just call ShowDetail() from the object\n",
        "teacher.ShowDetail(); #calling the method defined in Human\n",
        "student.ShowDetail(); #calling the method defined in Human"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The Details are:\n",
            "Name : John\n",
            "Weight : 67\n",
            "Height : 5.98\n",
            "The Details are:\n",
            "Name : Kumar\n",
            "Weight : 54\n",
            "Height : 6.5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VZhwsK64RAM6",
        "outputId": "ce763610-698e-4f4c-8eff-8464b0f431f1"
      },
      "source": [
        "#creating a new object parent\n",
        "parent = Human();\n",
        "parent.name=\"Kumar\"; #change the name of Human object to Kumar\n",
        "parent.ShowDetail();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Constructor called\n",
            "The Details are:\n",
            "Name : Kumar\n",
            "Weight : 56\n",
            "Height : 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mNZUCSIGf0Fo"
      },
      "source": [
        "# An Example for OOP using Complex numbers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0zdhnYMFgel0"
      },
      "source": [
        "# complex number class\n",
        "class Complex:  \n",
        "  #constructor with two argument : 1 = >real, 2 => img\n",
        "  def __init__(self, r=0, i=0):\n",
        "    self.real = r;  # accessing the property of instance and set the real prop \n",
        "    self.img = i;   #  accessing the property of instance and set the img prop\n",
        "    # To automatcally call display when an object is created.\n",
        "    self.display(); # accessing the method of instance and call display\n",
        "  #method to display the complex number\n",
        "  def display(self):\n",
        "    print(str(self.real)+\"+\"+str(self.img)+\"i\");\n",
        "\n",
        "  # method to add complex number with this object\n",
        "  def add(self, c):\n",
        "    self.real = self.real+c.real;\n",
        "    self.img = self.img+c.img;    \n",
        "    return self;\n",
        "\n",
        "  # method to subtract complex number with this object\n",
        "  def sub(self, c):\n",
        "    self.real = self.real-c.real;\n",
        "    self.img = self.img-c.img;    \n",
        "    return self;\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vgz5D2L_iIFO",
        "outputId": "955e4dd8-0039-4ef2-9977-0f0d60a67959"
      },
      "source": [
        "# we are using the class to create complex number objects\n",
        "print(\"C1 object is created\");\n",
        "c1 = Complex();\n",
        "print(\"C1 object is created with real and complex assigned\");\n",
        "c1 = Complex(3,2); # this line automatically calls __init__ on c1\n",
        "print(\"C2 object is created with real and complex assigned\");\n",
        "c2 = Complex(16,4); # this line automatically calls __init__ on c1\n",
        "#c1.display(); # calling the display method of c1\n",
        "#c2.display(); # calling the display method of c2\n",
        "\n",
        "# creating complex numbe object with no arguments\n",
        "c3 = Complex();\n",
        "# calling the add method of c1 and pass c2\n",
        "c3 = c1.add(c2);\n",
        "# print the complex number c3\n",
        "c3.display();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0+0i\n",
            "3+2i\n",
            "16+4i\n",
            "0+0i\n",
            "19+6i\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9wknm4Dcs0VM"
      },
      "source": [
        "# An Example for OOP using Mobile - Real object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0t96yVldm8VK"
      },
      "source": [
        "# class Mobile\n",
        "class Mobile: \n",
        "\n",
        "  #properties\n",
        "  #======================\n",
        "  os = \"Android Nogut\";\n",
        "  ram = 8;\n",
        "  rom = 32;\n",
        "  battery = 4200;\n",
        "  color = \"Black\";\n",
        "  #=======================\n",
        "\n",
        "  #methods\n",
        "  #===================================\n",
        "  #constructor = called automatically when objects of this class are created\n",
        "  def __init__(self,p_make, p_model):\n",
        "    self.make = p_make;  \n",
        "    self.model = p_model;\n",
        "    print(\"Mobile device created : \");\n",
        "    print(\"Make : \", self.make);\n",
        "    print(\"Model : \", self.model);\n",
        "\n",
        "  def PlayMusic(self, song):\n",
        "    print(\"The mobile is playing the song : \", song);\n",
        "\n",
        "  def WatchVideo(self):\n",
        "    print(\"The mobile is being used to watch video\");\n",
        "\n",
        "  def PlayGame(self):\n",
        "    print(\"The mobile is being used to play games\");\n",
        "\n",
        "  def Call(self, person):\n",
        "    print(\"Calling .... \", person);\n",
        "\n",
        "  def Text(self, person):\n",
        "    print(\"Texting.... \", person);\n",
        "\n",
        "  def display(self):\n",
        "    print(\"Mobile Details\");\n",
        "    print(\"  Make : \", self.make);\n",
        "    print(\"  Model : \", self.model);    \n",
        "    print(\"  Operating System : \", self.os);\n",
        "    print(\"  RAM Memory : \" + str(self.ram) + \" GB\");\n",
        "    print(\"  ROM Storage : \" + str(self.rom) + \" GB\");    \n",
        "    print(\"  Battery : \" + str(self.battery) + \" mAh\");    \n",
        "    print(\"  Colour : \", self.color);\n",
        "  #===================================    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WRKsEXtrotCG",
        "outputId": "8c1a8f58-9fcc-4b15-c55e-7a9d1d25be18"
      },
      "source": [
        "a = Mobile(\"Samsung\", \"F41\");\n",
        "a.Call(\"Manikandan\");\n",
        "a.Text(\"Sam\");\n",
        "a.WatchVideo();\n",
        "a.PlayMusic(\"Christmas Song\");\n",
        "a.PlayGame();\n",
        "a.display();\n",
        "a.os = \" Androiod Q\";\n",
        "a.display();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mobile device created : \n",
            "Make :  Samsung\n",
            "Model :  F41\n",
            "Calling ....  Manikandan\n",
            "Texting....  Sam\n",
            "The mobile is being used to watch video\n",
            "The mobile is playing the song :  Christmas Song\n",
            "The mobile is being used to play games\n",
            "Mobile Details\n",
            "  Make :  Samsung\n",
            "  Model :  F41\n",
            "  Operating System :  Android Nogut\n",
            "  RAM Memory : 8 GB\n",
            "  ROM Storage : 32 GB\n",
            "  Battery : 4200 mAh\n",
            "  Colour :  Black\n",
            "Mobile Details\n",
            "  Make :  Samsung\n",
            "  Model :  F41\n",
            "  Operating System :   Androiod Q\n",
            "  RAM Memory : 8 GB\n",
            "  ROM Storage : 32 GB\n",
            "  Battery : 4200 mAh\n",
            "  Colour :  Black\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S8QZAAJgwisB"
      },
      "source": [
        "# sum of numbers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lzo26k3lwl3y"
      },
      "source": [
        "class SumofNumber:\n",
        "  sum=0;\n",
        "  list2=[];\n",
        "\n",
        "  def getInput(self):\n",
        "    var1 = int(input(\"Enter the starting number\"));\n",
        "    var2 = int(input(\"Enter the end number\"));\n",
        "    self.list2 = range(var1,var2);\n",
        "\n",
        "  def show(self):\n",
        "    print(\"The size of the list : \", len(self.list2));\n",
        "\n",
        "  def display(self):\n",
        "    print(\"The given elements are :\")\n",
        "    for x in self.list2:\n",
        "      print(x);\n",
        "\n",
        "  def calculate(self):\n",
        "    print(\"Calculation step :\")\n",
        "    for x in self.list2:\n",
        "      self.sum=self.sum+x;\n",
        "\n",
        "  def result(self):\n",
        "    print(\"Result : \")\n",
        "    print(\"Finally, the sum of numbers \",self.sum);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GOkn9tjzxNSv",
        "outputId": "8bc933ab-defb-4a1f-8a37-8416daf71a21"
      },
      "source": [
        "s = SumofNumber();\n",
        "s.getInput();\n",
        "s.calculate();\n",
        "s.display();\n",
        "s.result();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the starting number2\n",
            "Enter the end number10\n",
            "Calculation step :\n",
            "The given elements are :\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "Result : \n",
            "Finally, the sum of numbers  44\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ctZAoFbDs1e"
      },
      "source": [
        "# Inheritance\n",
        "It allows us to define a class (child class) that can inherit or get all the method and properties from another class (parent class)\n",
        "\n",
        "* Parent class - class that hold the properties and methods \n",
        "\n",
        "* Child class - on inherting the parent class, all the properties and methods of the parent class can be accessed through the child class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SPTENYLkDxh1"
      },
      "source": [
        "# parent class - A. { Has properties => x and y}\n",
        "class A:\n",
        "  x=10;\n",
        "  y=25.5;\n",
        "\n",
        "#child class - B {Has properties => z}\n",
        "# as this is a child class of A class, all the methods and properties of A will \n",
        "# be passed to this child class\n",
        "class B(A):\n",
        "  z=\"Hi\";\n",
        "\n",
        "class C(A):\n",
        "  pass; # it is a keyword that is used to specify that we don't want to give any\n",
        "  # additional properties or methods to the child class"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "evnJCoqBEXt3"
      },
      "source": [
        "b1=B(); # create an object for class B\n",
        "print(b1.z); # print the prop from child class\n",
        "print(b1.x); # print the prop from parent class\n",
        "print(b1.y); # print the prop from parent class\n",
        "\n",
        "c1 = C();\n",
        "print(c1.x); # print the prop from parent class\n",
        "print(c1.y); # print the prop from parent class"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1x0IxUYMUdwM"
      },
      "source": [
        "## Animal class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pVNR3a9gH9Ki"
      },
      "source": [
        "# method overriding - giving different definitions to the functions that work \n",
        "# differently than those defined in the parent class\n",
        "class Animal:\n",
        "  name = \"Animal\";\n",
        "  # constructor - a method that gets called automatically when objects are created\n",
        "  def __init__(self):\n",
        "    print(\"Animal created\");\n",
        "\n",
        "  def makeSound(self):\n",
        "    print(self.name + \" : Makes a sound\");\n",
        "\n",
        "class Dog(Animal):\n",
        "  name = \"Dog\";\n",
        "  def __init__(self,name):\n",
        "    self.name = name;\n",
        "    print(\"Dog created\");  \n",
        "  def makeSound(self): # override the makeSound() of Animal\n",
        "    print(self.name + \" : Bow Bow!!!\");\n",
        "\n",
        "class Cat(Animal):\n",
        "  name = \"Cat\";\n",
        "  def __init__(self,name):\n",
        "    self.name = name;\n",
        "    print(\"Cat created\");\n",
        "    Animal.__init__(self); # calls the parent class's constructor    \n",
        "  def makeSound(self): # override the makeSound() of Animal\n",
        "    print(self.name + \" : Meow Meow!!!\");    \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_1W2fqbDIxxs",
        "outputId": "8e5c315f-6343-42c3-b0ac-e6ffc4f9a4f6"
      },
      "source": [
        "#create a parent class object a\n",
        "a = Animal();\n",
        "a.makeSound();\n",
        "#create a child class object j\n",
        "j = Dog(\"Jimmy\"); # passing name as constructor argument\n",
        "j.makeSound();\n",
        "j1 = Dog(\"Rex\");\n",
        "j1.makeSound();\n",
        "#create a child class object c\n",
        "c = Cat(\"Blacky\");\n",
        "c.makeSound();\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Animal created\n",
            "Animal : Makes a sound\n",
            "Dog created\n",
            "Jimmy : Bow Bow!!!\n",
            "Dog created\n",
            "Rex : Bow Bow!!!\n",
            "Cat created\n",
            "Animal created\n",
            "Blacky : Meow Meow!!!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cqS1IxrQKd6-"
      },
      "source": [
        "class Spare:\n",
        "  height = 4.1;\n",
        "  length = 6.2;\n",
        "  width = 2.4;\n",
        "\n",
        "class Bolt(Spare):\n",
        "  breadth = 3.4;\n",
        "\n",
        "bz = Bolt();"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gmnc8b8_Mm0c"
      },
      "source": [
        "class AdvancedDog(Dog):\n",
        "  weight=4;\n",
        "  height=2;\n",
        "  age=8;\n",
        "  name = \"Advanced Dog\";\n",
        "  def wagTail(self): # adding new methods to this class\n",
        "    print(self.name + \" : Wagging Tail....\");    \n",
        "  def eat(self,food): # adding new methods to this class\n",
        "    print(self.name + \" : Eating ... \" + food);\n",
        "  def walk(self): # adding new methods to this class\n",
        "    print(self.name + \": Walking .... \");    \n",
        "  def follow(self,target): # adding new methods to this class\n",
        "    print(self.name + \": Following =>\", target);        "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mvszg1HUPJOR",
        "outputId": "ee527da4-73ca-41d3-d95b-b2c8f553246d"
      },
      "source": [
        "a = AdvancedDog(\"Some dog\");\n",
        "a.makeSound();\n",
        "a.eat(\"Chicken Biriyani\");\n",
        "a.wagTail();\n",
        "a.follow(\"Manikandan\");\n",
        "a.walk();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dog created\n",
            "Some dog : Bow Bow!!!\n",
            "Some dog : Eating ... Chicken Biriyani\n",
            "Some dog : Wagging Tail....\n",
            "Some dog: Following => Manikandan\n",
            "Some dog: Walking .... \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8qb3H_DXTSTx"
      },
      "source": [
        "del a.name; # delete a property in a\n",
        "a.eat(\"Chicken Biriyani\");\n",
        "a.wagTail();\n",
        "a.follow(\"Manikandan\");\n",
        "a.walk();\n",
        "print(a.name);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iGAqM6HLUVB8"
      },
      "source": [
        "del a; # delete a class object"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uBGwTUqVUV3O"
      },
      "source": [
        "print(a.name);"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LqDpMm9VaV1t"
      },
      "source": [
        "## super() function\n",
        "This can be used to call or access the methods and properties of the parent class from the child class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vva79jA7Vw8L",
        "outputId": "c5e67bd0-c9e7-4ed9-ddb6-bdd625d4f50a"
      },
      "source": [
        "class Object:\n",
        "  def __init__(self):\n",
        "    print(\"Object created\");\n",
        "  def __init__(self,n):\n",
        "    print(\"Object created  : \" + n);\n",
        "    self.fullname=n;\n",
        "  def samp(self):\n",
        "    print(\"Sample\");\n",
        "\n",
        "class Object1(Object):\n",
        "  def __init__(self,n,a):\n",
        "    super().__init__(n); # calls the parent class' constructor from Object\n",
        "    self.age = a;\n",
        "  def show(self):\n",
        "    print(\"Name : \", self.fullname);\n",
        "    print(\"Age  : \", self.age);\n",
        "    super().samp(); # calls the samp method from Object\n",
        "\n",
        "o = Object(\"Mani\");\n",
        "print(o.fullname);\n",
        "\n",
        "o1 = Object1(\"Mani\",28);\n",
        "o1.show();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Object created  : Mani\n",
            "Mani\n",
            "Object created  : Mani\n",
            "Name :  Mani\n",
            "Age  :  28\n",
            "Sample\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iJWDtEbArMFv",
        "outputId": "39b8436e-8701-4594-d388-04325e88971c"
      },
      "source": [
        "## Error debugging\n",
        "class profile:\n",
        "  def __init__(self,name):\n",
        "    print(\"OBJECT: \"+name);\n",
        "    self.fullname=name;\n",
        "  def approve(self):\n",
        "    print(\"approved\");\n",
        "\n",
        "class profile_age(profile):\n",
        "  def __init__(self,name,age):\n",
        "    super().__init__(name);\n",
        "    self.name=name;\n",
        "    self.age = age;\n",
        "  def show(self):\n",
        "    print(\"Profile: \",self.name);\n",
        "    print(\"age: \",self.age);\n",
        "    super().approve();\n",
        "\n",
        "A = profile(\"MANIKANDAN\");\n",
        "print(A.fullname);\n",
        "A = profile_age(\"MANIKANDAN\" , 25);\n",
        "A.show();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OBJECT: MANIKANDAN\n",
            "MANIKANDAN\n",
            "OBJECT: MANIKANDAN\n",
            "Profile:  MANIKANDAN\n",
            "age:  25\n",
            "approved\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "txmTCMJDuEKu"
      },
      "source": [
        "# Python Iterators\n",
        "An iterator is an object  that is used for going through all the items in an list.\n",
        "<br/>\n",
        "Note : An iterator can be created for iteratable objects such as Lists, Tuples, Dictionaries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_1is5bY3ukOb",
        "outputId": "a1950fa1-b7c3-4931-da7c-b1b3deeaa190"
      },
      "source": [
        "t = (\"apple\", \"orange\", \"banana\", \"mango\") #creating tuple\n",
        "it = iter(t); #create iterator for the tuple\n",
        "print(it) # show the type of t\n",
        "print(next(it)); # call next on iterator object\n",
        "print(next(it));\n",
        "print(next(it));\n",
        "print(next(it));\n",
        "# print(next(it)); -- This will throw an error - printed all the elements in iter"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<tuple_iterator object at 0x7f3eba60bc10>\n",
            "apple\n",
            "orange\n",
            "banana\n",
            "mango\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uIZYfMp1uyjw",
        "outputId": "cc2872af-3216-4592-a317-14ba958fe97c"
      },
      "source": [
        "it = iter(\"banana\");\n",
        "print(next(it));\n",
        "print(next(it));\n",
        "print(next(it));\n",
        "str1 = \"banana\";\n",
        "print(\"\\n\");\n",
        "for q in str1:\n",
        "  print(\"\\t\"+q);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "b\n",
            "a\n",
            "n\n",
            "\n",
            "\n",
            "\tb\n",
            "\ta\n",
            "\tn\n",
            "\ta\n",
            "\tn\n",
            "\ta\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yb6DH7aZwK1N",
        "outputId": "bc82f5db-7d94-4c62-8565-5b4fafc7f71c"
      },
      "source": [
        "# without using iterators\n",
        "t1 = (\"apple\", \"orange\", \"banana\", \"mango\") #creating tuple\n",
        "\n",
        "for f in t1:\n",
        "  print(f);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "apple\n",
            "orange\n",
            "banana\n",
            "mango\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CwIaTdVPxmIK"
      },
      "source": [
        "# Scope"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "En1PxGiow9rq",
        "outputId": "d171109c-7163-4070-a1e4-4a432bc93908"
      },
      "source": [
        "def fun1():\n",
        "  x=10;\n",
        "  print(x);\n",
        "\n",
        "fun1();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TML_M1Q5xy_8",
        "outputId": "ed85b855-183c-487a-f792-0f67d071169d"
      },
      "source": [
        "def fun2():\n",
        "  x=10; # fun_x can access this x\n",
        "  def fun_x():\n",
        "    print(x);\n",
        "  fun_x();       \n",
        "  \n",
        "\n",
        "fun2();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p_oGgaFxyJyu",
        "outputId": "8d9e9b7a-0473-433b-9127-9563d0f0126b"
      },
      "source": [
        "def fun3():\n",
        "  global b; # b is a global variable that can be used anywhere\n",
        "  b=10; # fun_x can access this x\n",
        "  def fun_x():\n",
        "    print(b);\n",
        "  fun_x();       \n",
        "  \n",
        "\n",
        "fun3();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WUxyE49Wyabl",
        "outputId": "9cac5a72-d088-41d1-c702-fa726d5a12f6"
      },
      "source": [
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sjvMYYzemVVE"
      },
      "source": [
        "# Modules\n",
        "## DateTime"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1IsNIqc3loEr"
      },
      "source": [
        "# import a module\n",
        "import datetime;\n",
        "\n",
        "x = datetime.datetime.now();\n",
        "print(\"Now :\", x);\n",
        "\n",
        "print(\"Date :\", x.day);\n",
        "print(\"Month :\", x.month);\n",
        "print(\"Year :\", x.year);\n",
        "print(\"Hour :\", x.hour);\n",
        "print(\"Minute :\", x.minute);\n",
        "print(\"Second :\", x.second);\n",
        "print(x.strftime(\"%p\"));\n",
        "print(\"Day :\", x.strftime(\"%A\")); # day\n",
        "print(\"Month :\", x.strftime(\"%B\")); # month\n",
        "\n",
        "x = datetime.datetime(2021,9,1,3,5,28);\n",
        "print(\"Date chosen :\", x);\n",
        "\n",
        "print(\"Date :\", x.day);\n",
        "print(\"Month :\", x.month);\n",
        "print(\"Year :\", x.year);\n",
        "print(\"Hour :\", x.hour);\n",
        "print(\"Minute :\", x.minute);\n",
        "print(\"Second :\", x.second);\n",
        "print(x.strftime(\"%p\"));\n",
        "print(\"Day :\", x.strftime(\"%A\")); # day\n",
        "print(\"Month :\", x.strftime(\"%B\")); # month\n",
        "\n",
        "#view inside the datetime module\n",
        "#print(\"Inside datetime :\");\n",
        "#print(dir(datetime));\n",
        "\n",
        "#print(\"Inside datetime.datetime :\");\n",
        "#view datetime class inside of the datetime module\n",
        "#print(dir(datetime.datetime));\n",
        "\n",
        "\n",
        "print(\"Date Checking Program\");\n",
        "print(\"************************\");\n",
        "dd = int(input(\"Enter date :\"));\n",
        "mm = int(input(\"Enter month :\"));\n",
        "yyyy = int(input(\"Enter year :\"));\n",
        "h = int(input(\"Enter Hour :\"));\n",
        "m = int(input(\"Enter Minute :\"));\n",
        "s = int(input(\"Enter Second :\"));\n",
        "x = datetime.datetime(yyyy,mm,dd,h,m,s);\n",
        "print(\"Date given :\", x);\n",
        "\n",
        "print(\"Date :\", x.day);\n",
        "print(\"Month :\", x.month);\n",
        "print(\"Year :\", x.year);\n",
        "print(\"Hour :\", x.hour);\n",
        "print(\"Minute :\", x.minute);\n",
        "print(\"Second :\", x.second);\n",
        "print(x.strftime(\"%p\"));\n",
        "print(\"Day :\", x.strftime(\"%A\"));\n",
        "print(\"Month :\", x.strftime(\"%B\"));\n",
        "20"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ncQ58ACHmczv"
      },
      "source": [
        "## Maths"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5xVsXT3Hma60",
        "outputId": "e87bb551-0f35-4aed-9ca9-ec26ce7e8787"
      },
      "source": [
        "import math;\n",
        "\n",
        "list1 = [5,10,12,15];\n",
        "\n",
        "x = max(list1);\n",
        "print(x)\n",
        "\n",
        "x = min(list1);\n",
        "print(x);\n",
        "\n",
        "x = abs(-6.876);\n",
        "print(x);\n",
        "\n",
        "x = pow(2,3); # equivalant to print(2**3);\n",
        "print(x);\n",
        "\n",
        "x = math.sqrt(64);\n",
        "print(x);\n",
        "\n",
        "x = math.ceil(6.876);\n",
        "print(x);\n",
        "\n",
        "x = math.ceil(-6.876);\n",
        "print(x);\n",
        "\n",
        "x = math.floor(-6.876);\n",
        "print(x);\n",
        "\n",
        "x = math.floor(6.876);\n",
        "print(x);\n",
        "\n",
        "x = math.degrees(4);\n",
        "print(x);\n",
        "\n",
        "x = math.radians(60);\n",
        "print(x);\n",
        "\n",
        "x = math.log2(10);\n",
        "print(x);\n",
        "\n",
        "x = math.sin(90);\n",
        "print(x);\n",
        "\n",
        "#tan\n",
        "x = math.tan(6.876);\n",
        "print(x);\n",
        "\n",
        "#arc tan\n",
        "x = math.atan(6.876);\n",
        "print(x);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n",
            "5\n",
            "6.876\n",
            "8\n",
            "8.0\n",
            "7\n",
            "-6\n",
            "-7\n",
            "6\n",
            "229.1831180523293\n",
            "1.0471975511965976\n",
            "3.321928094887362\n",
            "0.8939966636005579\n",
            "0.6736398866121137\n",
            "1.4263754641486666\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h6BkMKpHqRWt"
      },
      "source": [
        "## JSON Handling - Javascript Object Notation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YEOZPVSeqXKr",
        "outputId": "9db218b5-9182-4a8f-c8dc-18efbcb8f7ef"
      },
      "source": [
        "# conversion from a json string to dictionary in python\n",
        "import json;\n",
        "x = '{\"name\": \"Manikandan\",\"age\": 19,\"course\":\"python\",\"city\":\"Tuticorin\"}'\n",
        "print(x);\n",
        "print(type(x));\n",
        "data = json.loads(x);\n",
        "print(data);\n",
        "print(type(data));\n",
        "\n",
        "print(data[\"name\"]);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{\"name\": \"Manikandan\",\"age\": 19,\"course\":\"python\",\"city\":\"Tuticorin\"}\n",
            "<class 'str'>\n",
            "{'name': 'Manikandan', 'age': 19, 'course': 'python', 'city': 'Tuticorin'}\n",
            "<class 'dict'>\n",
            "Manikandan\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d1_BTtoYrapI",
        "outputId": "474f1a14-598c-486a-f7db-fe87d551514d"
      },
      "source": [
        "# conversion from a dictionary in python to json string\n",
        "student = {\n",
        "  \"name\": \"Manikandan\",\n",
        "  \"age\": 19,\n",
        "  \"course\":\"python\",\n",
        "  \"city\":\"Tuticorin\"\n",
        "}\n",
        "print(student);\n",
        "print(type(student));\n",
        "\n",
        "x = json.dumps(student);\n",
        "print(x);\n",
        "print(type(x));"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Manikandan', 'age': 19, 'course': 'python', 'city': 'Tuticorin'}\n",
            "<class 'dict'>\n",
            "{\"name\": \"Manikandan\", \"age\": 19, \"course\": \"python\", \"city\": \"Tuticorin\"}\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DvvUAGeZGPcB",
        "outputId": "f41dd185-6dcf-47a4-986b-3f442fe5ef06"
      },
      "source": [
        " import json\n",
        "\n",
        "x = {\n",
        "  \"name\": \"John\",\n",
        "  \"age\": 30,\n",
        "  \"married\": True,\n",
        "  \"divorced\": False,\n",
        "  \"children\": (\"Ann\",\"Billy\"),\n",
        "  \"pets\": None,\n",
        "  \"cars\": [\n",
        "    {\"model\": \"BMW 230\", \"mpg\": 27.5},\n",
        "    {\"model\": \"Ford Edge\", \"mpg\": 24.1}\n",
        "  ]\n",
        "}\n",
        "\n",
        "print(json.dumps(x))"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Ody2fXBszAi"
      },
      "source": [
        "# Exception Handling"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cB6w8pebs9-b",
        "outputId": "f3e3dbc3-7411-46aa-f8d3-14d48c5f921e"
      },
      "source": [
        "abc=100\n",
        "#print(pqr);\n",
        "print(\"Hello\");\n",
        "try:\n",
        "  print(\"Hello again\");\n",
        "  print(pqr);\n",
        "except:\n",
        "  print('The variable abc has not been initialized');\n",
        "print(\"Hello once again\");\n",
        "print(\"Hello once again and again\");"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello\n",
            "Hello again\n",
            "The variable abc has not been initialized\n",
            "Hello once again\n",
            "Hello once again and again\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YkR9yjHPv7gv",
        "outputId": "f3c8e38d-271f-4c13-b5cf-e7cdd0844c62"
      },
      "source": [
        "t=0;\n",
        "try:\n",
        "  a = int(input(\"Enter a :\"));\n",
        "  b = int(input(\"Enter b : \"));\n",
        "  t = a/b;\n",
        "except NameError:\n",
        "  print('variable name is not initialized');\n",
        "except ZeroDivisionError:\n",
        "  print('you cannot divide by zero');\n",
        "except:\n",
        "  print('An error occured. Please try again!');  \n",
        "finally:\n",
        "  print(\"The answer is \",t);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a :8\n",
            "Enter b : 5\n",
            "variable name is not initialized\n",
            "The answer is  0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QWFGyVGCz3Ih",
        "outputId": "1bd7ed6f-12a7-43f2-ade4-e10dd69e00b1"
      },
      "source": [
        "t=0;\n",
        "#a=\"Hello\";\n",
        "a=6;\n",
        "if not type(a) is int:\n",
        "  raise Exception(\"A is not a integer\");\n",
        "\n",
        "if a>100:\n",
        "  raise Exception(\"A value should be below 100. Run the program again\");\n",
        "\n",
        "try:\n",
        "  a = int(input(\"Enter a below 100 :\"));\n",
        "  if a>100:\n",
        "    raise Exception(\"A value should be below 100. Run the program again\");  \n",
        "  b = int(input(\"Enter b : \"));\n",
        "  t = a/b;\n",
        "except NameError:\n",
        "  print('variable name is not initialized');\n",
        "except ZeroDivisionError:\n",
        "  print('you cannot divide by zero');\n",
        "except:\n",
        "  print('An error occured. Please try again!');  \n",
        "finally:\n",
        "  print(\"The answer is \",t);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "An error occured. Please try again!\n",
            "The answer is  0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "otdj-IHFJ0il"
      },
      "source": [
        "# String formatting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2eT1ToPcJ31l",
        "outputId": "8254c5a8-8138-49a7-f2b6-acd7a89019f5"
      },
      "source": [
        "price = 15.6550;\n",
        "print(\"The cost of the product is {} Rupees\".format(price));\n",
        "print(\"The cost of the product is {:.2f} Rupees\".format(price));"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The cost of the product is 15.655 Rupees\n",
            "The cost of the product is 15.65 Rupees\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "flNpaBauJ_mi",
        "outputId": "71f4bbda-ee39-4dac-b46e-0d2f84d36064"
      },
      "source": [
        "product=\"Hamam soap\";\n",
        "print(\"The cost of the {} is {:.2f} Rupees\".format(product,price));"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The cost of the Hamam soap is 15.65 Rupees\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jkQ3HJDUK8YV",
        "outputId": "60bb8861-eea8-48cb-ac54-1f51413f61cd"
      },
      "source": [
        "product=input(\"Enter product name :\");\n",
        "price = float(input(\"Enter product cost :\"));\n",
        "print(\"The cost of the {} is {:.2f} Rupees\".format(product,price));"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter product name :samp\n",
            "Enter product cost :15\n",
            "The cost of the samp is 15.00 Rupees\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NXIej-lwLYyq",
        "outputId": "77bf89b7-151b-4b62-9cf8-aa1331f992ca"
      },
      "source": [
        "a = float(input(\"Enter a : \"));\n",
        "b = float(input(\"Enter b : \"));\n",
        "c = a+b;\n",
        "print(\"The sum of {2:.2f} and {1:.2f} is {0:.2f}\".format(a,b,c));\n",
        "print(\"The sum of {:.2f} and {:.2f} is {:.2f}\".format(a,b,c));\n",
        "print(\"The sum of {0:.2f} and {1:.2f} is {2:.2f}. So the final answer is {2:.2f}\".format(a,b,c));"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a : 5.76\n",
            "Enter b : 4.23\n",
            "The sum of 9.99 and 4.23 is 5.76\n",
            "The sum of 5.76 and 4.23 is 9.99\n",
            "The sum of 5.76 and 4.23 is 9.99. So the final answer is 9.99\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rfb9rSQZNMS2",
        "outputId": "f05d216c-eac7-4cdd-b491-7f4a04582a4c"
      },
      "source": [
        "car_str = \"I have a {carname} and it is a {make}\";\n",
        "print(car_str.format(carname=\"DB9\", make=\"Aston Martin\"));"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I have a DB9 and it is a Aston Martin\n"
          ]
        }
      ]
    }
  ]
}