001_Python_OOPs_Concepts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in this lecture series by Dr. Milan Parmar are available @ **[GitHub](https://github.com/milaan9/06_Python_Object_Class)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python OOPs Concepts\n",
    "\n",
    "In this class, you’ll learn about Object-Oriented Programming (OOP) in Python and its fundamental concept with the help of examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object Oriented Programming\n",
    "\n",
    "Python is a multi-paradigm programming language. It supports different programming approaches.\n",
    "\n",
    "One of the popular approaches to solve a programming problem is by creating objects. This is known as Object-Oriented Programming (OOP).\n",
    "\n",
    "Object-oriented programming (OOP) is a programming paradigm based on the concept of **“objects”**. The object contains both data and code: Data in the form of properties (often known as attributes), and code, in the form of methods (actions object can perform).\n",
    "\n",
    "An object has two characteristics:\n",
    "\n",
    "* attributes\n",
    "* behavior\n",
    "\n",
    "For example:\n",
    "\n",
    "A parrot is can be an object,as it has the following properties:\n",
    "\n",
    "* name, age, color as attributes\n",
    "* singing, dancing as behavior\n",
    "\n",
    "The concept of OOP in Python focuses on creating reusable code. This concept is also known as DRY (Don't Repeat Yourself).\n",
    "\n",
    "In Python, the concept of OOP follows some basic principles:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class \n",
    "\n",
    "In Python, everything is an object. A class is a blueprint for the object. To create an object we require a model or plan or blueprint which is nothing but class.\n",
    "\n",
    "**Class represents the properties (attribute) and action (behavior) of the object. Properties represent variables, and actions are represented by the methods. Hence class contains both variables and methods.**\n",
    "\n",
    "We can think of class as a sketch of a parrot with labels. It contains all the details about the name, colors, size etc. Based on these descriptions, we can study about the parrot. Here, a parrot is an object.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "class classname:\n",
    "    '''documentation string'''\n",
    "    class_suite\n",
    "```\n",
    "* **Documentation string:** represent a description of the class. It is optional.\n",
    "* **class_suite:** class suite contains component statements, variables, methods, functions, attributes.\n",
    "\n",
    "The example for class of parrot can be :\n",
    "\n",
    "```python\n",
    "class Parrot:\n",
    "    pass\n",
    "```\n",
    "\n",
    "Here, we use the **`class`** keyword to define an empty class **`Parrot`**. From class, we construct instances. An instance is a specific object created from a particular class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object \n",
    "\n",
    "The physical existence of a class is nothing but an object. In other words, the object is an entity that has a state and behavior. \n",
    "\n",
    "Therefore, an object (instance) is an instantiation of a class. So, when class is defined, only the description for the object is defined. Therefore, no memory or storage is allocated.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```pyton\n",
    "reference_variable = classname()\n",
    "```\n",
    "\n",
    "The example for object of parrot class can be:\n",
    "\n",
    "```python\n",
    "obj = Parrot()\n",
    "```\n",
    "\n",
    "Here, **`obj`** is an **`object`** of class Parrot.\n",
    "\n",
    "Suppose we have details of parrots. Now, we are going to show how to build the class and objects of parrots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:01.298252Z",
     "start_time": "2021-06-19T09:00:01.283605Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome to Dr. Milaan Parmar's class on Python Programming\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Creating Class and Object in Python\n",
    "\n",
    "class Student:\n",
    "    \"\"\"This is student class with data\"\"\"    \n",
    "    def learn(self):    # A sample method\n",
    "        print(\"Welcome to Dr. Milaan Parmar's class on Python Programming\")\n",
    "\n",
    "stud = Student()        # creating object\n",
    "stud.learn()            # Calling method\n",
    "\n",
    "# Output: Welcome to Dr. Milaan Parmar's class on Python Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instance Variables and Methods\n",
    "\n",
    "If the value of a variable varies from object to object, then such variables are called instance variables. For every object, a separate copy of the instance variable will be created.\n",
    "\n",
    "When we create classes in Python, instance methods are used regularly. we need to create an object to execute the block of code or action defined in the instance method.\n",
    "\n",
    "We can access the instance variable and methods using the object. Use dot (**`.`**) operator to access instance variables and methods.\n",
    "\n",
    "In Python, working with an instance variable and method, we use the **`self`** keyword. When we use the **`self`** keyword as a parameter to a method or with a variable name is called the instance itself.\n",
    "\n",
    ">**Note:** Instance variables are used within the instance method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:03.112688Z",
     "start_time": "2021-06-19T09:00:03.099018Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name is: Arthur and percentage is: 90\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Creating Class and Object in Python\n",
    "\n",
    "class Student:\n",
    "    def __init__(self, name, percentage):\n",
    "        self.name = name\n",
    "        self.percentage = percentage\n",
    "\n",
    "    def show(self):\n",
    "        print(\"Name is:\", self.name, \"and percentage is:\", self.percentage)\n",
    "\n",
    "        \n",
    "stud = Student(\"Arthur\", 90)\n",
    "stud.show()\n",
    "\n",
    "# Output Name is: Arthur and percentage is: 90"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div>\n",
    "<img src=\"img/instvarmeth.png\" width=\"700\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:06.483747Z",
     "start_time": "2021-06-19T09:00:06.468123Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Blu is a bird\n",
      "Woo is also a bird\n",
      "Blu is 10 years old\n",
      "Woo is 15 years old\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Creating Class and Object in Python\n",
    "\n",
    "class Parrot:\n",
    "    species = \"bird\"                    # class attribute\n",
    "    def __init__(self, name, age):      # instance attribute\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "# instantiate the Parrot class\n",
    "blu = Parrot(\"Blu\", 10)\n",
    "woo = Parrot(\"Woo\", 15)\n",
    "\n",
    "# access the class attributes\n",
    "print(\"Blu is a {}\".format(blu.__class__.species))\n",
    "print(\"Woo is also a {}\".format(woo.__class__.species))\n",
    "\n",
    "# access the instance attributes\n",
    "print(\"{} is {} years old\".format( blu.name, blu.age))\n",
    "print(\"{} is {} years old\".format( woo.name, woo.age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "In the above program, we created a class with the name **`Parrot`**. Then, we define attributes. The attributes are a characteristic of an object.\n",
    "\n",
    "These attributes are defined inside the **`__init__`** method of the class. It is the initializer method that is first run as soon as the object is created.\n",
    "\n",
    "Then, we create instances of the **`Parrot`** class. Here, **`blu`** and **`woo`** are references (value) to our new objects.\n",
    "\n",
    "We can access the class attribute using **`__class__.species`**. Class attributes are the same for all instances of a class. Similarly, we access the instance attributes using **`blu.name`** and **`blu.age`**. However, instance attributes are different for every instance of a class.\n",
    "\n",
    "To learn more about classes and objects, go to [**Python Classes and Objects**](https://github.com/milaan9/06_Python_Object_Class/blob/main/002_Python_Classes_and_Objects.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method\n",
    "\n",
    "Methods are functions defined inside the body of a class. They are used to define the behaviors of an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:11.054497Z",
     "start_time": "2021-06-19T09:00:11.034969Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Blu sings 'Happy'\n",
      "Blu is now dancing\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Creating Methods in Python\n",
    "\n",
    "class Parrot:\n",
    "    \n",
    "    # instance attributes\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    \n",
    "    # instance method\n",
    "    def sing(self, song):\n",
    "        return \"{} sings {}\".format(self.name, song)\n",
    "\n",
    "    def dance(self):\n",
    "        return \"{} is now dancing\".format(self.name)\n",
    "\n",
    "# instantiate the object\n",
    "blu = Parrot(\"Blu\", 10)\n",
    "\n",
    "# call our instance methods\n",
    "print(blu.sing(\"'Happy'\"))\n",
    "print(blu.dance())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "In the above program, we define two methods i.e **`sing()`** and **`dance()`**. These are called instance methods because they are called on an instance object i.e **`blu`**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encapsulation\n",
    "\n",
    "n Python, encapsulation is a method of wrapping data and functions into a single entity. For example, A class encapsulates all the data (methods and variables). Encapsulation means the internal representation of an object is generally hidden from outside of the object’s definition.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/encap.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "Using OOP in Python, we can restrict access to methods and variables. This prevents data from direct modification which is called encapsulation. In Python, we denote private attributes using underscore as the prefix i.e single **`_`** or double **`__`**.\n",
    "\n",
    "#### Need of Encapsulation\n",
    "\n",
    "Encapsulation acts as a protective layer. We can restrict access to methods and variables from outside, and It can prevent the data from being modified by accidental or unauthorized modification. Encapsulation provides security by hiding the data from the outside world.\n",
    "\n",
    "In Python, we do not have access modifiers directly, such as public, private, and protected. But we can achieve encapsulation by using single prefix underscore and double underscore to control access of variable and method within the Python program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:15.687261Z",
     "start_time": "2021-06-19T09:00:15.666758Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selling Price: 900\n",
      "Selling Price: 900\n",
      "Selling Price: 1000\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Data Encapsulation in Python\n",
    "\n",
    "class Computer:\n",
    "\n",
    "    def __init__(self):\n",
    "        self.__maxprice = 900\n",
    "\n",
    "    def sell(self):\n",
    "        print(\"Selling Price: {}\".format(self.__maxprice))\n",
    "\n",
    "    def setMaxPrice(self, price):\n",
    "        self.__maxprice = price\n",
    "\n",
    "c = Computer()\n",
    "c.sell()\n",
    "\n",
    "# change the price\n",
    "c.__maxprice = 1000\n",
    "c.sell()\n",
    "\n",
    "# using setter function\n",
    "c.setMaxPrice(1000)\n",
    "c.sell()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "In the above program, we defined a **`Computer`** class.\n",
    "\n",
    "We used **`__init__()`** method to store the maximum selling price of **`Computer`**. We tried to modify the price. However, we can't change it because Python treats the **`__maxprice`** as private attributes.\n",
    "\n",
    "As shown, to change the value, we have to use a setter function i.e **`setMaxPrice()`** which takes price as a parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:17.520737Z",
     "start_time": "2021-06-19T09:00:17.211663Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Employee' object has no attribute 'PrintName'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-b977fb738e16>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;31m# Outside class\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[0mE\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mEmployee\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Bella\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m60000\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[0mE\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mPrintName\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     14\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mE\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mE\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mPrintName\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Employee' object has no attribute 'PrintName'"
     ]
    }
   ],
   "source": [
    "# Example 2: Data Encapsulation in Python\n",
    "\n",
    "class Employee:\n",
    "    def __init__(self, name, salary):\n",
    "        self.name = name\n",
    "        self.__salary = salary\n",
    "\n",
    "    def show(self):\n",
    "        print(\"Name is \", self.name, \"and salary is\", self.__salary)\n",
    "\n",
    "# Outside class\n",
    "E = Employee(\"Bella\", 60000)\n",
    "E.PrintName()\n",
    "print(E.name)\n",
    "print(E.PrintName())\n",
    "print(E.__salary)\n",
    "\n",
    "# AttributeError: 'Employee' object has no attribute '__salary'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "In the above example, we create a class called **`Employee`**. Within that class, we declare two variables **`name`** and **`__salary`**. We can observe that the name variable is accessible, but **`__salary`** is the **private variable**. We cannot access it from outside of class. If we try to access it, we will get an error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Polymorphism\n",
    "\n",
    "Polymorphism is based on the greek words **Poly** (many) and **morphism** (forms). We will create a structure that can take or use many forms of objects.\n",
    "\n",
    "Polymorphism is an ability (in OOP) to use a common interface for multiple forms (data types).\n",
    "\n",
    "**Example 1:** The student can act as a student in college, act as a player on the ground, and as a daughter/brother in the home. \n",
    "\n",
    "**Example 2:** In the programming language, the **`+`** operator, acts as a concatenation and arithmetic addition.\n",
    "\n",
    "**Example 3:** If we need to color a shape, there are multiple shape options (rectangle, square, circle). However we could use the same method to color any shape. \n",
    "\n",
    "<div>\n",
    "<img src=\"img/polymor.png\" width=\"400\"/>\n",
    "</div>\n",
    "\n",
    "In Python, polymorphism allows us to define the child class methods with the same name as defined in the parent class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:20.204307Z",
     "start_time": "2021-06-19T09:00:20.187708Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parrot can fly\n",
      "Penguin can't fly\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Using Polymorphism in Python\n",
    "\n",
    "class Parrot:\n",
    "\n",
    "    def fly(self):\n",
    "        print(\"Parrot can fly\")\n",
    "    \n",
    "    def swim(self):\n",
    "        print(\"Parrot can't swim\")\n",
    "\n",
    "class Penguin:\n",
    "\n",
    "    def fly(self):\n",
    "        print(\"Penguin can't fly\")\n",
    "    \n",
    "    def swim(self):\n",
    "        print(\"Penguin can swim\")\n",
    "\n",
    "# common interface\n",
    "def flying_test(bird):\n",
    "    bird.fly()\n",
    "\n",
    "#instantiate objects\n",
    "blu = Parrot()\n",
    "peggy = Penguin()\n",
    "\n",
    "# passing the object\n",
    "flying_test(blu)\n",
    "flying_test(peggy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exaplanation**:\n",
    "\n",
    "In the above program, we defined two classes **`Parrot`** and **`Penguin`**. Each of them have a common **`fly()`** method. However, their functions are different.\n",
    "\n",
    "To use polymorphism, we created a common interface i.e **`flying_test()`** function that takes any object and calls the object's **`fly()`** method. Thus, when we passed the **`blu`** and **`peggy`** objects in the **`flying_test()`** function, it ran effectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:21.662302Z",
     "start_time": "2021-06-19T09:00:21.639840Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of circle: 254.34\n",
      "Area of Rectangle: 54\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Using Polymorphism in Python\n",
    "\n",
    "class Circle:\n",
    "    pi = 3.14\n",
    "\n",
    "    def __init__(self, redius):\n",
    "        self.radius = redius\n",
    "\n",
    "    def calculate_area(self):\n",
    "        print(\"Area of circle:\", self.pi * self.radius * self.radius)\n",
    "\n",
    "class Rectangle:\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "\n",
    "    def calculate_area(self):\n",
    "        print(\"Area of Rectangle:\", self.length * self.width)\n",
    "\n",
    "cir = Circle(9)\n",
    "rect = Rectangle(9, 6)\n",
    "cir.calculate_area()\n",
    "# Output Area of circle: 254.34\n",
    "\n",
    "rect.calculate_area()\n",
    "# Output Area od Rectangle: 54"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exaplanation**:\n",
    "\n",
    "In the above example, we created two classes called **`Circle`** and **`Rectangle`**. In both classes, we created the same method with the name **`calculate_area`**. This method acts differently in both classes. In the case of the **`Circle`** class, it calculates the area of the circle, whereas, in the case of a **`Rectangle`** class, it calculates the area of a rectangle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inheritance\n",
    "\n",
    "In an Object-oriented programming language, inheritance is an important aspect. The main purpose of inheritance is the reusability of code because we can use the existing class to create a new class instead of creating it from scratch.\n",
    "\n",
    "In Python, **[inheritance](https://github.com/milaan9/06_Python_Object_Class/blob/main/003_Python_Inheritance.ipynb)** is the process of inheriting the properties of the base class (or parent class) into a derived class (or child class).\n",
    "\n",
    "In inheritance, the child class acquires and access all the data members, properties, and functions from the parent class. Also, a child class can also provide its specific implementation to the functions of the parent class.\n",
    "\n",
    "#### Use of inheritance\n",
    "\n",
    "To create classes that are built upon existing classes called reusability. So, we do not have to write the same code again and again.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "class BaseClass:\n",
    "    Body of base class\n",
    "class DerivedClass(BaseClass):\n",
    "    Body of derived class\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:23.526541Z",
     "start_time": "2021-06-19T09:00:23.515798Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bird is ready\n",
      "Penguin is ready\n",
      "Penguin\n",
      "Swim faster\n",
      "Run faster\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Use of Inheritance in Python\n",
    "\n",
    "# parent class\n",
    "class Bird:\n",
    "    \n",
    "    def __init__(self):\n",
    "        print(\"Bird is ready\")\n",
    "\n",
    "    def whoisThis(self):\n",
    "        print(\"Bird\")\n",
    "\n",
    "    def swim(self):\n",
    "        print(\"Swim faster\")\n",
    "\n",
    "# child class\n",
    "class Penguin(Bird):\n",
    "\n",
    "    def __init__(self):\n",
    "        # call super() function\n",
    "        super().__init__()\n",
    "        print(\"Penguin is ready\")\n",
    "\n",
    "    def whoisThis(self):\n",
    "        print(\"Penguin\")\n",
    "\n",
    "    def run(self):\n",
    "        print(\"Run faster\")\n",
    "\n",
    "peggy = Penguin()\n",
    "peggy.whoisThis()\n",
    "peggy.swim()\n",
    "peggy.run()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exaplanation**:\n",
    "\n",
    "In the above program, we created two classes i.e. **`Bird`** (parent class) and **`Penguin`** (child class). The child class inherits the functions of parent class. We can see this from the **`swim()`** method.\n",
    "\n",
    "Again, the child class modified the behavior of the parent class. We can see this from the **`whoisThis()`** method. Furthermore, we extend the functions of the parent class, by creating a new **`run()`** method.\n",
    "\n",
    "Additionally, we use the **`super()`** function inside the **`__init__()`** method. This allows us to run the **`__init__()`** method of the parent class inside the child class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-19T09:00:24.847816Z",
     "start_time": "2021-06-19T09:00:24.835121Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Parent class\n",
      "This is Child class\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Use of Inheritance in Python\n",
    "\n",
    "class ClassOne:              # Base class\n",
    "    def func1(self):\n",
    "        print('This is Parent class')\n",
    "\n",
    "class ClassTwo(ClassOne):    # Derived class\n",
    "    def func2(self):\n",
    "        print('This is Child class')\n",
    "\n",
    "obj = ClassTwo()\n",
    "obj.func1()\n",
    "obj.func2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exaplanation**:\n",
    "\n",
    "In the above program, we created two classes i.e. **`Bird`** (parent class) and **`Penguin`** (child class). The child class inherits the functions of parent class. We can see this from the **`swim()`** method.\n",
    "\n",
    "Again, the child class modified the behavior of the parent class. We can see this from the **`whoisThis()`** method. Furthermore, we extend the functions of the parent class, by creating a new **`run()`** method.\n",
    "\n",
    "Additionally, we use the **`super()`** function inside the **`__init__()`** method. This allows us to run the **`__init__()`** method of the parent class inside the child class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Key Points to Remember:\n",
    "* Object-Oriented Programming makes the program easy to understand as well as efficient.\n",
    "* Since the class is sharable, the code can be reused.\n",
    "* Data is safe and secure with data abstraction.\n",
    "* Polymorphism allows the same interface for different objects, so programmers can write efficient code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}