Inheritence_and_Polymorphism.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0frAYzYTco3y"
   },
   "source": [
    "# Inheritence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "peoOtM-eZcPC"
   },
   "source": [
    "Inheritance is a mechanism which allows us to create a new class (known as child class) that is based upon an existing class (the parent class), by adding new attributes and methods on top of the existing class. When we do so, the child class inherits attributes and methods of the parent class.\n",
    "\n",
    "Inheritance really shines when you want to create classes that are very similar. All you need to do is to write the code the for the things that they have common in one class - the parent class. And then write code for things that are very specific in a different class - the child class. This saves you from duplicating a lot of code.\n",
    "\n",
    "Let's take a more concrete example to illustrate this concept.\n",
    "\n",
    "Suppose we are creating a program which deals with various shapes. Each shape has some common properties. For example, color of the shape, whether it is filled or not and so on. In addition to that, there are some properties which vary from shape to shape. For example, area and perimeter. The area of rectangle is `width * length` whereas the area of circle is `πr²` . At first, it might be tempting to create classes for different shapes like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FOM8px0OO-6o"
   },
   "outputs": [],
   "source": [
    "# Rectangle class\n",
    "class Rectangle:\n",
    "    def __init__(self, color, filled, width, length): # constructor\n",
    "        self.__color = color\n",
    "        self.__filled = filled\n",
    "        self.__width = width\n",
    "        self.__length = length\n",
    "\n",
    "    # methods    \n",
    "    def get_color(self):\n",
    "        return self.__color\n",
    "\n",
    "    def set_color(self, color):\n",
    "        self.__color = color\n",
    "\n",
    "    def is_filled(self):\n",
    "        return self.__filled\n",
    "\n",
    "    def set_filled(self, filled):\n",
    "        self.__filled = filled\n",
    "\n",
    "    def get_area(self):\n",
    "        return self.__width * self.__length\n",
    "\n",
    "# Circle class\n",
    "class Circle:\n",
    "    def __init__(self, color, filled, radius):\n",
    "        self.__color = color\n",
    "        self.__filled = filled\n",
    "        self.__radius = radius      \n",
    "\n",
    "    def get_color(self):\n",
    "        return self.__color\n",
    "\n",
    "    def set_color(self, color):\n",
    "        self.__color = color\n",
    "\n",
    "    def is_filled(self):\n",
    "        return self.__filled\n",
    "\n",
    "    def set_filled(self, filled):\n",
    "        self.__filled = filled\n",
    "\n",
    "    def get_area(self):\n",
    "        return math.pi * self.__radius ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SJMm9oVaZjAr"
   },
   "source": [
    "Did you notice the amount of duplicate code we are writing?\n",
    "\n",
    "Both classes share the same `__color` and `__filled` attribute as well as their getter and setter methods. \n",
    "\n",
    "To make the situation worse, If we want to update how any of these methods work, then we would have to visit each classes one by one to make the necessary changes. \n",
    "\n",
    "By using inheritance, we can abstract out common properties to a general Shape class (parent class) and then we can create child classes such as `Rectangle`, `Triangle` and `Circle` that inherits from the `Shape` class. \n",
    "\n",
    "A child class class inherits all the attributes and methods from it's parent class, but it can also add attributes and methods of it's own.\n",
    "\n",
    "To create a child class based upon the parent class we use the following syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7rZt6jeFZnvw"
   },
   "outputs": [],
   "source": [
    "class ParentClass:\n",
    "    # body of ParentClass\n",
    "    # method1 \n",
    "    # method2\n",
    "\n",
    "class ChildClass(ParentClass): # ChildClass inherits from ParentClass\n",
    "    # body of ChildClass\n",
    "    # method 1\n",
    "    # method 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SedsQbciZsPu"
   },
   "source": [
    "In Object Oriented lingo, When a class `c2` inherits from a class `c1`, we say \n",
    "* class c2 extends class c1, or \n",
    "* class c2 is derived from class c1.\n",
    "\n",
    "The following program demonstrate inheritance in action. It creates a class named `Shape`, which contains attributes and methods common to all shapes. Then it creates two child classes `Rectangle` and `Triangle` which contains attributes and methods specific to them only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JunX-fx_P2PQ",
    "outputId": "16365b8a-4abe-4143-e945-8b3d09f3aa19"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of rectangle r1: 26.25\n",
      "Perimeter of rectangle r1: 26.0\n",
      "Color of rectangle r1: black\n",
      "Is rectangle r1 filled ?  False\n",
      "Is rectangle r1 filled ?  True\n",
      "Color of rectangle r1: orange\n",
      "\n",
      "Area of circle c1: 452.39\n",
      "Perimeter of circle c1: 75.40\n",
      "Color of circle c1: black\n",
      "Is circle c1 filled ?  False\n",
      "Is circle c1 filled ?  True\n",
      "Color of circle c1: blue\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "class Shape: # parent class\n",
    "\n",
    "    def __init__(self, color='black', filled=False):\n",
    "        self.__color = color\n",
    "        self.__filled = filled\n",
    "\n",
    "    def get_color(self):\n",
    "        return self.__color\n",
    "\n",
    "    def set_color(self, color):\n",
    "        self.__color = color\n",
    "\n",
    "    def get_filled(self):\n",
    "        return self.__filled\n",
    "\n",
    "    def set_filled(self, filled):\n",
    "        self.__filled = filled\n",
    "\n",
    "\n",
    "class Rectangle(Shape): # Rectangle is derived from 'Shape' class; so it is a child of 'Shape' class\n",
    "\n",
    "    def __init__(self, length, breadth):\n",
    "        super().__init__() # calls the constructor of the parent (Shape) class\n",
    "        self.__length = length\n",
    "        self.__breadth = breadth\n",
    "\n",
    "    def get_length(self):\n",
    "        return self.__length\n",
    "\n",
    "    def set_length(self, length):\n",
    "        self.__length = length\n",
    "\n",
    "    def get_breadth(self):\n",
    "        return self.__breadth\n",
    "\n",
    "    def set_breadth(self, breadth):\n",
    "        self.__breadth = breadth\n",
    "\n",
    "    def get_area(self):\n",
    "        return self.__length * self.__breadth\n",
    "\n",
    "    def get_perimeter(self):\n",
    "        return 2 * (self.__length + self.__breadth)\n",
    "\n",
    "\n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        super().__init__() # calls the constructor of the parent (Shape) class\n",
    "        self.__radius = radius\n",
    "\n",
    "    def get_radius(self):\n",
    "        return self.__radius\n",
    "\n",
    "    def set_radius(self, radius):\n",
    "        self.__radius = radius\n",
    "\n",
    "    def get_area(self):\n",
    "        return math.pi * self.__radius ** 2\n",
    "\n",
    "    def get_perimeter(self):\n",
    "        return 2 * math.pi * self.__radius\n",
    "\n",
    "\n",
    "r1 = Rectangle(10.5, 2.5) # instantiation of 'Rectangle' class\n",
    "\n",
    "print(\"Area of rectangle r1:\", r1.get_area())\n",
    "print(\"Perimeter of rectangle r1:\", r1.get_perimeter())\n",
    "print(\"Color of rectangle r1:\", r1.get_color())\n",
    "print(\"Is rectangle r1 filled ? \", r1.get_filled())\n",
    "r1.set_filled(True)\n",
    "print(\"Is rectangle r1 filled ? \", r1.get_filled())\n",
    "r1.set_color(\"orange\")\n",
    "print(\"Color of rectangle r1:\", r1.get_color())\n",
    "\n",
    "c1 = Circle(12) # instantiation of 'Circle' class\n",
    "\n",
    "print(\"\\nArea of circle c1:\", format(c1.get_area(), \"0.2f\"))\n",
    "print(\"Perimeter of circle c1:\", format(c1.get_perimeter(), \"0.2f\"))\n",
    "print(\"Color of circle c1:\", c1.get_color())\n",
    "print(\"Is circle c1 filled ? \", c1.get_filled())\n",
    "c1.set_filled(True)\n",
    "print(\"Is circle c1 filled ? \", c1.get_filled())\n",
    "c1.set_color(\"blue\")\n",
    "print(\"Color of circle c1:\", c1.get_color())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r1Fvj21LfmPl"
   },
   "source": [
    "In lines `3-19`, we have defined a `Shape` class. It is a parent class and only contains attributes and methods common to all shapes. This class defines two private attributes `__color` and `__filled`, then it provides getter and setter methods for those attributes.\n",
    "\n",
    "In lines `22-45`, we have defined a `Rectangle` class which inherits from `Shape` class. Pay close attention to the syntax we are using."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BYePNUTfQQmK"
   },
   "source": [
    "![image.png](data:image/png;base64,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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fhFa7385cMTK"
   },
   "source": [
    "This lines tells us that Rectangle class extends the `Shape` class or `Rectangle` class is a child class of Shape class. Thus the `Rectangle` class inherits attributes and methods defined in the `Shape` class. In addition to that, the `Rectangle` class adds two private attributes, getter and setter methods for private attributes, as well as methods to calculate area and perimeter of the rectangle.\n",
    "\n",
    "Notice the code in line 25.\n",
    "\n",
    "`super().__init__()`\n",
    "\n",
    "We use `super()` function to call the parent class methods. So the above code calls `Shape` class's `__init__()` method. This is required to set the values of attributes in the parent class. Otherwise, when you try to access values of attributes defined in parent class using getter or setter methods, you will get an error.\n",
    "\n",
    "Similarly, In lines `48-63` we have defined a `Circle` class. Just like `Rectangle`, it extends the `Shape` class and adds few attributes and methods of its own.\n",
    "\n",
    "The code in lines `66-86`, creates `Rectangle` and `Circle` object and then calls `get_area()`, `get_perimeter()`, `get_filled()`, `get_color()`, `set_color()` and `set_filled()` methods on these objects one by one. Notice how we are able to call methods which are defined in the same class, as well as methods which are defined on the parent class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "78vIivZGcvUn"
   },
   "source": [
    "# Polymorphism and Method Overriding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TA7LvqakQlYM"
   },
   "source": [
    "In a literal sense, Polymorphism means the ability to take various forms. In Python, Polymorphism allows us to define methods in the child class with the same name as defined in their parent class.\n",
    "\n",
    "As we know, a child class inherits all the methods from the parent class. However, you will encounter situations where the method inherited from the parent class doesn't quite fit into the child class. In such cases, you will have to re-implement method in the child class. This process is known as *Method Overriding*.\n",
    "\n",
    "In you have overridden a method in child class, then the version of the method will be called based upon the the type of the object used to call it. \n",
    "* If a child class object is used to call an overridden method then the child class version of the method is called. \n",
    "* On the other hand, if parent class object is used to call an overridden method, then the parent class version of the method is called.\n",
    "\n",
    "The following program demonstrates method overriding in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OdUyf_MEQQGZ",
    "outputId": "aaeec9fb-aec3-48c7-fb0d-10a41b73a27b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "explore() method from class B\n",
      "explore() method from class A\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def explore(self):\n",
    "        print(\"explore() method from class A\")\n",
    "\n",
    "class B(A):\n",
    "    def explore(self): \n",
    "        print(\"explore() method from class B\") # method overriding\n",
    "\n",
    "\n",
    "b_obj = B() # instance of class B\n",
    "a_obj = A() # instance of class A\n",
    "\n",
    "b_obj.explore()\n",
    "a_obj.explore()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EN6y7oEBRV6n"
   },
   "source": [
    "Here `b_obj` is an object of class `B` (child class), as a result, class `B` version of the explore() method is called. \n",
    "\n",
    "However, the variable `a_obj` is an object of class `A` (parent class), as a result, class `A` version of the explore() method is called.\n",
    "\n",
    "If for some reason you still want to access the overridden method of the parent class in the child class, you can call it using the `super()` function as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TqGjduomRasA",
    "outputId": "3be4bd57-5c7a-431e-97c9-c0193adb41cc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "explore() method from class A\n",
      "explore() method from class B\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def explore(self):\n",
    "        print(\"explore() method from class A\")\n",
    "\n",
    "class B(A):\n",
    "    def explore(self):\n",
    "        super().explore()  # calling the parent class explore() method\n",
    "        print(\"explore() method from class B\")\n",
    "\n",
    "\n",
    "b_obj = B()\n",
    "b_obj.explore()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hsm19pcHhepq"
   },
   "source": [
    "You just saw Polymorphism in action - i.e. different invokations (and consequently different behaviors) of the same method, depending on the object the method is called from."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Python_Inheritence_and_Polymorphism.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}