001_Python_OOPs_Concepts.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Object Class** lecture series by **[Dr. Milaan Parmar](https://www.linkedin.com/in/milaanparmar/)** 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",
    "We create class to create an object. A class is like an object constructor, or a \"blueprint\" for creating objects. We instantiate a class to create an object. The class defines attributes and the behavior of the object, while the object, on the other hand, represents the 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.\n",
    "\n",
    "```python\n",
    "class Person:\n",
    "    pass\n",
    "print(Person)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Person'>\n"
     ]
    }
   ],
   "source": [
    "# Creating a class\n",
    "\n",
    "class Person:\n",
    "    pass\n",
    "print(Person)"
   ]
  },
  {
   "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",
    "```python\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.\n",
    "\n",
    "```python\n",
    "p = Person()\n",
    "print(p)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Person object at 0x0000021E45765B20>\n"
     ]
    }
   ],
   "source": [
    "# Example 1: We can create an object by calling the class\n",
    "\n",
    "p = Person()\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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 2: 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": [
    "## Class Constructor\n",
    "\n",
    "In the examples above, we have created an object from the **`Person`** class. However, a class without a constructor is not really useful in real applications. Let us use constructor function to make our class more useful. Like the constructor function in Java or JavaScript, Python has also a built-in **`__init__()`** constructor function. The **`__init__()`** constructor function has **`self`** parameter which is a reference to the current instance of the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan\n",
      "<__main__.Person object at 0x0000021E45765DC0>\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "      def __init__ (self, name):\n",
    "        # self allows to attach parameter to the class\n",
    "          self.name =name\n",
    "\n",
    "p = Person('Milaan')\n",
    "print(p.name)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us add more parameters to the constructor function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan\n",
      "Parmar\n",
      "96\n",
      "England\n",
      "London\n"
     ]
    }
   ],
   "source": [
    "# Example 1: add more parameters to the constructor function.\n",
    "\n",
    "class Person:\n",
    "      def __init__(self, firstname, lastname, age, country, city):\n",
    "            self.firstname = firstname\n",
    "            self.lastname = lastname\n",
    "            self.age = age\n",
    "            self.country = country\n",
    "            self.city = city\n",
    "\n",
    "p = Person('Milaan', 'Parmar', 96, 'England', 'London')\n",
    "print(p.firstname)\n",
    "print(p.lastname)\n",
    "print(p.age)\n",
    "print(p.country)\n",
    "print(p.city)"
   ]
  },
  {
   "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": 6,
   "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": 7,
   "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": [
    "### Object Method\n",
    "\n",
    "Object Methods are functions defined inside the body of a class. They are used to define the behaviors of an object.\n",
    "\n",
    "Objects can have methods. The methods are functions which belong to the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan Parmar is 96 years old. He lives in London, England\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "class Person:\n",
    "      def __init__(self, firstname, lastname, age, country, city):\n",
    "            self.firstname = firstname\n",
    "            self.lastname = lastname\n",
    "            self.age = age\n",
    "            self.country = country\n",
    "            self.city = city\n",
    "      def person_info(self):\n",
    "        return f'{self.firstname} {self.lastname} is {self.age} years old. He lives in {self.city}, {self.country}'\n",
    "\n",
    "p = Person('Milaan', 'Parmar', 96, 'England', 'London')\n",
    "print(p.person_info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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 2: Creating Object 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": [
    "## Object Default Methods\n",
    "\n",
    "Sometimes, you may want to have a default values for your object methods. If we give default values for the parameters in the constructor, we can avoid errors when we call or instantiate our class without parameters. Let's see how it looks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan Parmar is 96 years old. He lives in London, England.\n",
      "Ben Doe is 30 years old. He lives in Tampere, Finland.\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "      def __init__(self, firstname='Milaan', lastname='Parmar', age=96, country='England', city='London'):\n",
    "            self.firstname = firstname\n",
    "            self.lastname = lastname\n",
    "            self.age = age\n",
    "            self.country = country\n",
    "            self.city = city\n",
    "\n",
    "      def person_info(self):\n",
    "        return f'{self.firstname} {self.lastname} is {self.age} years old. He lives in {self.city}, {self.country}.'\n",
    "\n",
    "p1 = Person()\n",
    "print(p1.person_info())\n",
    "p2 = Person('Ben', 'Doe', 30, 'Finland', 'Tampere')\n",
    "print(p2.person_info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Method to Modify Class Default Values\n",
    "\n",
    "In the example below, the **`Person`** class, all the constructor parameters have default values. In addition to that, we have skills parameter, which we can access using a method. Let us create **`add_skill`** method to add skills to the skills list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Milaan Parmar is 96 years old. He lives in London, England.\n",
      "Ben Doe is 30 years old. He lives in Tampere, Finland.\n",
      "['Python', 'MATLAB', 'R']\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "      def __init__(self, firstname='Milaan', lastname='Parmar', age=96, country='England', city='London'):\n",
    "            self.firstname = firstname\n",
    "            self.lastname = lastname\n",
    "            self.age = age\n",
    "            self.country = country\n",
    "            self.city = city\n",
    "            self.skills = []\n",
    "\n",
    "      def person_info(self):\n",
    "        return f'{self.firstname} {self.lastname} is {self.age} years old. He lives in {self.city}, {self.country}.'\n",
    "      def add_skill(self, skill):\n",
    "            self.skills.append(skill)\n",
    "\n",
    "p1 = Person()\n",
    "print(p1.person_info())\n",
    "p1.add_skill('Python')\n",
    "p1.add_skill('MATLAB')\n",
    "p1.add_skill('R')\n",
    "p2 = Person('Ben', 'Doe', 30, 'Finland', 'Tampere')\n",
    "print(p2.person_info())\n",
    "print(p1.skills)\n",
    "print(p2.skills)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance\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 an Object-oriented programming language, inheritance is an important aspect. Using inheritance we can reuse parent class code. Inheritance allows us to define a class that inherits all the methods and properties from parent class. The parent class or super or base class is the class which gives all the methods and properties. Child class is the class that inherits from another or parent 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",
    "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",
    "**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": 12,
   "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 1: 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": [
    "Let us create a student class by inheriting from **`Person`** class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arthur Curry is 33 years old. He lives in London, England.\n",
      "['HTML', 'CSS', 'JavaScript']\n",
      "Emily Carter is 28 years old. He lives in Manchester, England.\n",
      "['Organizing', 'Marketing', 'Digital Marketing']\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Use of Inheritance in Python\n",
    "\n",
    "class Student(Person):\n",
    "    pass\n",
    "\n",
    "s1 = Student('Arthur', 'Curry', 33, 'England', 'London')\n",
    "s2 = Student('Emily', 'Carter', 28, 'England', 'Manchester')\n",
    "print(s1.person_info())\n",
    "s1.add_skill('HTML')\n",
    "s1.add_skill('CSS')\n",
    "s1.add_skill('JavaScript')\n",
    "print(s1.skills)\n",
    "\n",
    "print(s2.person_info())\n",
    "s2.add_skill('Organizing')\n",
    "s2.add_skill('Marketing')\n",
    "s2.add_skill('Digital Marketing')\n",
    "print(s2.skills)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exaplanation:**\n",
    "\n",
    "We did not call the **`__init__()`** constructor in the child class. If we didn't call it then we can still access all the properties from the parent. But if we do call the constructor we can access the parent properties by calling **`super()`**.  \n",
    "We can add a new method to the child or we can override the parent class methods by creating the same method name in the child class. When we add the **`__init__()`** function, the child class will no longer inherit the parent's **`__init__()`** function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overriding parent method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arthur Curry is 33 years old. He lives in London, England.\n",
      "['HTML', 'CSS', 'JavaScript']\n",
      "Emily Carter is 28 years old. She lives in Manchester, England.\n",
      "['Organizing', 'Marketing', 'Digital Marketing']\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Overriding parent method from above example\n",
    "\n",
    "class Student(Person):\n",
    "    def __init__ (self, firstname='Milaan', lastname='Parmar',age=96, country='England', city='London', gender='male'):\n",
    "        self.gender = gender\n",
    "        super().__init__(firstname, lastname,age, country, city)\n",
    "        \n",
    "    def person_info(self):\n",
    "        gender = 'He' if self.gender =='male' else 'She'\n",
    "        return f'{self.firstname} {self.lastname} is {self.age} years old. {gender} lives in {self.city}, {self.country}.'\n",
    "\n",
    "s1 = Student('Arthur', 'Curry', 33, 'England', 'London','male')\n",
    "s2 = Student('Emily', 'Carter', 28, 'England', 'Manchester','female')\n",
    "print(s1.person_info())\n",
    "s1.add_skill('HTML')\n",
    "s1.add_skill('CSS')\n",
    "s1.add_skill('JavaScript')\n",
    "print(s1.skills)\n",
    "\n",
    "print(s2.person_info())\n",
    "s2.add_skill('Organizing')\n",
    "s2.add_skill('Marketing')\n",
    "s2.add_skill('Digital Marketing')\n",
    "print(s2.skills)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exaplanation**:\n",
    "\n",
    "We can use **`super()`** built-in function or the parent name Person to automatically inherit the methods and properties from its parent. In the example above we override the parent method. The child method has a different feature, it can identify, if the gender is male or female and assign the proper pronoun(He/She)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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 3: Use of Inheritance in Python\n",
    "\n",
    "# parent class\n",
    "class Bird:   \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",
    "    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": "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": 16,
   "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": 17,
   "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-17-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": 18,
   "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",
    "    def fly(self):\n",
    "        print(\"Parrot can fly\")\n",
    "    \n",
    "    def swim(self):\n",
    "        print(\"Parrot can't swim\")\n",
    "\n",
    "class Penguin:\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": 19,
   "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()   # Output Area of circle: 254.34\n",
    "\n",
    "rect.calculate_area()  # 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": [
    "## 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": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>Objects and Classes</span>\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 1</span>\n",
    "\n",
    "1. Python has the module called **`statistics`** and we can use this module to do all the statistical calculations. However, to learn how to make function and reuse function let us try to develop a program, which calculates the measure of central tendency of a sample (**`mean`**, **`median`**, **`mode`**) and measure of variability (**`range`**, **`variance`**, **`standard deviation`**). In addition to those measures, find the **`min`**, **`max`**, **`count`**, **`percentile`**, and **`frequency distribution`** of the sample. You can create a class called **`statistics`** and create all the functions that do statistical calculations as methods for the **`statistics`** class. Check the output below.\n",
    "\n",
    "    - ```python\n",
    "ages = [31, 26, 34, 37, 27, 26, 32, 32, 26, 27, 27, 24, 32, 33, 27, 25, 26, 38, 37, 31, 34, 24, 33, 29, 26]\n",
    "print('Count:', data.count()) # 25\n",
    "print('Sum: ', data.sum()) # 744\n",
    "print('Min: ', data.min()) # 24\n",
    "print('Max: ', data.max()) # 38\n",
    "print('Range: ', data.range() # 14\n",
    "print('Mean: ', data.mean()) # 30\n",
    "print('Median: ', data.median()) # 29\n",
    "print('Mode: ', data.mode()) # {'mode': 26, 'count': 5}\n",
    "print('Standard Deviation: ', data.std()) # 4.2\n",
    "print('Variance: ', data.var()) # 17.5\n",
    "print('Frequency Distribution: ', data.freq_dist()) # [(20.0, 26), (16.0, 27), (12.0, 32), (8.0, 37), (8.0, 34), (8.0, 33), (8.0, 31), (8.0, 24), (4.0, 38), (4.0, 29), (4.0, 25)]\n",
    "    ```\n",
    "\n",
    "    -```sh\n",
    "# you output should look like this:\n",
    "print(data.describe())\n",
    "Count: 25\n",
    "Sum:  744\n",
    "Min:  24\n",
    "Max:  38\n",
    "Range:  14\n",
    "Mean:  30\n",
    "Median:  29\n",
    "Mode:  (26, 5)\n",
    "Variance:  17.5\n",
    "Standard Deviation:  4.2\n",
    "Frequency Distribution: [(20.0, 26), (16.0, 27), (12.0, 32), (8.0, 37), (8.0, 34), (8.0, 33), (8.0, 31), (8.0, 24), (4.0, 38), (4.0, 29), (4.0, 25)]\n",
    "    ``` \n",
    "\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 2</span>\n",
    "\n",
    "1. Create a class called **`PersonAccount`**. It has **`firstname`**, **`lastname`**, **`incomes`**, **`expenses`** properties and it has **`total_income`**, **`total_expense`**, **`account_info`**, **`add_income`**, **`add_expense`** and **`account_balance`** methods. Incomes is a set of incomes and its description. The same goes for expenses."
   ]
  },
  {
   "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
}