OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d3e04ca7-6436-4601-b456-600d10bde5c3",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 24-05-2022"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fa47b5b4-1bf8-4152-89e9-93121af95399",
   "metadata": {},
   "outputs": [],
   "source": [
    "#create class\n",
    "class student:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "86f8dc54-f7ef-423a-8a40-950441b2b5dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "vt = student()\n",
    "s1 = student()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d9ea23d8-5e8d-475e-b22a-79c4bae90111",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.student'>\n"
     ]
    }
   ],
   "source": [
    "print(type(vt))\n",
    "\n",
    "#adding a variable individuals objects\n",
    "#Remember that this will not add attributes to other objects of the same class\n",
    "vt.name = 'Vinayak' # instance attribute\n",
    "vt.roll = 21\n",
    "s1.roll = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "e5dd5db5-13a9-42c7-9537-74badfd9d13f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'roll': 21, 'name': 'Vinayak'}\n",
      "{'roll': 12}\n"
     ]
    }
   ],
   "source": [
    "#this will generate a dictionary with all the attributes as a dictionary\n",
    "print(vt.__dict__)\n",
    "print(s1.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "09d8f4c5-7b99-43cd-bbaf-2600ffa05f3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "Vinayak\n",
      "Vinayak\n",
      "attribute does not exist\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# check if the object has a particular attribute\n",
    "print(hasattr(vt,'name'))\n",
    "print(hasattr(s1,'name'))\n",
    "\n",
    "# get the value of the object attribute\n",
    "print(getattr(vt,'name')) # Method 1\n",
    "print(vt.name) # Method 2\n",
    "print(getattr(s1,'name',\"attribute does not exist\")) # third argument is the default value if attr is not prosent\n",
    "\n",
    "#delete the particular attribute\n",
    "delattr(vt,'name')\n",
    "print(hasattr(vt,'name'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6428ca6f-da29-470d-b264-4f0d93916571",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Difference between instance attribute and class attribute\n",
    "class student:\n",
    "    pp = 40 # class instance will be defined for all the classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "5c141305-e426-4f9d-b383-ed74272ac565",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "vt =  student()\n",
    "print(vt.pp) # this will call class attribute as it doesnot have intance attribute\n",
    "s1.pp = student()\n",
    "s1.pp=80 # instance attribute\n",
    "print(s1.pp) #here instance attribute will be prnited"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5df2fe25-6470-4ad9-be88-8f67ad404912",
   "metadata": {},
   "source": [
    "## Instance Methods and Static Methods\n",
    "Here every function will need self as a compulsory argument since the self argument is passed by default to function. Normally the self object is by default passed to the function<br>\n",
    "The functions which do not need self as argument are static function. For this we use a decorator `@staticmethod`. This will stop binding of the function with the self object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d2b76966-f6df-4535-80f2-f993bd573fd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey! Welcome to school\n",
      "Name:  Vinayak\n",
      "Name:  Vinayak\n",
      "Student is passed\n"
     ]
    }
   ],
   "source": [
    "class student:\n",
    "    # every function will take the object itself as an argument with is refferes in the class as \"self\"\n",
    "    pp = 80\n",
    "    def studentDetails(self):\n",
    "        self.name = \"Vinayak\" #this creates the instance attribute\n",
    "        # and it will be available accross the class\n",
    "        # defining variable with self will create a local variable for this function only\n",
    "        percentage = 85 # this is a local variable\n",
    "        self.percentage = 85 # this is instance attribute\n",
    "        print(\"Name: \",self.name)\n",
    "    \n",
    "    def isPassed(self):\n",
    "        if self.percentage>=student.pp:\n",
    "            print(\"Student is passed\")\n",
    "        else:\n",
    "            print(\"Student is not passe\")\n",
    "            \n",
    "    #this is required before defining static method\n",
    "    @staticmethod\n",
    "    def welcometoschool():\n",
    "        # no need to pass self else it would have by default passed self argument\n",
    "        print(\"Hey! Welcome to school\")\n",
    "vt = student()\n",
    "vt.welcometoschool()\n",
    "vt.studentDetails() #by default the object is passed argument\n",
    "# Class_name.function(Class_name)\n",
    "student.studentDetails(vt) # this is same as above\n",
    "vt.isPassed()\n",
    "# The instance and the class attribute remains till the lifetime of the object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f9e2a82-dfcc-456b-9d38-77597443a346",
   "metadata": {},
   "source": [
    "## Init Method\n",
    "This method is immediately called after the obejct is created and the self object is passed by default to the init method. This is analogus to constructor in Java."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "604b9c71-06f6-412a-9768-c1c6dc3d23ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Vinayak', 'roll': 67}\n",
      "{'name': 'Kanchan', 'roll': 28}\n"
     ]
    }
   ],
   "source": [
    "class student:\n",
    "    def __init__(self,name,roll):\n",
    "        self.name = name\n",
    "        self.roll = roll\n",
    "\n",
    "# Remeber here self object is also passed by default but is not shown\n",
    "s1 = student(\"Vinayak\",67)\n",
    "print(s1.__dict__)\n",
    "s2 = student(\"Kanchan\",28)\n",
    "print(s2.__dict__)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31d58f94-a8e0-44f8-8ac1-5862ab34688d",
   "metadata": {},
   "source": [
    "## Factory methods or class method\n",
    "These methods creates the object when they are called using the class name. THe first argument is by default class name. TO define these method we use decorator `@classmethod`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "78f8d691-1a73-481b-ac50-0659d6962a34",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "class student:\n",
    "    pp = 40\n",
    "    def __init__(self,name,age,percentage):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.percentage = percentage\n",
    "    \n",
    "    # this is required before declaring a factory method\n",
    "    # the by default argument is class\n",
    "    @classmethod\n",
    "    def fromBirthdate(c,name,birth_year,percentage):\n",
    "        return c(name,date.today().year-birth_year,percentage)\n",
    "    \n",
    "    def studentDetails(self):\n",
    "        print(\"Name:\",self.name)\n",
    "        print(\"Age:\",self.age)\n",
    "        print(\"Percentage:\",self.percentage)\n",
    "    \n",
    "    def isPassed(self):\n",
    "        if self.percentage > student.pp:\n",
    "            print(\"Student is passed\")\n",
    "        else:\n",
    "            print(\"Student is not passed\")\n",
    "\n",
    "s1 = student(\"Vinayak\",21,56) #Declaring object in normal way\n",
    "s2 = student.fromBirthdate(\"Tripathi\",2001,67) #Declaring using the factory method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4dea6e5a-3d0f-4f89-bf0e-c2aca124a32d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Vinayak\n",
      "Age: 21\n",
      "Percentage: 56\n",
      "-----------------\n",
      "Name: Tripathi\n",
      "Age: 21\n",
      "Percentage: 67\n"
     ]
    }
   ],
   "source": [
    "s1.studentDetails()\n",
    "print(\"-----------------\")\n",
    "s2.studentDetails()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "464d4a95-7991-41a3-b2f8-93f5ba2f466e",
   "metadata": {},
   "source": [
    "## Private attributes\n",
    "By default in python all the attributes and methods are public i.e that they can be accessed in outside the class. But by naming the variable `__<variable name>` it can be converted to public class. It ccannot be accessed outside the class<br>\n",
    "In similiar way `__<function name>` will make the function function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "92c7a8c0-8765-43e2-8c77-a53d7d67898d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class student:\n",
    "    pp = 40\n",
    "    def __init__(self,name,age,percentage):\n",
    "        self.__name = name # this is the private attribute\n",
    "        self.age = age\n",
    "        self.percentage = percentage\n",
    "    \n",
    "    def studentDetails(self):\n",
    "        print(\"Name:\",self.__name) #this is not an error since private variable is used within class\n",
    "        print(\"Age:\",self.age)\n",
    "        print(\"Percentage:\",self.percentage)\n",
    "    \n",
    "    def isPassed(self):\n",
    "        if self.percentage > student.pp:\n",
    "            print(\"Student is passed\")\n",
    "        else:\n",
    "            print(\"Student is not passed\")\n",
    "\n",
    "s1 = student(\"Vinayak\",21,56)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6caee077-f42b-42f3-84ec-e16cf8efe441",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.age # this is not an error as it is public variable\n",
    "#s1.__name # this is an error as __name or name cannot be asscessed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "936851dc-65fc-4c0c-beb5-17cba4382689",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Vinayak'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# however there is a way to ascess private variable\n",
    "# when we say <object_instance_name>._<variablename> it can be interpreted as <object_instance_name>._<main_object>__<variablename>\n",
    "s1._student__name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "504c311c-5028-44e0-984c-6f313ac91602",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 26-05-2022\n",
    "Tried one thing --> You can access one object of the class using another object of the same class. See below code and understand if you didn't understand the statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1d9643be-ab1e-4e25-85ed-d9665ef5f940",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Kanchan\n",
      "Age: 17\n",
      "Percentage: 60\n"
     ]
    }
   ],
   "source": [
    "class student:\n",
    "    pp = 40\n",
    "    def __init__(self,name,age,percentage):\n",
    "        self.name = name \n",
    "        self.age = age\n",
    "        self.percentage = percentage\n",
    "    \n",
    "    def studentDetails(self,s):\n",
    "        print(\"Name:\",s.name) \n",
    "        print(\"Age:\",s.age)\n",
    "        print(\"Percentage:\",s.percentage)\n",
    "\n",
    "s1 = student(\"Vinayak\",21,56)\n",
    "s2 = student(\"Kanchan\",17,60)\n",
    "s1.studentDetails(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "197e6be9-3a31-46b0-95b6-5e8fcd74245f",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Class Example - Fraction\n",
    "Create Fraction Class to perform fraction definition, printing and basic operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "129b0825-8544-43dc-aae0-568914ffc0bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class fraction:\n",
    "    # by defining in this way,default values of the arguments are assigned\n",
    "    def __init__(self,num = 0,den = 1):\n",
    "        #if the num or den or bith are not passed then the default values will be passed\n",
    "        if den==0:\n",
    "            # throw error\n",
    "            den=1 #for now let's do this\n",
    "        self.num = num\n",
    "        self.den = den\n",
    "    def print(self):\n",
    "        if self.num==0:\n",
    "            print(0)\n",
    "        elif self.den==1:\n",
    "            print(self.num)\n",
    "        else:    \n",
    "            print(\"{}/{}\".format(self.num,self.den))\n",
    "    \n",
    "    def simplify(self):\n",
    "        if self.num == 0:\n",
    "            self.den = 1\n",
    "            return\n",
    "        current = min(self.num,self.den)\n",
    "        while current>1:\n",
    "            if self.num%current==0 and self.den%current==0:\n",
    "                break\n",
    "            current-=1\n",
    "        self.num = self.num//current\n",
    "        self.den = self.den//current\n",
    "    \n",
    "    def add(self, b):\n",
    "        newNum = b.den * self.num + b.num * self.den\n",
    "        newDen = b.den * self.den\n",
    "        self.den = newDen\n",
    "        self.num = newNum\n",
    "        self.simplify()\n",
    "        \n",
    "    def multiply(self,b):\n",
    "        newNum = b.num * self.num\n",
    "        newDen = b.den * self.den\n",
    "        self.den = newDen\n",
    "        self.num = newNum\n",
    "        self.simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "aad893ea-d384-4edb-a4f0-712868d63dc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'num': 2, 'den': 3}\n",
      "2/3\n",
      "{'num': 2, 'den': 1}\n",
      "2\n",
      "{'num': 0, 'den': 1}\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "f1 = fraction(2,3)\n",
    "f2 = fraction(2) # single value passed\n",
    "f3 = fraction() # no values passed\n",
    "print(f1.__dict__)\n",
    "f1.print()\n",
    "print(f2.__dict__)\n",
    "f2.print()\n",
    "print(f3.__dict__)\n",
    "f3.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "4a8421af-28fc-41a9-9c23-3df0f3309725",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = fraction(2,3)\n",
    "b = fraction(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "0358bdb2-f7a1-4e68-8c92-1a25d801450f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13/15\n"
     ]
    }
   ],
   "source": [
    "a.add(b)\n",
    "a.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "3a93d50f-20d1-4277-837f-6755cd394a7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13/75\n"
     ]
    }
   ],
   "source": [
    "a.multiply(b)\n",
    "a.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46050c71-fa18-47cb-8d78-b976acb7bc92",
   "metadata": {},
   "source": [
    "## Class Example - Complex\n",
    "Create Complex Class to perform complex number definition, printing and basic operations like add, multiply and make conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "0c5bb466-3654-454d-af6e-51a3d4ef2283",
   "metadata": {},
   "outputs": [],
   "source": [
    "class complex:\n",
    "    def __init__(self,r=0,i=0):\n",
    "        self.r = r\n",
    "        self.i = i\n",
    "    \n",
    "    def print(self):\n",
    "        if self.i==0:\n",
    "            if self.r==0:\n",
    "                print(0)\n",
    "            else:\n",
    "                print(self.r)\n",
    "        elif self.r==0:\n",
    "            print(\"{}i\".format(self.i))\n",
    "        else:\n",
    "            if self.i<0:\n",
    "                print(\"{} - {}i\".format(self.r,-1*self.i))\n",
    "            else: print(\"{} + {}i\".format(self.r,self.i))\n",
    "    \n",
    "    def add(self,b):\n",
    "        newi = self.i + b.i\n",
    "        newr = self.r + b.r\n",
    "        self.r = newr\n",
    "        self.i = newi\n",
    "    \n",
    "    def multiply(self,b):\n",
    "        newi = self.i * b.r + self.r * b.i\n",
    "        newr = self.r * b.r - self.i * b.i\n",
    "        self.r = newr\n",
    "        self.i = newi\n",
    "        \n",
    "    def conjugate(self):\n",
    "        self.i = self.i*-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "c10cd60a-b9b5-4633-a165-a78781a3a826",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 - 2i\n",
      "-11i\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "a = complex(1,-2)\n",
    "a.print()\n",
    "a = complex(0,-11)\n",
    "a.print()\n",
    "a = complex()\n",
    "a.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "3d0a8c45-99cd-4bde-93c1-1871e6f243dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = complex(4,5)\n",
    "b = complex(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c4a0f6a-085b-4027-97ea-48f849712c27",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.add(b)\n",
    "a.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "37d838f8-a81e-45e0-af05-0cc1b431142c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-6 + 13i\n"
     ]
    }
   ],
   "source": [
    "a.multiply(b)\n",
    "a.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7955449c-011e-4c5e-a4e2-7f4e90bb5fe6",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 28-05-2022"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83002c98-9bf2-4b61-98ad-100a35876c22",
   "metadata": {},
   "source": [
    "## Inheritance\n",
    "Inheritance enables us to define a class that takes all the functionality from a parent class and allows us to add more.<br>\n",
    "Inheritance contains Base or super class and child class. Child class is defined by passing the parent class in it. See the below code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8b300bb3-4fc6-4516-abb5-9bf5ed384f71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Geek1 False\n",
      "Geek2 True\n"
     ]
    }
   ],
   "source": [
    "# A Python program to demonstrate inheritance\n",
    "  \n",
    "# Base or Super class. Note object in bracket.\n",
    "# (Generally, object is made ancestor of all classes)\n",
    "# In Python 3.x \"class Person\" is\n",
    "# equivalent to \"class Person(object)\"\n",
    "class Person(object):\n",
    "      \n",
    "    # Constructor\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "  \n",
    "    # To get name\n",
    "    def getName(self):\n",
    "        return self.name\n",
    "  \n",
    "    # To check if this person is an employee\n",
    "    def isEmployee(self):\n",
    "        return False\n",
    "  \n",
    "  \n",
    "# Inherited or Subclass (Note Person in bracket)\n",
    "class Employee(Person):\n",
    "  \n",
    "    # Here we return true\n",
    "    # method is overriden from the parent class\n",
    "    def isEmployee(self):\n",
    "        return True\n",
    "    \n",
    "emp = Person(\"Geek1\")  # An Object of Person\n",
    "print(emp.getName(), emp.isEmployee())\n",
    "  \n",
    "emp = Employee(\"Geek2\") # An Object of Employee\n",
    "print(emp.getName(), emp.isEmployee())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af5f4a23-ca1f-4320-ad54-adee41740ba4",
   "metadata": {},
   "source": [
    "### Inheritance code example to find the area of the shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7881590d-04ff-466a-8740-39c7fafdf699",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Polygon:\n",
    "    def __init__(self, no_of_sides):\n",
    "        self.n = no_of_sides\n",
    "        self.sides = [0 for i in range(no_of_sides)]\n",
    "\n",
    "    def inputSides(self):\n",
    "        self.sides = [float(input(\"Enter side \"+str(i+1)+\" : \")) for i in range(self.n)]\n",
    "\n",
    "    def dispSides(self):\n",
    "        for i in range(self.n):\n",
    "            print(\"Side\",i+1,\"is\",self.sides[i])\n",
    "        \n",
    "class Triangle(Polygon):\n",
    "    def __init__(self):\n",
    "        Polygon.__init__(self,3)\n",
    "        # or ******************\n",
    "        # super().__init__(3)\n",
    "\n",
    "    def findArea(self):\n",
    "        a, b, c = self.sides\n",
    "        # calculate the semi-perimeter\n",
    "        s = (a + b + c) / 2\n",
    "        area = (s*(s-a)*(s-b)*(s-c)) ** 0.5\n",
    "        print('The area of the triangle is %0.2f' %area)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7e9fe7ec-e139-437f-8628-31d1d869be47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter side 1 :  3\n",
      "Enter side 2 :  5\n",
      "Enter side 3 :  4\n",
      "Side 1 is 3.0\n",
      "Side 2 is 5.0\n",
      "Side 3 is 4.0\n",
      "The area of the triangle is 6.00\n"
     ]
    }
   ],
   "source": [
    "t = Triangle()\n",
    "t.inputSides()\n",
    "t.dispSides()\n",
    "t.findArea()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c69cc49-2aab-4930-9573-d92162c938a9",
   "metadata": {},
   "source": [
    "## Two built-in functions isinstance() and issubclass() are used to check inheritances.\n",
    "The function `isinstance()` returns True if the object is an instance of the class or other classes derived from it. Each and every class in Python inherits from the base class object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d4584782-19a4-4f23-bd36-96efbe3ceab3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(t,Triangle)) # t is object of Triangle\n",
    "print(isinstance(t,Polygon)) # t is object of Polygon as it is inherited\n",
    "print(isinstance(t,int)) # t is not object of int\n",
    "\n",
    "print(isinstance(t,object))\n",
    "print(issubclass(Polygon,Triangle))\n",
    "\n",
    "print(issubclass(Triangle,Polygon))\n",
    "print(issubclass(bool,int))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eff97ce-238a-4a37-bb09-9c0e67540f92",
   "metadata": {},
   "source": [
    "⭐⭐ See the link https://www.programiz.com/python-programming/operator-overloading"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2cf84c8-ba4f-4fa7-8e1f-3f5de7a9fec2",
   "metadata": {},
   "source": [
    "## Abstract Class\n",
    "An abstract method is a method that has a declaration but does not have an implementation. A class which contains one or more abstract methods is called an abstract class.<br>\n",
    "We need to import `module abc` for implementing abstract classes in python. <br>\n",
    "<b><u>abc --> Abstract Base Classes</u></b>.<br> Decorator `@abstractmethod` is used to define abstract method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "4a124797-324c-4f30-a29c-4253545a76b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class automobile(ABC):\n",
    "    # You won't be able to create object of abstract class\n",
    "    def __init__(self,wheels):\n",
    "        self.wheels = wheels\n",
    "        print(\"Automobile with %d wheels Created\"%self.wheels)\n",
    "    \n",
    "    @abstractmethod\n",
    "    def start(self):\n",
    "        print('Start of Automobile is called')\n",
    "        #this part will be executed by calling this using 'super only else this method will be overidden\n",
    "        # by the child class method which has implemented this abstract method\n",
    "    \n",
    "    @abstractmethod\n",
    "    def stop(self):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def drive(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def get_wheels(self):\n",
    "        return self.wheels\n",
    "# vt = automobile()\n",
    "# --> TypeError: Can't instantiate abstract class automobile with abstract methods drive, start, stop\n",
    "\n",
    "class car(automobile):\n",
    "    # Since this class inherits abstract class it will need to implement the abstract methods in it\n",
    "    # else it will be error without implementing abstract method\n",
    "    def __init__(self,name):\n",
    "        print(\"Car created\")\n",
    "        self.name = name\n",
    "        super().__init__(4)\n",
    "    # if above init method is not there then init method of Abstract class will be called   \n",
    "    \n",
    "    # implementing abstract methods here\n",
    "    \n",
    "    # you can write some code in the abstract method\n",
    "    def start(self):\n",
    "        super().start() # here the parent class method is called\n",
    "        print('Start of Car is called')\n",
    "    \n",
    "    def stop(self):\n",
    "        pass\n",
    "    \n",
    "    def drive(self):\n",
    "        pass\n",
    "    \n",
    "    def get_wheels(self):\n",
    "        return super().get_wheels()\n",
    "    \n",
    "class bus(automobile):\n",
    "\n",
    "    # implementing abstract methods here\n",
    "    def start(self):\n",
    "        pass\n",
    "    \n",
    "    def stop(self):\n",
    "        pass\n",
    "    \n",
    "    def drive(self):\n",
    "        pass\n",
    "    \n",
    "    def get_wheels(self):\n",
    "        return super().get_wheels()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "11fa7a5e-7b2e-4c51-aa1f-8205f2f5141e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car created\n",
      "Automobile with 4 wheels Created\n",
      "Start of Automobile is called\n",
      "Start of Car is called\n",
      "-------------------\n",
      "Automobile with 3 wheels Created\n",
      "4\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "c = car(\"Mercedes\")\n",
    "c.start()\n",
    "print('-------------------')\n",
    "b = bus(3)\n",
    "print(c.get_wheels())\n",
    "print(b.get_wheels())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6173427f-bdaf-42b2-a5e2-509970948b9a",
   "metadata": {},
   "source": [
    "## Errors and Exceptions\n",
    "Errors are the problems in a program due to which the program will stop the execution.<br>\n",
    "When in the runtime an error that occurs after passing the syntax test is called exception or logical error.<br>\n",
    "<a href = 'https://www.geeksforgeeks.org/errors-and-exceptions-in-python/'>Click here for List of Exceptions</a>\n",
    "<br> We can also handle multiple trype of error by specifying the type of error `except &lt;exceptiontype&gt;`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1bf18b8e-b7e8-4b4d-9e8a-9aa5ebf682d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    n = input(\"Enter a numerator : \")\n",
    "    num = int(n)\n",
    "    d = input(\"Enter a denominator : \")\n",
    "    den = int(d)\n",
    "    value = num/den\n",
    "    print(value)\n",
    "except ValueError:\n",
    "    # This except block will only handle ValueError\n",
    "    print(\"ValueError\")\n",
    "except ZeroDivisionError:\n",
    "    print('Denominator cannot be zero')\n",
    "except:\n",
    "    # this block will handle all the error\n",
    "    print('Numerator and denominator should be integer')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d78e5e2b",
   "metadata": {},
   "source": [
    "## Custom execption\n",
    "Raising some exceptions on certain conditions `raise &lt;ExceptionType&gt;`\n",
    "<br>\n",
    "<br>\n",
    "User defined exceptions can also be done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "40196723",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Divison by zeros not possible\n",
      "Divison by zeros not possible\n",
      "0.03498542274052478\n"
     ]
    }
   ],
   "source": [
    "# defining userdefined error\n",
    "class ZeroDominatorError(ZeroDivisionError):\n",
    "    # instead of Exception we can also use ZeroDivisionError as argument\n",
    "    # this makes the ZeroDominatorError class as subclass of ZeroDivisionError\n",
    "    # this will make this error as a child of ZeroDivisionError\n",
    "    # Exception class a init method which takes message as argument\n",
    "    pass\n",
    "\n",
    "while True:\n",
    "    try:\n",
    "        n = input('Enter a numerator : ')\n",
    "        num = int(n)\n",
    "        d = input('Enter a denominator : ')\n",
    "        den = int(d)\n",
    "        if den == 0:\n",
    "            # raising the exception with the message\n",
    "            raise ZeroDominatorError('Denominator cannot be zero')\n",
    "        value = num/den\n",
    "        print(value)\n",
    "        break\n",
    "    except ValueError:\n",
    "        print('Numerator and Denominator should be integer')\n",
    "    except ZeroDivisionError:\n",
    "        # Now if the ZeroDominatorError is raised and is the child of ZeroDivisionError then then this block will be executed\n",
    "        # If we change the order the below block then that will be executed first\n",
    "        # See the below example\n",
    "        print('Divison by zeros not possible')\n",
    "    except ZeroDominatorError as e:\n",
    "        print(e)\n",
    "    except Exception as e:\n",
    "        # this block will handle all the exceptions that are not specified above\n",
    "        print(e)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f766b3bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Denominator cannot be zero\n",
      "0.3111111111111111\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    try:\n",
    "        n = input('Enter a numerator : ')\n",
    "        num = int(n)\n",
    "        d = input('Enter a denominator : ')\n",
    "        den = int(d)\n",
    "        if den == 0:\n",
    "            # raising the exception with the message\n",
    "            raise ZeroDominatorError('Denominator cannot be zero')\n",
    "        value = num/den\n",
    "        print(value)\n",
    "        break\n",
    "    except ValueError:\n",
    "        print('Numerator and Denominator should be integer')\n",
    "    except ZeroDominatorError as e:\n",
    "        print(e)\n",
    "        # Now in this code the ZeroDivisionError is executed and this will be exected as code is executed linearly and this except block is encountered first\n",
    "    except ZeroDivisionError:\n",
    "        print('Divison by zeros not possible')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e42df36f",
   "metadata": {},
   "source": [
    "## Else and finally in exception handling\n",
    "else:  the code inside this sill be executed if no given error is found or raised. This block will be present at the last of the try except block and before finally block if it is defined<br>\n",
    "<br>finally: this is the code which will be finally always executed whether error occured or not occured. This block will compulsorily be declared at last of the try except else block\n",
    "1. try except\n",
    "2. try except finally\n",
    "3. try except else\n",
    "4. try except else finally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "fbc0b29b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value is 1.00\n",
      "This was good\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    try:\n",
    "        n = input('Enter a numerator : ')\n",
    "        num = int(n)\n",
    "        d = input('Enter a denominator : ')\n",
    "        den = int(d)\n",
    "        if den == 0:\n",
    "            # raising the exception with the message\n",
    "            raise ZeroDominatorError('Denominator cannot be zero')\n",
    "        value = num/den\n",
    "    except ValueError:\n",
    "        print('Numerator and Denominator should be integer')\n",
    "    except ZeroDominatorError as e:\n",
    "        print(e)\n",
    "        # Now in this code the ZeroDivisionError is executed and this will be exected as code is executed linearly and this except block is encountered first\n",
    "    except ZeroDivisionError:\n",
    "        print('Divison by zeros not possible')\n",
    "    else:\n",
    "        # this block will be executed if not exception raised\n",
    "        print('Value is %0.2f' %value)\n",
    "        break\n",
    "    finally:\n",
    "        print(\"This was good\")\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "f4b2379af196c368a34064cc89b60a1e9f5160853b69b3c323cf4119a4b70be8"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}