Part - 4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "760c9ea0",
   "metadata": {},
   "source": [
    "# Object Oriented Programming System (OOPs)\n",
    "\n",
    "In Python, object-oriented Programming (OOPs) is a programming paradigm that uses objects and classes in programming. It aims to implement real-world entities like inheritance, polymorphisms, encapsulation, etc. in the programming. The main concept of OOPs is to bind the data and the functions that work on that together as a single unit so that no other part of the code can access this data.\n",
    "\n",
    "Main Concepts of Object-Oriented Programming (OOPs) \n",
    "1. Class and Objects\n",
    "2. Encapsulation\n",
    "3. Abstraction\n",
    "4. Inheritance\n",
    "5. Polymorphism\n",
    "\n",
    "Python is an object oriented programming language like Java, it does not force the programmers to write program in complete object oriented way. Unlike Java. Python has a blend of both the object oriented and procedure oriented features. Hence, Python programmers can write programs using procedure oriented approach (like C) or object oriented (like Java) depending on their requirements. This is definitely an advantage for Python programmers!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa941b67",
   "metadata": {},
   "source": [
    "## What is Object:\n",
    "- The things which are physically present in this whole world are basically known as objects.For example, Table, Person, Laptop, Car etc.\n",
    "- And something doesn't really exist, So it's not an objects. For example, our thoughts, imagination, plans, ideas etc. are not objects because they do not exist physically.\n",
    "- Every object has some behavior. The behavior of an object is represented by attributes and actions.\n",
    "Pysical existence of a class is nothing but object. We can create any number of objects for a class.\n",
    "\n",
    " \n",
    "\n",
    "    Syntax to create object: referencevariable = classname()\n",
    "    Example: s = Student()\n",
    "    \n",
    "![](images\\classes-objects.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "644ef4c2",
   "metadata": {},
   "source": [
    "### What is Class: \n",
    "In Python every thing is an object. To create objects we required some Model or Plan or Blue print, which is nothing but class.\n",
    "- We can write a class to represent properties (attributes) and actions (behaviour) of object.\n",
    "- Properties can be represented by variables\n",
    "- Actions can be represented by Methods.\n",
    "- Hence class contains both variables and method\n",
    "- Class is a collection of attributes and methods.\n",
    "- Class is a collection of objects.\n",
    "- Technically, class is a user-defined datatype.\n",
    "\n",
    "### How to Define a class?\n",
    "We can define a class by using class keyword. \n",
    "\n",
    "    class ClassName:\n",
    "        # Statement\n",
    "        \n",
    "    obj = ClassName()\n",
    "        print(obj.atrr)\n",
    "        \n",
    "    ------------------------------------\n",
    "    \n",
    "    Syntax:\n",
    "    \n",
    "    class className:\n",
    "       #attributes\n",
    "       #methods\n",
    "       \n",
    "         obj1 = Class_name([args])\n",
    "         obj2 = Class_name([args])\n",
    "         \n",
    "     variables:instance variables,static and local variables\n",
    "     methods: instance methods,static methods,class methods\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b1c14445",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Email'>\n"
     ]
    }
   ],
   "source": [
    "# Example\n",
    "class Email:     # class\n",
    "    pass\n",
    "\n",
    "e1 = Email()     # Object\n",
    "e2 = Email()\n",
    "\n",
    "print(type(e1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09a5a246",
   "metadata": {},
   "source": [
    "#### Some points on Python class and objects:  \n",
    "\n",
    "- Classes are created by keyword class.\n",
    "- Attributes are the variables that belong to a class.\n",
    "- Attributes are always public and can be accessed using the dot (.) operator. Eg.: Myclass.Myattribute\n",
    "- State: It is represented by the attributes of an object. It also reflects the properties of an object.\n",
    "- Behaviour: It is represented by the methods of an object. It also reflects the response of an object to other objects.\n",
    "- Identity: It gives a unique name to an object and enables one object to interact with other objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5680e1af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Nikhil', 'salary': 44000}\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    def __init__(self,nm,sl):\n",
    "        self.name = nm\n",
    "        self.salary = sl\n",
    "        \n",
    "    def display():\n",
    "        print(self.name)\n",
    "        \n",
    "e1 = Employee(\"Nikhil\",44000)\n",
    "e2 = Employee(\"Prakriti\",89000)\n",
    "print(e1.__dict__)  # __dict__ its a special attributes which is uswd to seen the content of the object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4998300d",
   "metadata": {},
   "source": [
    "Documentation string represents description of the class. Within the class doc string is always optional. We can get doc string by using the following 2 ways.\n",
    "        \n",
    "        1. print(classname.__doc__)\n",
    "        2. help(classname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1d969987",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is employee class with required data\n",
      "Help on class Employee in module __main__:\n",
      "\n",
      "class Employee(builtins.object)\n",
      " |  This is employee class with required data\n",
      " |  \n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    '''This is employee class with required data'''\n",
    "print(Employee.__doc__)\n",
    "# Or\n",
    "help(Employee)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c630279",
   "metadata": {},
   "source": [
    "Within the Python class we can represent data by using variables. \n",
    "\n",
    "\n",
    "There are 3 types of variables are allowed. \n",
    "1. Instance Variables (Object Level Variables)\n",
    "2. Static Variables (Class Level Variables)\n",
    "3. Local variables (Method Level Variables)\n",
    "\n",
    "Within the Python class, we can represent operations by using methods. The following are various types of allowed methods\n",
    "1. Instance Methods\n",
    "2. Class Methods \n",
    "3. Static Methods\n",
    "\n",
    "#### Rules\n",
    "- Class have only two things that is Data and Functions and these things are access by Class's Object\n",
    "- One method can't access other method. Only object access so we need to use self name for access the other method self is nothing but its a object and they have same id\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "625e977d",
   "metadata": {},
   "source": [
    "## What is Reference Variable:\n",
    "The variable which can be used to refer object is called reference variable.\n",
    "\n",
    "By using reference variable, we can access properties and methods of object.\n",
    "\n",
    "#### Declaring an object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b11ff0a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    pass\n",
    "\n",
    "# Example: Creating an object\n",
    "obj = Person()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "016f04ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nikhil\n",
      "I'm a Nikhil\n",
      "I'm a Prakriti\n"
     ]
    }
   ],
   "source": [
    "# Class\n",
    "class Person:    \n",
    "    \n",
    "    # Attribute\n",
    "    attr1 = \"Nikhil\"\n",
    "    attr2 = \"Prakriti\"\n",
    " \n",
    "    # Action\n",
    "    def show_name(self):\n",
    "        print(\"I'm a\", self.attr1)\n",
    "        print(\"I'm a\", self.attr2)\n",
    " \n",
    " \n",
    "# Driver code\n",
    "\n",
    "# Object instantiation\n",
    "user = Person()\n",
    " \n",
    "# Accessing class attributes and methods through objects\n",
    "print(user.attr1)\n",
    "user.show_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2a6d3610",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee name Nikhil has experience of 1 year as Data Scientist\n"
     ]
    }
   ],
   "source": [
    "class Employee():\n",
    "    name = \"Nikhil\"\n",
    "    exp = 1\n",
    "    profile = \"Data Scientist\"\n",
    "    \n",
    "    def show(self):\n",
    "        print(f\"Employee name {self.name} has experience of {self.exp} year as {self.profile}\")\n",
    "              \n",
    "emp = Employee()\n",
    "emp.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4127c6d",
   "metadata": {},
   "source": [
    "## Self variable:\n",
    "'self' is a defult variable that contains the memory address of the instance of the current class. So, we can use 'self' to refer all the instance variables and instance methods and self always pointing to current object (like this keyword in Java).\n",
    "\n",
    "\n",
    "When an instance to the class is creted the instance name contains the memory loaction of the instance. This memory loaction is \n",
    "internally passes to 'self'. For example, we create an instance to Student class as:\n",
    "\n",
    "    s1 = Student()\n",
    "\n",
    "- Class methods must have an extra first parameter in the method definition. We do not give a value for this parameter when we call the method, Python provides it.\n",
    "- If we have a method that takes no arguments, we still have one argument.\n",
    "\n",
    "\n",
    "\n",
    "When we call a method of this object as myobject.method(arg1, arg2), this is automatically converted by Python into MyClass.method(myobject, arg1, arg2) – this is all the special self is about.\n",
    "\n",
    "\n",
    "__Note:__\n",
    "1. self should be first parameter inside constructor \n",
    "         \n",
    "         def __init__(self):\n",
    "2. self should be first parameter inside instance methods\n",
    "         \n",
    "         def talk(self):\n",
    "\n",
    "## Constructor Concept:\n",
    "\n",
    "- Constructor is a special method in python.\n",
    "- The name of the constructor should be \n",
    "    \n",
    "        __init__(self)\n",
    "- Constructor will be executed automatically at the time of object creation.\n",
    "- The main purpose of constructor is to declare and initialize instance variables.\n",
    "- Per object constructor will be exeucted only once.\n",
    "- Constructor can take atleast one argument(atleast self)\n",
    "- Constructor is optional and if we are not providing any constructor then python will provide default constructor.\n",
    "\n",
    "        Syntax of constructor declaration : \n",
    "\n",
    "                    def __init__(self):\n",
    "                        # body of the constructor\n",
    "\n",
    "        Example:\n",
    "        def __init__(self,name,rollno,marks): \n",
    "            self.name=name \n",
    "            self.rollno=rollno \n",
    "            self.marks=marks\n",
    "            \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b68ce70",
   "metadata": {},
   "source": [
    "### Program to demonistrate constructor will execute only once per object:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2cea0dfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor exeuction...\n",
      "Constructor exeuction...\n",
      "Constructor exeuction...\n",
      "Method execution...\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    \n",
    "    def __init__(self): \n",
    "        print(\"Constructor exeuction...\")\n",
    "        \n",
    "    def m1(self): \n",
    "        print(\"Method execution...\") \n",
    "        \n",
    "t1=Test() \n",
    "t2=Test() \n",
    "t3=Test() \n",
    "t1.m1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ff4eda3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is Nikhil\n"
     ]
    }
   ],
   "source": [
    "# Sample class with init method\n",
    "class Person:\n",
    " \n",
    "    # init method or constructor\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    " \n",
    "    # Sample Method\n",
    "    def say_hi(self):\n",
    "        print('Hello, my name is', self.name)\n",
    " \n",
    " \n",
    "p = Person('Nikhil')\n",
    "p.say_hi()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45f6c8ba",
   "metadata": {},
   "source": [
    "### Differences between Methods and Constructors:\n",
    "#### Method \n",
    "1. Name of method can be any name \n",
    "2. Method will be executed if we call that method the time of object creation.\n",
    "3. Per object, method can be called any number of times.\n",
    "4. Inside method we can write business logic \n",
    "\n",
    "#### Constructor\n",
    "1. Constructor name should be always __init__\n",
    "2. Constructor will be executed automatically at \n",
    "the time of object creation.\n",
    "3. Per object, Constructor will be executed only once\n",
    "4. Inside Constructor we have to declare and initialize instance variables\n",
    "\n",
    "### Types of constructor\n",
    "1. Parameterized Constractor\n",
    "        \n",
    "        def __init__(self,name,salary):\n",
    "2. Non-Parameterized Constractor\n",
    "\n",
    "        def __init__(self):\n",
    "\n",
    "3. Default Constructor\n",
    "\n",
    "        class Employee:\n",
    "            pass\n",
    "            \n",
    "      \n",
    "### How to access class members\n",
    "Class members:- Attributes(variables)+Actions(Methods)\n",
    "We can assess these variables using object outside the class\n",
    "\n",
    "    Syntax: \n",
    "        Accessing attributes:- object_name.variable_name\n",
    "        Accessing method:- object_name.method_name()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "39c466b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nikhil\n",
      "Prakriti 19\n",
      "Chunmun\n",
      "salary is Chunmun and age is 19\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "class Employee:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    def display(self):\n",
    "        print(f\"salary is {self.name} and age is {self.age}\")\n",
    "        \n",
    "e1 = Employee(\"Nikhil\",22)\n",
    "e2 = Employee(\"Prakriti\",19)\n",
    "\n",
    "print(e1.name)\n",
    "print(e2.name, e2.age)\n",
    "e2.name = \"Chunmun\"\n",
    "print(e2.name)\n",
    " \n",
    "e2.display()     # e2 memory location goes to self in display and all process same again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "158df7b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Nikhil Yadav\n",
      "Enter your experience: 1\n",
      "Enter your profile: Data Scientist\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Employee name Nikhil Yadav has experience of 1 year as Data Scientist'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Employee():\n",
    "    def __init__(self,name,exp,profile):\n",
    "        self.name = name\n",
    "        self.exp = exp\n",
    "        self.profile = profile\n",
    "        \n",
    "    def display(self):\n",
    "        return f\"Employee name {self.name} has experience of {self.exp} year as {self.profile}\"\n",
    "\n",
    "name = input(\"Enter your name: \")\n",
    "exp = int(input(\"Enter your experience: \"))\n",
    "profile = input(\"Enter your profile: \")\n",
    "emp_data = Employee(name,exp,profile)\n",
    "emp_data.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ba44327",
   "metadata": {},
   "source": [
    "## Destructors:\n",
    "Destructor is a special method and the name should be __del__\n",
    "Just before destroying an object Garbage Collector always calls destructor to perform clean up \n",
    "activities (Resource deallocation activities like close database connection etc).\n",
    "Once destructor execution completed then Garbage Collector automatically destroys that object.\n",
    "\n",
    "    Syntax of destructor declaration : \n",
    "    \n",
    "            def __del__(self):\n",
    "               # body of destructor\n",
    "\n",
    "___Note: The job of destructor is not to destroy object and it is just to perform clean up activities.___\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ae4b530c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object Initialization...\n",
      "Fulfilling Last Wish and performing clean up activities...\n",
      "End of application\n"
     ]
    }
   ],
   "source": [
    "import time \n",
    "class Test: \n",
    "    def __init__(self): \n",
    "        print(\"Object Initialization...\") \n",
    "    def __del__(self): \n",
    "        print(\"Fulfilling Last Wish and performing clean up activities...\") \n",
    "\n",
    "t1=Test() \n",
    "t1=None \n",
    "time.sleep(5) \n",
    "print(\"End of application\") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b3518d6",
   "metadata": {},
   "source": [
    "___Note:\n",
    "If the object does not contain any reference variable then only it is eligible fo GC. ie if the \n",
    "reference count is zero then only object eligible for GC___\n",
    "#### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5d9d6b74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor Execution...\n",
      "object not yet destroyed after deleting t1\n",
      "object not yet destroyed even after deleting t2\n",
      "I am trying to delete last reference variable...\n",
      "Destructor Execution...\n"
     ]
    }
   ],
   "source": [
    "import time \n",
    "class Test: \n",
    "    def __init__(self): \n",
    "        print(\"Constructor Execution...\") \n",
    "    def __del__(self): \n",
    "        print(\"Destructor Execution...\") \n",
    "\n",
    "t1=Test() \n",
    "t2=t1 \n",
    "t3=t2 \n",
    "\n",
    "del t1 \n",
    "time.sleep(5) \n",
    "print(\"object not yet destroyed after deleting t1\")\n",
    "\n",
    "del t2 \n",
    "time.sleep(5) \n",
    "print(\"object not yet destroyed even after deleting t2\") \n",
    "print(\"I am trying to delete last reference variable...\") \n",
    "\n",
    "del t3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "88acc22b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Constructor Execution...\n",
      "Constructor Execution...\n",
      "Constructor Execution...\n",
      "Destructor Execution...\n",
      "Destructor Execution...\n",
      "Destructor Execution...\n",
      "End of application\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "import time \n",
    "class Test: \n",
    "    def __init__(self): \n",
    "        print(\"Constructor Execution...\") \n",
    "    def __del__(self):    # __del__ method is known as destructor\n",
    "        print(\"Destructor Execution...\") \n",
    "\n",
    "list=[Test(),Test(),Test()] \n",
    "del list \n",
    "time.sleep(5) \n",
    "print(\"End of application\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c6c65c9",
   "metadata": {},
   "source": [
    "# Types of Variables:\n",
    "Inside Python class 3 types of variables are allowed.\n",
    "1. Instance Variables (Object Level Variables)\n",
    "2. Static Variables (Class Level Variables)\n",
    "3. Local variables (Method Level Variables)\n",
    "\n",
    "## Instance Variables:\n",
    "\n",
    "If the value of a variable is varied from object to object, then such type of variables are called instance variables.\n",
    "- Variables made for particular instance.\n",
    "- Seprate copy is created for every objects.\n",
    "- Values of variables differs from object to object.\n",
    "- Modification in one object won't effect other objects.\n",
    "\n",
    "For every object a separate copy of instance variables will be created.\n",
    "##### Where we can declare Instance variables:\n",
    "1. Inside Constructor by using self variable\n",
    "2. Inside Instance Method by using self variable\n",
    "3. Outside of the class by using object reference variable\n",
    "\n",
    "\n",
    "### 1. Inside Constructor by using self variable:\n",
    "We can declare instance variables inside a constructor by using self keyword. Once we creates \n",
    "object, automatically these variables will be added to the object\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fe3f744e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'eno': 405, 'ename': 'Nikhil', 'esal': 10000}\n"
     ]
    }
   ],
   "source": [
    "class Employee: \n",
    "\n",
    "    def __init__(self): \n",
    "        self.eno = 405\n",
    "        self.ename = 'Nikhil' \n",
    "        self.esal = 10000 \n",
    "\n",
    "e=Employee() \n",
    "print(e.__dict__) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "aa59753e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student: \n",
    "\n",
    "    def __init__(self,name,grade): \n",
    "        self.name=name \n",
    "        self.grade=grade \n",
    "        \n",
    "s1=Student(\"Nikhil\",89) \n",
    "s2=Student(\"Prakriti\",99)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "abf123b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Nikhil', 'grade': 89}\n",
      "{'name': 'Prakriti', 'grade': 99}\n"
     ]
    }
   ],
   "source": [
    "# 2 Different memory location for 4 variables\n",
    "print(s1.__dict__) \n",
    "print(s2.__dict__) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1c851c7",
   "metadata": {},
   "source": [
    "### 2. Inside Instance Method by using self variable:\n",
    "We can also declare instance variables inside instance method by using self variable. If any \n",
    "instance variable declared inside instance method, that instance variable will be added once we \n",
    "call that method.\n",
    " \n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "53ffc0cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 10, 'b': 20, 'c': 30}\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "\n",
    "    def __init__(self): \n",
    "        self.a=10 \n",
    "        self.b=20 \n",
    "        \n",
    "    def m1(self): \n",
    "        self.c=30 \n",
    "        \n",
    "t=Test() \n",
    "t.m1() \n",
    "print(t.__dict__) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55abc15f",
   "metadata": {},
   "source": [
    "### 3. Outside of the class by using object reference variable:\n",
    "We can also add instance variables outside of a class to a particular object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5561be4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 10, 'b': 20, 'c': 30, 'd': 40}\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "        \n",
    "    def __init__(self): \n",
    "        self.a=10 \n",
    "        self.b=20 \n",
    "        \n",
    "    def m1(self): \n",
    "        self.c=30 \n",
    "        \n",
    "t=Test() \n",
    "t.m1() \n",
    "t.d=40 \n",
    "print(t.__dict__) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b87bb075",
   "metadata": {},
   "source": [
    "### How to access Instance variables:\n",
    "We can access instance variables with in the class by using 'self' variable and outside of the class by \n",
    "using object reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d7e02cfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "10 20\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "        \n",
    "    def __init__(self): \n",
    "        self.a=10 \n",
    "        self.b=20 \n",
    "        \n",
    "    def display(self): \n",
    "        print(self.a) \n",
    "        print(self.b) \n",
    "\n",
    "t=Test() \n",
    "t.display() \n",
    "print(t.a,t.b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "083e4acc",
   "metadata": {},
   "source": [
    "### How to delete instance variable from the object:\n",
    "1. Within a class we can delete instance variable as follows\n",
    "     \n",
    "         del self.variableName\n",
    "2. From outside of class we can delete instance variables as follows\n",
    " \n",
    "         del objectreference.variableName\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "95ce685e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 10, 'b': 20, 'c': 30, 'd': 40}\n",
      "{'a': 10, 'b': 20, 'c': 30}\n",
      "{'a': 10, 'b': 20}\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    def __init__(self): \n",
    "        self.a=10 \n",
    "        self.b=20 \n",
    "        self.c=30 \n",
    "        self.d=40 \n",
    "        \n",
    "    def m1(self): \n",
    "        del self.d \n",
    "        \n",
    "t=Test() \n",
    "print(t.__dict__)\n",
    "t.m1() \n",
    "print(t.__dict__) \n",
    "del t.c \n",
    "print(t.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5b6fad9",
   "metadata": {},
   "source": [
    "___Note: The instance variables which are deleted from one object,will not be deleted from other \n",
    "objects.___\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5b129440",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b': 20, 'c': 30, 'd': 40}\n",
      "{'a': 10, 'b': 20, 'c': 30, 'd': 40}\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    def __init__(self): \n",
    "        self.a=10 \n",
    "        self.b=20 \n",
    "        self.c=30 \n",
    "        self.d=40 \n",
    "        \n",
    "t1=Test() \n",
    "t2=Test() \n",
    "\n",
    "del t1.a \n",
    "print(t1.__dict__) \n",
    "print(t2.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d837dc64",
   "metadata": {},
   "source": [
    "If we change the values of instance variables of one object then those changes won't be reflected \n",
    "to the remaining objects, because for every object we are separate copy of instance variables are \n",
    "available.\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "59ccb83f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t1: 888 999\n",
      "t2: 10 20\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    def __init__(self): \n",
    "        self.a=10 \n",
    "        self.b=20 \n",
    "        \n",
    "t1=Test() \n",
    "t1.a=888 \n",
    "t1.b=999 \n",
    "t2=Test() \n",
    "\n",
    "print('t1:',t1.a,t1.b)\n",
    "print('t2:',t2.a,t2.b) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bdb9cca",
   "metadata": {},
   "source": [
    "## Static variables or Class variable:\n",
    "If the value of a variable is not varied from object to object, such type of variables we have to \n",
    "declare with in the class directly but outside of methods. Such type of variables are called Static \n",
    "variables.\n",
    "\n",
    "For total class only one copy of static variable will be created and shared by all objects of that \n",
    "class.\n",
    "\n",
    "We can access static variables either by class name or by object reference. But recommended to \n",
    "use class name.\n",
    "\n",
    "- Variable made for entire class (All Objects)\n",
    "- Only one copy is created and distributed to all objects.\n",
    "- Modification in class variable impact on all objects.\n",
    "\n",
    "\n",
    "### Instance Variable vs Static Variable:\n",
    "Note: In the case of instance variables for every object a seperate copy will be created,but in the \n",
    "case of static variables for total class only one copy will be created and shared by every object of \n",
    "that class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "29a2a2d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t1: 10 20\n",
      "t2: 10 20\n",
      "t1: 888 999\n",
      "t2: 888 20\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "class Test: \n",
    "    x=10     # class variable\n",
    "    def __init__(self): \n",
    "        self.y=20 \n",
    "    \n",
    "t1=Test() \n",
    "t2=Test() \n",
    "print('t1:',t1.x,t1.y) \n",
    "print('t2:',t2.x,t2.y) \n",
    "Test.x=888 \n",
    "t1.y=999 \n",
    "print('t1:',t1.x,t1.y) \n",
    "print('t2:',t2.x,t2.y)   # Only one copy of the variable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "900735f4",
   "metadata": {},
   "source": [
    "### Various places to declare static variables:\n",
    "1. In general we can declare within the class directly but from out side of any method\n",
    "2. Inside constructor by using class name\n",
    "3. Inside instance method by using class name\n",
    "4. Inside classmethod by using either class name or cls variable\n",
    "5. Inside static method by using class name"
   ]
  },
  {
   "cell_type": "raw",
   "id": "b7d4a744",
   "metadata": {},
   "source": [
    "class Test: \n",
    "    a=10 \n",
    "    def __init__(self): \n",
    "        Test.b=20 \n",
    "    def m1(self): \n",
    "        Test.c=30 \n",
    "    @classmethod     # builten Decorator\n",
    "    def m2(cls):      # cls used for class refrence like self used for object\n",
    "        cls.d1=40 \n",
    "        Test.d2=400 \n",
    "    @staticmethod \n",
    "    def m3(): \n",
    "        Test.e=50 \n",
    "print(Test.__dict__) \n",
    "t=Test() \n",
    "print(Test.__dict__) \n",
    "t.m1() \n",
    "print(Test.__dict__) \n",
    "Test.m2() \n",
    "print(Test.__dict__) \n",
    "Test.m3() \n",
    "print(Test.__dict__) \n",
    "Test.f=60 \n",
    "print(Test.__dict__) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "505eb35a",
   "metadata": {},
   "source": [
    "### How to access static variables:\n",
    "1. inside constructor: by using either self or classname\n",
    "2. inside instance method: by using either self or classname\n",
    "3. inside class method: by using either cls variable or classname\n",
    "4. inside static method: by using classname\n",
    "5. From outside of class: by using either object reference or classnmae"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f574b4f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    a=10 \n",
    "    def __init__(self): \n",
    "        print(self.a) \n",
    "        print(Test.a) \n",
    "    def m1(self): \n",
    "        print(self.a) \n",
    "        print(Test.a) \n",
    "        \n",
    "    @classmethod \n",
    "    def m2(cls): \n",
    "        print(cls.a) \n",
    "        print(Test.a) \n",
    "        \n",
    "    @staticmethod \n",
    "    def m3(): \n",
    "        print(Test.a) \n",
    "t=Test() \n",
    "print(Test.a) \n",
    "print(t.a) \n",
    "t.m1() \n",
    "t.m2() \n",
    "t.m3() "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0900d3a",
   "metadata": {},
   "source": [
    "### Where we can modify the value of static variable:\n",
    "Anywhere either with in the class or outside of class we can modify by using classname.\n",
    "But inside class method, by using cls variable.\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "17e1cce4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "777\n",
      "888\n",
      "999\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    a=777 \n",
    "    @classmethod \n",
    "    def m1(cls): \n",
    "        cls.a=888 \n",
    "    @staticmethod \n",
    "    def m2(): \n",
    "        Test.a=999\n",
    "print(Test.a) \n",
    "Test.m1() \n",
    "print(Test.a) \n",
    "Test.m2() \n",
    "print(Test.a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9505400a",
   "metadata": {},
   "source": [
    "#### If we change the value of static variable by using either self or object reference variable:\n",
    "If we change the value of static variable by using either self or object reference variable, then the \n",
    "value of static variable won't be changed,just a new instance variable with that name will be \n",
    "added to that particular object.\n",
    "#### Example 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4a68d95e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "888\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    a=10 \n",
    "    def m1(self): \n",
    "        self.a=888 \n",
    "t1=Test() \n",
    "t1.m1() \n",
    "print(Test.a) \n",
    "print(t1.a) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22ad23a4",
   "metadata": {},
   "source": [
    "### How to delete static variables of a class:\n",
    "We can delete static variables from anywhere by using the following syntax\n",
    "            \n",
    "            del classname.variablename\n",
    "But inside classmethod we can also use cls variable\n",
    "            \n",
    "            del cls.variablename\n",
    "\n",
    "___Note: By using object reference variable/self we can read static variables, but we cannot modify \n",
    "or delete.___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "75764560",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', 'm1': <classmethod object at 0x0000025F157121C0>, '__dict__': <attribute '__dict__' of 'Test' objects>, '__weakref__': <attribute '__weakref__' of 'Test' objects>, '__doc__': None}\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    a=10 \n",
    "    \n",
    "    @classmethod \n",
    "    def m1(cls): \n",
    "        del cls.a \n",
    "Test.m1() \n",
    "print(Test.__dict__) "
   ]
  },
  {
   "cell_type": "raw",
   "id": "2d711d53",
   "metadata": {},
   "source": [
    "If we are trying to delete then we will get error.\n",
    "Example:\n",
    "class Test: \n",
    "    a = 10 \n",
    "\n",
    "t1=Test() \n",
    "del t1.a ===>AttributeError: a "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eac0b770",
   "metadata": {},
   "source": [
    "We can modify or delete static variables only by using classname or cls variable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd6fef11",
   "metadata": {},
   "source": [
    "## Local variables or Method Variables:\n",
    "Sometimes to meet temporary requirements of programmer,we can declare variables inside a \n",
    "method directly,such type of variables are called local variable or temporary variables.\n",
    "\n",
    "Local variables will be created at the time of method execution and destroyed once method \n",
    "completes.\n",
    "\n",
    "Local variables of a method cannot be accessed from outside of method.\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "38fc1bd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "2000\n"
     ]
    }
   ],
   "source": [
    "class Test: \n",
    "    def m1(self): \n",
    "        a=1000 \n",
    "        print(a) \n",
    "    def m2(self): \n",
    "        a=2000 \n",
    "        print(a) \n",
    "t=Test() \n",
    "t.m1() \n",
    "t.m2()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "3ee40e1f",
   "metadata": {},
   "source": [
    "# Example 2: \n",
    "class Test: \n",
    "        def m1(self): \n",
    "    a=1000 \n",
    "        print(a) \n",
    "    def m2(self): \n",
    "        b=2000 \n",
    "        print(a) #NameError: name 'a' is not defined \n",
    "        print(b) \n",
    "t=Test() \n",
    "t.m1() \n",
    "t.m2("
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79c990bf",
   "metadata": {},
   "source": [
    "# Types of Methods:\n",
    "Inside Python class 3 types of methods are allowed\n",
    "1. Instance Methods\n",
    "2. Class Methods\n",
    "3. Static Methods\n",
    "\n",
    "\n",
    "## Instance Methods:\n",
    "Inside method implementation if we are using instance variables then such type of methods are \n",
    "called instance methods. \n",
    "\n",
    "Inside instance method declaration,we have to pass self variable.\n",
    "         \n",
    "         def m1(self):\n",
    "         \n",
    "By using self variable inside method we can able to access instance variables.\n",
    "\n",
    "Within the class we can call instance method by using self variable and from outside of the class we can call by using object reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8eb9bbfa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of the students: 2\n",
      "Enter the name: Nikhil Yadav\n",
      "Enter marks: 85\n",
      "Hii, Nikhil Yadav\n",
      "Your marks is:  85\n",
      "You got First Grade\n",
      "\n",
      "Enter the name: Prakriti Yadav\n",
      "Enter marks: 100\n",
      "Hii, Prakriti Yadav\n",
      "Your marks is:  100\n",
      "You got First Grade\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self,name,marks):\n",
    "        self.name = name\n",
    "        self.marks = marks\n",
    "        \n",
    "    def display(self):\n",
    "        print(\"Hii,\",self.name)\n",
    "        print(\"Your marks is: \",self.marks)\n",
    "    def grade(self):\n",
    "        if self.marks>=60:\n",
    "            print(\"You got First Grade\")\n",
    "        elif self.marks>=50:\n",
    "            print(\"You got Second Grade\")\n",
    "        elif self.marks>=35:\n",
    "            print(\"You got Third Grade\")\n",
    "            \n",
    "        else:\n",
    "            print(\"You Failed\")\n",
    "            \n",
    "n = int(input(\"Enter number of the students: \"))\n",
    "for i in range(n):\n",
    "    name = input('Enter the name: ')\n",
    "    marks = int(input(\"Enter marks: \"))\n",
    "    s = Student(name,marks)\n",
    "    s.display()\n",
    "    s.grade()\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc0e47fb",
   "metadata": {},
   "source": [
    "### Setter and Getter Methods:\n",
    "We can set and get the values of instance variables by using getter and setter methods.\n",
    "### Setter Method:\n",
    "setter methods can be used to set values to the instance variables. setter methods also known as \n",
    "mutator methods.\n",
    "#### syntax:\n",
    "       def setVariable(self,variable):\n",
    "          self.variable=variable\n",
    "#### Example:\n",
    "    def setName(self,name):\n",
    "     self.name=name\n",
    "### Getter Method:\n",
    "Getter methods can be used to get values of the instance variables. Getter methods also known as \n",
    "accessor methods.\n",
    "#### syntax:\n",
    "    def getVariable(self):\n",
    "     return self.variable\n",
    " \n",
    "#### Example:\n",
    "    def getName(self):\n",
    "     return self.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "df55f54b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter number of students: 2\n",
      "Enter the name: Nikhil Yadav\n",
      "Enter Marks: 95\n",
      "Hii Nikhil Yadav\n",
      "Your Marks is:  95\n",
      "Enter the name: Prakriti Yadav\n",
      "Enter Marks: 99\n",
      "Hii Prakriti Yadav\n",
      "Your Marks is:  99\n"
     ]
    }
   ],
   "source": [
    "class Student():\n",
    "    def setName(self,name):   #setter method\n",
    "        self.name = name\n",
    "        \n",
    "    def getName(self):      #getter method\n",
    "        return self.name\n",
    "    \n",
    "    def setMarks(self,marks):\n",
    "        self.marks=marks\n",
    "        \n",
    "    def getMarks(self):\n",
    "        return self.marks\n",
    "    \n",
    "n = int(input(\"Enter number of students: \"))\n",
    "for i in range(n):\n",
    "    s = Student()\n",
    "    \n",
    "    name = input(\"Enter the name: \")\n",
    "    s.setName(name)\n",
    "    \n",
    "    marks=int(input(\"Enter Marks: \"))\n",
    "    s.setMarks(marks)\n",
    "    \n",
    "    print(\"Hii\",s.getName())\n",
    "    print(\"Your Marks is: \", s.getMarks())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99104e96",
   "metadata": {},
   "source": [
    "## Class Methods:\n",
    "Inside method implementation if we are using only class variables (static variables), then such type \n",
    "of methods we should declare as class method.\n",
    "\n",
    "We can declare class method explicitly by using @classmethod decorator. \n",
    "For class method we should provide cls variable at the time of declaration\n",
    "\n",
    "We can call classmethod by using classname or object reference variable.\n",
    "#### Demo Program:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f76ae660",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog walks with 4 legs...\n",
      "Cat walks with 4 legs...\n"
     ]
    }
   ],
   "source": [
    "class Animal: \n",
    "    legs=4 \n",
    "    \n",
    "    @classmethod    # decorators denote a class\n",
    "    def walk(cls,name): \n",
    "        print('{} walks with {} legs...'.format(name,cls.legs)) \n",
    "Animal.walk('Dog') \n",
    "Animal.walk('Cat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "8df33ba6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of objects created for test class: 2\n",
      "The number of objects created for test class: 5\n"
     ]
    }
   ],
   "source": [
    "# Program to track the number of objects created for a class:\n",
    "class Test: \n",
    "    count=0 \n",
    "    def __init__(self): \n",
    "        Test.count =Test.count+1 \n",
    "    @classmethod \n",
    "    def noOfObjects(cls): \n",
    "        print('The number of objects created for test class:',cls.count)\n",
    "        \n",
    "t1=Test() \n",
    "t2=Test() \n",
    "Test.noOfObjects() \n",
    "t3=Test() \n",
    "t4=Test() \n",
    "t5=Test() \n",
    "Test.noOfObjects() "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72750fc6",
   "metadata": {},
   "source": [
    "## Static Methods:\n",
    "In general these methods are general utility methods.\n",
    "\n",
    "Inside these methods we won't use any instance or class variables.\n",
    "\n",
    "Here we won't provide self or cls arguments at the time of declaration.\n",
    "\n",
    "We can declare static method explicitly by using @staticmethod decorator\n",
    "\n",
    "We can access static methods by using classname or object reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "1944fa35",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Sum:  30\n",
      "The Product:  200\n",
      "The average:  15.0\n"
     ]
    }
   ],
   "source": [
    "class Nikhil:\n",
    "    @staticmethod\n",
    "    def add(x,y):\n",
    "        print(\"The Sum: \",x+y)\n",
    "    @staticmethod\n",
    "    def product(x,y):\n",
    "        print(\"The Product: \",x*y)\n",
    "    @staticmethod\n",
    "    def average(x,y):\n",
    "        print(\"The average: \",(x+y)/2)\n",
    "        \n",
    "Nikhil.add(10,20)\n",
    "Nikhil.product(10,20)\n",
    "Nikhil.average(10,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9b009ad",
   "metadata": {},
   "source": [
    "___Note: In general we can use only instance and static methods.Inside static method we can access \n",
    "class level variables by using class name.\n",
    "class methods are most rarely used methods in python.\n",
    "Passing members of one class to another class:___\n",
    "\n",
    "We can access members of one class inside another class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "a9ce02ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee No:  100\n",
      "Employee Name:  Nikhil Yadav\n",
      "Employee Salary:  20000\n",
      "---------------------------\n",
      "Employee No:  100\n",
      "Employee Name:  Nikhil Yadav\n",
      "Employee Salary:  20000\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    def __init__(self,eno,ename,esal):\n",
    "        self.eno = eno\n",
    "        self.ename = ename\n",
    "        self.esal = esal\n",
    "    def display(self):\n",
    "        print(\"Employee No: \",self.eno)\n",
    "        print(\"Employee Name: \",self.ename)\n",
    "        print(\"Employee Salary: \",self.esal)\n",
    "        \n",
    "class Test:\n",
    "    def modify(emp):\n",
    "        emp.esal = emp.esal+10000\n",
    "        emp.display()\n",
    "e = Employee(100,\"Nikhil Yadav\",10000)\n",
    "Test.modify(e)\n",
    "print('---------------------------')\n",
    "e.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1ff76c0",
   "metadata": {},
   "source": [
    "In the above application, Employee class members are available to Test class\n",
    "### Inner classes:\n",
    "Sometimes we can declare a class inside another class,such type of classes are called inner classes.\n",
    "\n",
    "Without existing one type of object if there is no chance of existing another type of object,then we \n",
    "should go for inner classes.\n",
    "#### Example - 1: \n",
    "Without existing Car object there is no chance of existing Engine object. Hence Engine \n",
    "class should be part of Car class.\n",
    "    \n",
    "    class Car:\n",
    "     .....\n",
    "     class Engine:\n",
    "     ......\n",
    "#### Example - 2: \n",
    "Without existing university object there is no chance of existing Department object\n",
    "\n",
    "    class University:\n",
    "     .....\n",
    "     class Department:\n",
    "     ......\n",
    "#### Example - 3:\n",
    "Without existing Human there is no chance of existin Head. Hence Head should be part of Human.\n",
    "\n",
    "    class Human:\n",
    "     class Head:\n",
    "___Note: Without existing outer class object there is no chance of existing inner class object. Hence \n",
    "inner class object is always associated with outer class object.___\n",
    "#### Demo Program-1: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1f5de229",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "outer class object creation\n",
      "inner class object creation\n",
      "inner class method\n"
     ]
    }
   ],
   "source": [
    "class Outer: \n",
    "    def __init__(self): \n",
    "        print(\"outer class object creation\") \n",
    "    class Inner: \n",
    "        def __init__(self): \n",
    "            print(\"inner class object creation\") \n",
    "        def m1(self): \n",
    "            print(\"inner class method\")\n",
    "o=Outer() \n",
    "i=Outer.Inner() # or i = o.inner()\n",
    "i.m1() "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc5c75c1",
   "metadata": {},
   "source": [
    "___Note: The following are various possible syntaxes for calling inner class method___\n",
    "     \n",
    "    1. o=Outer()\n",
    "       i=o.Inner()\n",
    "       i.m1()\n",
    "    \n",
    "    2. i=Outer().Inner()\n",
    "       i.m1()\n",
    "    \n",
    "    3. Outer().Inner().m1()\n",
    "#### Demo Program-2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0b0bca5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name:  Nikhil\n",
      "Dob = 4/7/2000/\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self):\n",
    "        self.name = \"Nikhil\"\n",
    "        self.db = self.Dob()\n",
    "    def display(self):\n",
    "        print(\"Name: \",self.name)\n",
    "    class Dob:\n",
    "        def __init__(self):\n",
    "            self.dd=4\n",
    "            self.mm=7\n",
    "            self.yy=2000\n",
    "        def display(self):\n",
    "            print(\"Dob = {}/{}/{}/\".format(self.dd,self.mm,self.yy))\n",
    "\n",
    "p = Person()\n",
    "p.display()\n",
    "x = p.db\n",
    "x.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "439e3cca",
   "metadata": {},
   "source": [
    "####  Demo Program-3:\n",
    "Inside a class we can declare any number of inner classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "07514859",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello.. Nikhil\n",
      "Talking...\n",
      "Thinking...\n"
     ]
    }
   ],
   "source": [
    "class Human: \n",
    "\n",
    "    def __init__(self):\n",
    "        self.name = 'Nikhil' \n",
    "        self.head = self.Head() \n",
    "        self.brain = self.Brain() \n",
    "    def display(self): \n",
    "        print(\"Hello..\",self.name) \n",
    "\n",
    "    class Head: \n",
    "        def talk(self): \n",
    "            print('Talking...') \n",
    "\n",
    "    class Brain: \n",
    "        def think(self): \n",
    "            print('Thinking...') \n",
    "\n",
    "h=Human() \n",
    "h.display() \n",
    "h.head.talk() \n",
    "h.brain.think()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fa8527f",
   "metadata": {},
   "source": [
    "# Inheritance\n",
    "\n",
    "Deriving a new class from an existing class so that new class inherits all members (attributes + methods) of existing class is called as inheritance.\n",
    "\n",
    "Old class :- Parent class, Base class, Existing class, Super class\n",
    "\n",
    "New class:- Child class, sub class, derived class\n",
    "\n",
    "It is a mechanism that allows you to create a hierarchy of classes that share a set of properties and methods by deriving a class from another class. Inheritance is the capability of one class to derive or inherit the properties from another class. \n",
    "\n",
    "### Benefits of inheritance are: \n",
    "- It represents real-world relationships well.\n",
    "- It provides the reusability of a code. We don’t have to write the same code again and again. Also, it allows us to add more features to a class without modifying it.\n",
    "- It is transitive in nature, which means that if class B inherits from another class A, then all the subclasses of B would automatically inherit from class A.\n",
    "- Inheritance offers a simple, understandable model structure. \n",
    "- Less development and maintenance expenses result from an inheritance. \n",
    "#### Python Inheritance Syntax\n",
    "\n",
    "    Class BaseClass:\n",
    "        {Body}\n",
    "    Class DerivedClass(BaseClass):\n",
    "        {Body}\n",
    "\n",
    "\n",
    "#### Without using inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "b23670be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is employee class method\n",
      "This is manager class method\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    bonus = 2000\n",
    "    def display(self):\n",
    "        print(\"This is employee class method\")\n",
    "class Manager:\n",
    "    bonus1 = 5000\n",
    "    def show(self):\n",
    "        print(\"This is manager class method\")\n",
    "        \n",
    "e1=Employee()\n",
    "m1=Manager()\n",
    "\n",
    "e1.display()\n",
    "m1.show()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0faf3390",
   "metadata": {},
   "source": [
    "# If i accessed employee class bonus by using manager class\n",
    "\n",
    "m1.bonus     -----> AttributeError: 'Manager' object has no attribute 'bonus'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c50a7565",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is employee class method\n",
      "This is manager class method\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2000"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Employee:\n",
    "    bonus = 2000\n",
    "    def display(self):\n",
    "        print(\"This is employee class method\")\n",
    "class Manager(Employee):  # pass the parent class name in the child class but its not visversa \n",
    "    bonus1 = 5000\n",
    "    def show(self):\n",
    "        print(\"This is manager class method\")\n",
    "        \n",
    "e1=Employee()\n",
    "m1=Manager()\n",
    "\n",
    "e1.display()\n",
    "m1.show()\n",
    "\n",
    "# Now we get access employee class by using manager class\n",
    "m1.bonus\n",
    "# e1.bonus1 --> this will get error bcoz we can't access the child class by using parent class now"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9a00ed28",
   "metadata": {},
   "source": [
    "Inheritance uses in both classes\n",
    "If we passed child class in the parent class than it will give error.\n",
    "\n",
    "\n",
    "class Employee1(Manager1):\n",
    "    bonus = 2000\n",
    "    def display(self):\n",
    "        print(\"This is employee class method\")\n",
    "class Manager1:  \n",
    "    bonus1 = 5000\n",
    "    def show(self):\n",
    "        print(\"This is manager class method\")\n",
    "        \n",
    "e1=Employee()\n",
    "m1=Manager()\n",
    "\n",
    "e1.display()\n",
    "m1.show()\n",
    "\n",
    "11.bonus1    -----> SyntaxError: invalid syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e5d7056",
   "metadata": {},
   "source": [
    "### How constructor works in inheritance\n",
    "\n",
    "- By default, constructor of parent class available to child class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "ef0465a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Father constructor called\n",
      "{'vehicle': 'scooter'}\n"
     ]
    }
   ],
   "source": [
    "class Father:\n",
    "    def __init__(self):\n",
    "        print(\"Father constructor called\")\n",
    "        self.vehicle=\"scooter\"\n",
    "class Son(Father):\n",
    "    pass\n",
    "s=Son()\n",
    "print(s.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dfbaef5",
   "metadata": {},
   "source": [
    "### super() Function\n",
    "\n",
    "- Using super() function, we can access parent class properties.\n",
    "- This function returns a temporary object which contains refrence to parent class.\n",
    "- It makes inheritance more manageable and extensible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "0f8151d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Son constructor called\n",
      "{'vehicle': 'BMW'}\n"
     ]
    }
   ],
   "source": [
    "# If we have constructoer in both class than child class excuted your own class constructor\n",
    "class Father:\n",
    "    def __init__(self):\n",
    "        print(\"Father constructor called\")\n",
    "        self.vehicle=\"scooter\"\n",
    "class Son(Father):\n",
    "    def __init__(self):\n",
    "        print(\"Son constructor called\")\n",
    "        self.vehicle=\"BMW\"\n",
    "s=Son()\n",
    "print(s.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "80ec4845",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computer class constructor called\n",
      "Mobile class constractor called\n",
      "{'ram': '8 GB', 'storage': '512 GB', 'model': 'i phone X'}\n"
     ]
    }
   ],
   "source": [
    "class Computer(object):\n",
    "    def __init__(self):\n",
    "        self.ram = \"8 GB\"\n",
    "        self.storage = \"512 GB\"\n",
    "        print(\"Computer class constructor called\")\n",
    "        \n",
    "class Mobile(Computer):\n",
    "    def __init__(self):\n",
    "        \n",
    "        super().__init__()  # Super() basically used as object of parent class\n",
    "        \n",
    "        self.model = \"i phone X\"\n",
    "        print(\"Mobile class constractor called\")\n",
    "Apple=Mobile()\n",
    "print(Apple.__dict__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64f7020d",
   "metadata": {},
   "source": [
    "# Types of Inheritance:-\n",
    "1. Single inheritance\n",
    "2. Multi-level inheritance\n",
    "3. Multiple Inheritance\n",
    "4. Hierarchical Inheritance\n",
    "5. Hybrid Inheritance\n",
    "Depending on number of child and parent class involved\n",
    "\n",
    "- ___Single inheritance___: When a child class inherits from only one parent class, it is called single inheritance. We saw an example above.\n",
    "- ___Multilevel inheritance___: When we have a child and grandchild relationship. \n",
    "- ___Multiple inheritances___: When a child class inherits from multiple parent classes, it is called multiple inheritances. Unlike java, python shows multiple inheritances.\n",
    "\n",
    "- ___Hierarchical inheritance___ More than one derived class are created from a single base.\n",
    "- ___Hybrid inheritance___: This form combines more than one form of inheritance. Basically, it is a blend of more than one type of inheritance.\n",
    "\n",
    "## Single Inheritance\n",
    "- One parent and one child class.\n",
    "- Single inheritance enables a derived class to inherit properties from a single parent class, thus enabling code reusability and the addition of new features to existing code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "caf682e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function is in parent class.\n",
      "This function is in child class.\n"
     ]
    }
   ],
   "source": [
    "# single inheritance\n",
    " \n",
    "# Base class\n",
    "class Parent:\n",
    "    def func1(self):\n",
    "        print(\"This function is in parent class.\")\n",
    "\n",
    "# Derived class \n",
    "class Child(Parent):\n",
    "    def func2(self):\n",
    "        print(\"This function is in child class.\")\n",
    " \n",
    " \n",
    "# Driver's code\n",
    "object = Child()\n",
    "object.func1()\n",
    "object.func2()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e51bd00",
   "metadata": {},
   "source": [
    "## Multi-level Inheritance\n",
    "- Parent class and child class further inhertied into new class forming multiple levels.\n",
    "- In multilevel inheritance, features of the base class and the derived class are further inherited into the new derived class. This is similar to a relationship representing a child and a grandfather. \n",
    "\n",
    "        Eg - Object ---> Parent ---> Child ---> Grand_Child\n",
    "        \n",
    "        \n",
    "                    class class1:  \n",
    "                        <class-suite> \n",
    "                        \n",
    "                        class class2(class1):  \n",
    "                            <class suite>  \n",
    "                            \n",
    "                            class class3(class2):  \n",
    "                                <class suite> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "0eed44af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dog barking\n",
      "Animal Speaking\n",
      "Eating bread...\n"
     ]
    }
   ],
   "source": [
    "class Animal:  \n",
    "    def speak(self):  \n",
    "        print(\"Animal Speaking\")  \n",
    "#The child class Dog inherits the base class Animal  \n",
    "class Dog(Animal):  \n",
    "    def bark(self):  \n",
    "        print(\"dog barking\")  \n",
    "#The child class Dogchild inherits another child class Dog  \n",
    "class DogChild(Dog):  \n",
    "    def eat(self):  \n",
    "        print(\"Eating bread...\")  \n",
    "        \n",
    "d = DogChild()  \n",
    "d.bark()  \n",
    "d.speak()  \n",
    "d.eat()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "71d7af87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lal mani\n",
      "Grandfather name : Lal mani\n",
      "Father name : Rampal\n",
      "Son name : Prince\n"
     ]
    }
   ],
   "source": [
    "# Base class \n",
    "class Grandfather:\n",
    " \n",
    "    def __init__(self, grandfathername):\n",
    "        self.grandfathername = grandfathername\n",
    "\n",
    "# Intermediate class \n",
    "class Father(Grandfather):\n",
    "    def __init__(self, fathername, grandfathername):\n",
    "        self.fathername = fathername\n",
    " \n",
    "        # invoking constructor of Grandfather class\n",
    "        Grandfather.__init__(self, grandfathername)\n",
    "\n",
    "# Derived class\n",
    "class Son(Father):\n",
    "    def __init__(self, sonname, fathername, grandfathername):\n",
    "        self.sonname = sonname\n",
    " \n",
    "        # invoking constructor of Father class\n",
    "        Father.__init__(self, fathername, grandfathername)\n",
    " \n",
    "    def print_name(self):\n",
    "        print('Grandfather name :', self.grandfathername)\n",
    "        print(\"Father name :\", self.fathername)\n",
    "        print(\"Son name :\", self.sonname)\n",
    " \n",
    " \n",
    "#  Driver code\n",
    "s1 = Son('Prince', 'Rampal', 'Lal mani')\n",
    "print(s1.grandfathername)\n",
    "s1.print_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "117b39aa",
   "metadata": {},
   "source": [
    "## Python Multiple inheritance      \n",
    "When a class can be derived from more than one base class this type of inheritance is called multiple inheritances. In multiple inheritances, all the features of the base classes are inherited into the derived class. \n",
    "        \n",
    "        class Base1:  \n",
    "            <class-suite>  \n",
    "  \n",
    "        class Base2:  \n",
    "            <class-suite>  \n",
    "        .  \n",
    "        .  \n",
    "        .  \n",
    "        class BaseN:  \n",
    "            <class-suite>  \n",
    "  \n",
    "        class Derived(Base1, Base2, ...... BaseN):  \n",
    "            <class-suite> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6943994a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uttar Pradesh\n"
     ]
    }
   ],
   "source": [
    "class Country:\n",
    "    office=\"Delhi\"\n",
    "    \n",
    "class State:\n",
    "    office=\"Uttar Pradesh\"\n",
    "    \n",
    "class District(State,Country):     # First class more priority\n",
    "    pass\n",
    "\n",
    "d = District()\n",
    "print(d.office)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "dcee3c63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Father : RAM\n",
      "Mother : SITA\n"
     ]
    }
   ],
   "source": [
    "# Base class1\n",
    "class Mother:\n",
    "    mothername = \"\"\n",
    " \n",
    "    def mother(self):\n",
    "        print(self.mothername)\n",
    "\n",
    "# Base class2\n",
    "class Father:\n",
    "    fathername = \"\"\n",
    " \n",
    "    def father(self):\n",
    "        print(self.fathername)\n",
    "\n",
    "# Derived class \n",
    "class Son(Mother, Father):\n",
    "    def parents(self):\n",
    "        print(\"Father :\", self.fathername)\n",
    "        print(\"Mother :\", self.mothername)\n",
    " \n",
    " \n",
    "# Driver's code\n",
    "s1 = Son()\n",
    "s1.fathername = \"RAM\"\n",
    "s1.mothername = \"SITA\"\n",
    "s1.parents()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "f50a99f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "200\n",
      "0.5\n"
     ]
    }
   ],
   "source": [
    "# Example:-\n",
    "class Calculation1:  \n",
    "    def Summation(self,a,b):  \n",
    "        return a+b;  \n",
    "class Calculation2:  \n",
    "    def Multiplication(self,a,b):  \n",
    "        return a*b;  \n",
    "class Derived(Calculation1,Calculation2):  \n",
    "    def Divide(self,a,b):  \n",
    "        return a/b;  \n",
    "d = Derived()  \n",
    "print(d.Summation(10,20))  \n",
    "print(d.Multiplication(10,20))  \n",
    "print(d.Divide(10,20)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c74110f",
   "metadata": {},
   "source": [
    "## Hierarchical Inheritance: \n",
    "- One Parent class and multiple child classes.\n",
    "\n",
    "\n",
    "When more than one derived class are created from a single base this type of inheritance is called hierarchical inheritance. In this program, we have a parent (base) class and two child (derived) classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "71d5cc16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function is in parent class.\n",
      "This function is in child 1.\n",
      "This function is in parent class.\n",
      "This function is in child 2.\n"
     ]
    }
   ],
   "source": [
    "# Base class\n",
    "class Parent:\n",
    "    def func1(self):\n",
    "        print(\"This function is in parent class.\")\n",
    "\n",
    "# Derived class1\n",
    "class Child1(Parent):\n",
    "    def func2(self):\n",
    "        print(\"This function is in child 1.\")\n",
    "\n",
    "# Derivied class2\n",
    "class Child2(Parent):\n",
    "    def func3(self):\n",
    "        print(\"This function is in child 2.\")\n",
    " \n",
    " \n",
    "# Driver's code\n",
    "object1 = Child1()\n",
    "object2 = Child2()\n",
    "object1.func1()\n",
    "object1.func2()\n",
    "object2.func1()\n",
    "object2.func3()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65780336",
   "metadata": {},
   "source": [
    "## Method Resolution Order (MRO)\n",
    "\n",
    "### Hybrid Inheritance: \n",
    "Inheritance consisting of multiple types of inheritance is called hybrid inheritance.\n",
    "\n",
    "#### What is MRO?\n",
    "MRO represent how properties (attributes+methods) are searched in inheritance.\n",
    "\n",
    "__Rule-1__\n",
    "- Python First search in child class and then goes to parent class.\n",
    "- Priority is to child class.\n",
    "\n",
    "__Rule-2__\n",
    "- MRO follows 'Depth First Left to Right approach'\n",
    "\n",
    "        mro(o) - Object\n",
    "        mro(A) - A,O\n",
    "        mro(B) - B,O\n",
    "        mro(C) - C,O\n",
    "        mro(X) - X,A,B,C,O\n",
    "        mro(Y) - Y,B,C,O\n",
    "        mro(Z) - P,X,Y,A,B,C,O\n",
    "        \n",
    "__Rule-3__\n",
    "- You can use mro() method for knowing mro of any class objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "acf94fed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<class '__main__.Z'>, <class '__main__.X'>, <class '__main__.A'>, <class '__main__.Y'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    pass\n",
    "class B:\n",
    "    pass\n",
    "class C:\n",
    "    pass\n",
    "class X(A,B,C):\n",
    "    pass\n",
    "class Y(B,C):\n",
    "    pass\n",
    "class Z(X,Y):\n",
    "    pass\n",
    "\n",
    "print(Z.mro())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "eb3adda9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function is in school.\n",
      "This function is in student 1. \n"
     ]
    }
   ],
   "source": [
    "class School:\n",
    "    def func1(self):\n",
    "        print(\"This function is in school.\")\n",
    " \n",
    " \n",
    "class Student1(School):\n",
    "    def func2(self):\n",
    "        print(\"This function is in student 1. \")\n",
    " \n",
    " \n",
    "class Student2(School):\n",
    "    def func3(self):\n",
    "        print(\"This function is in student 2.\")\n",
    " \n",
    " \n",
    "class Student3(Student1, School):\n",
    "    def func4(self):\n",
    "        print(\"This function is in student 3.\")\n",
    " \n",
    " \n",
    "# Driver's code\n",
    "object = Student3()\n",
    "object.func1()\n",
    "object.func2()\n",
    "# object.func3() ---> Give Error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00ff5338",
   "metadata": {},
   "source": [
    "# Encapsulation\n",
    "\n",
    "- Wrapping up data and methods working on data together in a single unit (i.e class) is called as encapsulation.\n",
    "\n",
    "- Advantages\n",
    "        \n",
    "        - Security\n",
    "        - Prevents accidental modification\n",
    "        - Simplicity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45d6370e",
   "metadata": {},
   "source": [
    "\n",
    "Encapsulation is one of the fundamental concepts in object-oriented programming (OOP). It describes the idea of wrapping data and the methods that work on data within one unit. This puts restrictions on accessing variables and methods directly and can prevent the accidental modification of data. To prevent accidental change, an object’s variable can only be changed by an object’s method. Those types of variables are known as private variables.\n",
    "\n",
    "A class is an example of encapsulation as it encapsulates all the data that is member functions, variables, etc. The goal of information hiding is to ensure that an object’s state is always valid by controlling access to attributes that are hidden from the outside world.\n",
    "\n",
    "-----------------------------------------------------\n",
    "\n",
    "Consider a real-life example of encapsulation, in a company, there are different sections like the accounts section, finance section, sales section etc. The finance section handles all the financial transactions and keeps records of all the data related to finance. Similarly, the sales section handles all the sales-related activities and keeps records of all the sales. Now there may arise a situation when due to some reason an official from the finance section needs all the data about sales in a particular month. In this case, he is not allowed to directly access the data of the sales section. He will first have to contact some other officer in the sales section and then request him to give the particular data. This is what encapsulation is. Here the data of the sales section and the employees that can manipulate them are wrapped under a single name “sales section”. Using encapsulation also hides the data. In this example, the data of the sections like sales, finance, or accounts are hidden from any other section.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c122a444",
   "metadata": {},
   "source": [
    "### Access Modifiers:\n",
    "\n",
    "- Generally, we restrict data access outside the class in encapsulation.\n",
    "- Encapsulation can be achieved by declaring the data members and methods of a class as private.\n",
    "- Three access specifiers:- public, private,protected\n",
    "\n",
    "### Public members\n",
    "- Accessable anywhere by using object refrence."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "803f9cd1",
   "metadata": {},
   "source": [
    "#### Without using Encapsulation we can modify the data from any class, Its known as a Public members\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "0a123d64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'MCA', 'Specalization': 'AI and ML'}\n",
      "{'name': 'Btec', 'Specalization': 'AI and ML'}\n"
     ]
    }
   ],
   "source": [
    "# Eg\n",
    "class Department:\n",
    "    def __init__(self):\n",
    "        self.name = \"MCA\"\n",
    "        self.Specalization = \"AI and ML\"\n",
    "\n",
    "d1 = Department()\n",
    "print(d1.__dict__)\n",
    "\n",
    "class Students:\n",
    "    def __init__(self):\n",
    "        d1.name = \"Btec\"\n",
    "        self.sname = \"Nikhil\"\n",
    "        self.rno = 33\n",
    "        \n",
    "s1 = Students()\n",
    "\n",
    "print(d1.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc4c1290",
   "metadata": {},
   "source": [
    "### Protected members\n",
    "Protected members (in C++ and JAVA) are those members of the class that cannot be accessed outside the class but can be accessed from within the class and its subclasses. \n",
    "\n",
    "To accomplish this in Python, just follow the convention by prefixing the name of the member by a single underscore “_”.\n",
    "\n",
    "Although the protected variable can be accessed out of the class as well as in the derived class (modified too in derived class), it is customary(convention not a rule) to not access the protected out the class body.\n",
    "\n",
    "___Note: The init method is a constructor and runs as soon as an object of a class is instantiated.___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "01bcf5f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling protected member of base class:  2\n",
      "Calling modified protected member outside class:  3\n",
      "Accessing protected member of obj1:  3\n",
      "Accessing protected member of obj2:  2\n"
     ]
    }
   ],
   "source": [
    "# demonstrate protected members\n",
    " \n",
    "# Creating a base class\n",
    "class Base:\n",
    "    def __init__(self):\n",
    "        # Protected member\n",
    "        self._a = 2\n",
    "\n",
    "# Creating a derived class\n",
    "class Derived(Base):\n",
    "    def __init__(self):\n",
    "        # Calling constructor of\n",
    "        # Base class\n",
    "        Base.__init__(self)\n",
    "        print(\"Calling protected member of base class: \",\n",
    "              self._a)\n",
    "        # Modify the protected variable:\n",
    "        self._a = 3\n",
    "        print(\"Calling modified protected member outside class: \",\n",
    "              self._a)\n",
    "obj1 = Derived() \n",
    "obj2 = Base()\n",
    " \n",
    "# Calling protected member\n",
    "# Can be accessed but should not be done due to convention\n",
    "print(\"Accessing protected member of obj1: \", obj1._a)\n",
    " \n",
    "# Accessing the protected variable outside\n",
    "print(\"Accessing protected member of obj2: \", obj2._a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "3a89c57a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_name': 'MCA', '_Department__Specalization': 'AI and ML'}\n",
      "{'_name': 'Btec', '_Department__Specalization': 'AI and ML', '_Students__Specalization': 'CSE'}\n"
     ]
    }
   ],
   "source": [
    "# Eg\n",
    "class Department:\n",
    "    def __init__(self):\n",
    "        self._name = \"MCA\"  # Protected data\n",
    "        self.__Specalization = \"AI and ML\"  # Private data\n",
    "\n",
    "d1 = Department()\n",
    "print(d1.__dict__)\n",
    "\n",
    "class Students:\n",
    "    def __init__(self):\n",
    "        self.sname = \"Nikhil\"\n",
    "        self.rno = 33\n",
    "        d1._name = \"Btec\"\n",
    "        d1.__Specalization = \"CSE\"\n",
    "s1 = Students()\n",
    "\n",
    "print(d1.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c4fe958",
   "metadata": {},
   "source": [
    "### Private members\n",
    "- Accessible within the class. Accessible via methods only.\n",
    "\n",
    "Private members are similar to protected members, the difference is that the class members declared private should neither be accessed outside the class nor by any base class. In Python, there is no existence of Private instance variables that cannot be accessed except inside a class.\n",
    "\n",
    "\n",
    "However, to define a private member prefix the member name with double underscore “__”.\n",
    "\n",
    "\n",
    "___Note: Python’s private and protected members can be accessed outside the class through python name mangling. ___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "15cfe0b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nikhil\n"
     ]
    }
   ],
   "source": [
    "# demonstrate private members\n",
    " \n",
    "# Creating a Base class\n",
    " \n",
    "class Base:\n",
    "    def __init__(self):\n",
    "        self.a = \"Nikhil\"\n",
    "        self.__c = \"Prakriti\"\n",
    "        # print(self.__c)\n",
    "        \n",
    "# Creating a derived class\n",
    "class Derived(Base):\n",
    "    def __init__(self):\n",
    " \n",
    "        # Calling constructor of\n",
    "        # Base class\n",
    "        Base.__init__(self)\n",
    "        print(\"Calling private member of base class: \")\n",
    "        print(self.__c)\n",
    " \n",
    " \n",
    "# Driver code\n",
    "obj1 = Base()\n",
    "print(obj1.a)\n",
    " \n",
    "# Uncommenting print(obj1.c) will\n",
    "# raise an AttributeError\n",
    " \n",
    "# Uncommenting obj2 = Derived() will\n",
    "# also raise an AtrributeError as\n",
    "# private member of base class\n",
    "# is called inside derived class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aac7465b",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Polymorphism\n",
    "- Poly means many. Morphs means forms.\n",
    "- Polymorphism means 'Many Forms'.\n",
    "- Accessible within class and its subclasses.\n",
    "\n",
    "Polymorphism is mainly used with inheritance. In inheritance, child class inherits the attributes and methods of a parent class. The existing class is called a base class or parent class, and the new class is called a subclass or child class or derived class.\n",
    "\n",
    "\n",
    "In programming, polymorphism means the same function name (but different signatures) being used for different types. The key difference is the data types and number of arguments used in function.\n",
    "\n",
    "#### Eg1: \n",
    "Yourself is best example of polymorphism.In front of Your parents You will have one type of \n",
    "behaviour and with friends another type of behaviour.Same person but different behaviours at \n",
    "different places,which is nothing but polymorphism.\n",
    "#### Eg2: \n",
    "    + operator acts as concatenation and arithmetic addition\n",
    "\n",
    "#### Eg3: \n",
    "    * operator acts as multiplication and repetition operator\n",
    "#### Eg4: \n",
    "The Same method with different implementations in Parent class and child \n",
    "    \n",
    "    classes.(overriding)\n",
    "\n",
    "\n",
    "\n",
    "Related to polymorphism the following 4 topics are important\n",
    "1. Duck Typing Philosophy of Python\n",
    "2. Overloading\n",
    " 1. Operator Overloading\n",
    " 2. Method Overloading\n",
    " 3. Constructor Overloading\n",
    "3. Overriding\n",
    " 1. Method overriding\n",
    " 2. constructor overriding\n",
    "\n",
    "## 1. Duck Typing Philosophy of Python:\n",
    "In Python we cannot specify the type explicitly. Based on provided value at runtime the type will \n",
    "be considered automatically. Hence Python is considered as Dynamically Typed Programming \n",
    "Language.\n",
    "    \n",
    "    def f1(obj):\n",
    "       obj.talk()\n",
    "What is the type of obj? We cannot decide at the beginning. At runtime we can pass any type.Then \n",
    "how we can decide the type?\n",
    "\n",
    "At runtime if 'it walks like a duck and talks like a duck,it must be duck'. Python follows this \n",
    "principle. This is called Duck Typing Philosophy of Python.\n",
    "#### Demo Program:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "ac9ff4af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quack.. Quack..\n",
      "Moew Moew ..\n",
      "Bow Bow..\n",
      "Myaah Myaah ..\n"
     ]
    }
   ],
   "source": [
    "class Duck: \n",
    "    def talk(self): \n",
    "        print('Quack.. Quack..') \n",
    "        \n",
    "class Dog: \n",
    "    def talk(self): \n",
    "        print('Bow Bow..') \n",
    "        \n",
    "class Cat: \n",
    "    def talk(self): \n",
    "        print('Moew Moew ..') \n",
    "\n",
    "class Goat: \n",
    "    def talk(self): \n",
    "        print('Myaah Myaah ..') \n",
    "\n",
    "def f1(obj): \n",
    "    obj.talk() \n",
    "\n",
    "l=[Duck(),Cat(),Dog(),Goat()] \n",
    "for obj in l: \n",
    "    f1(obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d708613",
   "metadata": {},
   "source": [
    "The problem in this approach is if obj does not contain talk() method then we will get \n",
    "AttributeError\n",
    "#### Eg:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "fdd89877",
   "metadata": {},
   "source": [
    "class Duck: \n",
    "    def talk(self): \n",
    "        print('Quack.. Quack..') \n",
    "    \n",
    "class Dog: \n",
    "    def bark(self): \n",
    "        print('Bow Bow..') \n",
    "        \n",
    "def f1(obj): \n",
    "    obj.talk() \n",
    "\n",
    "d=Duck() \n",
    "f1(d) \n",
    "d=Dog() \n",
    "f1(d)\n",
    "\n",
    "AttributeError: 'Dog' object has no attribute 'talk'\n",
    "\n",
    "But we can solve this problem by using hasattr() function.\n",
    "    \n",
    "    hasattr(obj,'attributename')\n",
    "attributename can be method name or variable name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdb4e9ff",
   "metadata": {},
   "source": [
    "#### Demo Program with hasattr() function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "b9da533e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quack.. Quack..\n",
      "Hello Hi...\n",
      "Bow Bow..\n"
     ]
    }
   ],
   "source": [
    "class Duck: \n",
    "    def talk(self): \n",
    "        print('Quack.. Quack..') \n",
    "\n",
    "class Human: \n",
    "    def talk(self): \n",
    "        print('Hello Hi...') \n",
    "\n",
    "class Dog: \n",
    "    def bark(self): \n",
    "        print('Bow Bow..') \n",
    "\n",
    "def f1(obj): \n",
    "    if hasattr(obj,'talk'): \n",
    "        obj.talk() \n",
    "    elif hasattr(obj,'bark'): \n",
    "        obj.bark() \n",
    "\n",
    "d=Duck() \n",
    "f1(d) \n",
    "\n",
    "h=Human() \n",
    "f1(h) \n",
    "\n",
    "d=Dog() \n",
    "f1(d) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "d9acd6e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "# duck typing\n",
    "  \n",
    "class Specialstring:\n",
    "    def __len__(self):\n",
    "        return 21\n",
    "\n",
    "# Driver's code\n",
    "if __name__ == \"__main__\":\n",
    "  \n",
    "    string = Specialstring()\n",
    "    print(len(string))"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7a305a9d",
   "metadata": {},
   "source": [
    "In this case, we call method len() gives the return value from __len__ method. Here __len__ method defines the property of the class Specialstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "253eae72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fly with wings\n",
      "fly with fuel\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Fish' object has no attribute 'fly'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Input \u001b[1;32mIn [59]\u001b[0m, in \u001b[0;36m<cell line: 15>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[38;5;66;03m# Attributes having same name are\u001b[39;00m\n\u001b[0;32m     14\u001b[0m \u001b[38;5;66;03m# considered as duck typing\u001b[39;00m\n\u001b[0;32m     15\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m obj \u001b[38;5;129;01min\u001b[39;00m Bird(), Airplane(), Fish():\n\u001b[1;32m---> 16\u001b[0m     \u001b[43mobj\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfly\u001b[49m()\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Fish' object has no attribute 'fly'"
     ]
    }
   ],
   "source": [
    "# duck typing\n",
    "  \n",
    "class Bird:\n",
    "    def fly(self):\n",
    "        print(\"fly with wings\")\n",
    "class Airplane:\n",
    "    def fly(self):\n",
    "        print(\"fly with fuel\")\n",
    "class Fish:\n",
    "    def swim(self):\n",
    "        print(\"fish swim in sea\")\n",
    "        \n",
    "# Attributes having same name are\n",
    "# considered as duck typing\n",
    "for obj in Bird(), Airplane(), Fish():\n",
    "    obj.fly()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9556d9b",
   "metadata": {},
   "source": [
    "## 2. Overloading:\n",
    "Operator overloading means changing the default behavior of an operator depending on the operands (values) that we use. In other words, we can use the same operator for multiple purposes.\n",
    "\n",
    "\n",
    "We can use same operator or methods for different purposes.\n",
    "#### Eg1: \n",
    "    \n",
    "    + operator can be used for Arithmetic addition and String concatenation\n",
    "     print(10+20)#30\n",
    "     print('nikhil'+'yadav')#nikhilyadav\n",
    "#### Eg2: \n",
    "    \n",
    "    * operator can be used for multiplication and string repetition purposes.\n",
    "     print(10*20)#200\n",
    "     print('nikhil'*3)#nikhilnikhilnikhil\n",
    "#### Eg3:\n",
    "We can use deposit() method to deposit cash or cheque or dd\n",
    "     \n",
    "     deposit(cash)\n",
    "     deposit(cheque)\n",
    "     deposit(dd)\n",
    "\n",
    "There are 3 types of overloading\n",
    "1. Operator Overloading\n",
    "2. Method Overloading\n",
    "3. Constructor Overloading\n",
    "\n",
    "\n",
    "### i) Operator Overloading:\n",
    "We can use the same operator for multiple purposes, which is nothing but operator overloading.\n",
    "\n",
    "Python supports operator overloading.\n",
    "#### Eg1: \n",
    "    \n",
    "    + operator can be used for Arithmetic addition and String concatenation\n",
    "     print(10+20)#30\n",
    "     print('nikhil'+'yadav')#nikhilyadav\n",
    "#### Eg2: \n",
    "    \n",
    "    * operator can be used for multiplication and string repetition purposes.\n",
    "     print(10*20)#200\n",
    "     print('nikhil'*3)#nikhilnikhilnikhil\n",
    "#### Demo program to use + operator for our class objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14938c85",
   "metadata": {},
   "outputs": [],
   "source": [
    "# add 2 numbers\n",
    "print(100 + 200)\n",
    "\n",
    "# concatenate two strings\n",
    "print('Jess' + 'Roy')\n",
    "\n",
    "# merger two list\n",
    "print([10, 20, 30] + ['jessa', 'emma', 'kelly'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3769479f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book: \n",
    "    def __init__(self,pages): \n",
    "        self.pages=pages \n",
    "\n",
    "b1=Book(100) \n",
    "b2=Book(200) \n",
    "print(b1+b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a72f07f1",
   "metadata": {},
   "source": [
    "We can overload + operator to work with Book objects also. i.e Python supports Operator \n",
    "Overloading.\n",
    "\n",
    "For every operator Magic Methods are available. To overload any operator we have to override \n",
    "that Method in our class. \n",
    "\n",
    "    Internally + operator is implemented by using __add__() method.This method is called magic method for + operator. \n",
    "    We have to override this method in our class. \n",
    "#### Demo program to overload + operator for our Book class objects:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fdc60f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book: \n",
    "    def __init__(self,pages): \n",
    "        self.pages=pages \n",
    "\n",
    "    def __add__(self,other): \n",
    "        return self.pages+other.pages \n",
    "\n",
    "b1=Book(100) \n",
    "b2=Book(200) \n",
    "# b2=Book(300)  # It always consider last operation in other.\n",
    "print('The Total Number of Pages:',b1+b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99a5995d",
   "metadata": {},
   "source": [
    "The following is the list of operators and corresponding magic methods.\n",
    "    \n",
    "    + ---> object.__add__(self,other)\n",
    "    - ---> object.__sub__(self,other)\n",
    "    * ---> object.__mul__(self,other)\n",
    "    / ---> object.__div__(self,other)\n",
    "    // ---> object.__floordiv__(self,other)\n",
    "    % ---> object.__mod__(self,other)\n",
    "    ** ---> object.__pow__(self,other)\n",
    "    += ---> object.__iadd__(self,other)\n",
    "    -= ---> object.__isub__(self,other)\n",
    "    *= ---> object.__imul__(self,other)\n",
    "    /= ---> object.__idiv__(self,other)\n",
    "    //= ---> object.__ifloordiv__(self,other)\n",
    "    %= ---> object.__imod__(self,other)\n",
    "    **= ---> object.__ipow__(self,other)\n",
    "    < ---> object.__lt__(self,other)\n",
    "    <= ---> object.__le__(self,other)\n",
    "    > ---> object.__gt__(self,other)\n",
    "    >= ---> object.__ge__(self,other)\n",
    "    == ---> object.__eq__(self,other)\n",
    "    != ---> object.__ne__(self,other)\n",
    "\n",
    "#### Overloading > and <= operators for Student class objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8dd120e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student: \n",
    "    def __init__(self,name,marks): \n",
    "        self.name=name \n",
    "        self.marks=marks \n",
    "    def __gt__(self,other): \n",
    "        return self.marks>other.marks \n",
    "    def __le__(self,other): \n",
    "        return self.marks<=other.marks \n",
    "        \n",
    "\n",
    "print(\"10>20 =\",10>20) \n",
    "s1=Student(\"Nikhil\",100) \n",
    "s2=Student(\"Prakriti\",200) \n",
    "print(\"s1>s2=\",s1>s2) \n",
    "print(\"s1<s2=\",s1<s2) \n",
    "print(\"s1<=s2=\",s1<=s2) \n",
    "print(\"s1>=s2=\",s1>=s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37cc46ff",
   "metadata": {},
   "source": [
    "#### Program to overload multiplication operator to work on Employee objects:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50df8e43",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee: \n",
    "    def __init__(self,name,salary): \n",
    "        self.name=name \n",
    "        self.salary=salary \n",
    "    def __mul__(self,other): \n",
    "        return self.salary*other.days \n",
    "        \n",
    "class TimeSheet: \n",
    "    def __init__(self,name,days): \n",
    "        self.name=name \n",
    "        self.days=days \n",
    " \n",
    "e=Employee('Nikhil',500) \n",
    "t=TimeSheet('Nikhil',22) \n",
    "print('This Month Salary:',e*t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3810614c",
   "metadata": {},
   "source": [
    "### Overloading + operator for custom objects\n",
    "Suppose we have two objects, and we want to add these two objects with a binary + operator. However, it will throw an error if we perform addition because the compiler doesn’t add two objects. See the following example for more details."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "053a8b1a",
   "metadata": {},
   "source": [
    "### ii) Method Overloading:\n",
    "\n",
    "The process of calling the same method with different parameters is known as method overloading. Python does not support method overloading. Python considers only the latest defined method even if you overload the method. Python will raise a TypeError if you overload the method.\n",
    "\n",
    "\n",
    "If 2 methods having same name but different type of arguments then those methods are said to \n",
    "be overloaded methods.\n",
    "    \n",
    "       Eg: m1(int a)\n",
    "         m1(double d)\n",
    "But in Python Method overloading is not possible.\n",
    "\n",
    "If we are trying to declare multiple methods with same name and different number of arguments \n",
    "then Python will always consider only last method.\n",
    "#### Demo Program:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5635698d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def addition(a, b):\n",
    "    c = a + b\n",
    "    print(c)\n",
    "\n",
    "\n",
    "def addition(a, b, c):\n",
    "    d = a + b + c\n",
    "    print(d)\n",
    "\n",
    "\n",
    "# the below line shows an error\n",
    "# addition(4, 5)\n",
    "\n",
    "# This line will call the second product method\n",
    "addition(3, 7, 5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ee6c017",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5): print(i, end=', ')\n",
    "print()\n",
    "for i in range(5, 10): print(i, end=', ')\n",
    "print()\n",
    "for i in range(2, 12, 2): print(i, end=', ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8371d3d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test: \n",
    "    def m1(self): \n",
    "        print('no-arg method') \n",
    "    def m1(self,a): \n",
    "        print('one-arg method') \n",
    "    def m1(self,a,b): \n",
    "        print('two-arg method') \n",
    "\n",
    "t=Test() \n",
    "#t.m1() \n",
    "#t.m1(10) \n",
    "t.m1(10,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2e278bf",
   "metadata": {},
   "source": [
    "In the above program python will consider only last method.\n",
    "#### How we can handle overloaded method requirements in Python:\n",
    "Most of the times, if method with variable number of arguments required then we can handle \n",
    "with default arguments or with variable number of argument methods.\n",
    "#### Demo Program with Default Arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ebb2b3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test: \n",
    "    def sum(self,a=None,b=None,c=None): \n",
    "        if a!=None and b!= None and c!= None: \n",
    "            print('The Sum of 3 Numbers:',a+b+c) \n",
    "        elif a!=None and b!= None: \n",
    "            print('The Sum of 2 Numbers:',a+b) \n",
    "        else: \n",
    "            print('Please provide 2 or 3 arguments') \n",
    "            \n",
    "t=Test()\n",
    "t.sum(10,20) \n",
    "t.sum(10,20,30) \n",
    "t.sum(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f7e3f54",
   "metadata": {},
   "source": [
    "#### Demo Program with Variable Number of Arguments:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a763ad1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test: \n",
    "    def sum(self,*a): \n",
    "        total=0 \n",
    "        for x in a: \n",
    "            total=total+x \n",
    "            print('The Sum:',total) \n",
    "            \n",
    "            \n",
    "t=Test() \n",
    "t.sum(10,20) \n",
    "t.sum(10,20,30) \n",
    "t.sum(10) \n",
    "t.sum() "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da62ed9a",
   "metadata": {},
   "source": [
    "### iii) Constructor Overloading:\n",
    "Constructor overloading is not possible in Python.\n",
    "\n",
    "If we define multiple constructors then the last constructor will be considered.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3413a46a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test: \n",
    "    def __init__(self): \n",
    "        print('No-Arg Constructor') \n",
    "        \n",
    "    def __init__(self,a): \n",
    "        print('One-Arg constructor') \n",
    "        \n",
    "    def __init__(self,a,b): \n",
    "        print('Two-Arg constructor') \n",
    "#t1=Test() \n",
    "#t1=Test(10) \n",
    "t1=Test(10,20) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42bc9e78",
   "metadata": {},
   "source": [
    "In the above program only Two-Arg Constructor is available.\n",
    "\n",
    "But based on our requirement we can declare constructor with default arguments and variable \n",
    "number of arguments.\n",
    "### Constructor with Default Arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "998b2f4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test: \n",
    "    def __init__(self,a=None,b=None,c=None): \n",
    "        print('Constructor with 0|1|2|3 number of arguments') \n",
    "\n",
    "t1=Test() \n",
    "t2=Test(10) \n",
    "t3=Test(10,20) \n",
    "t4=Test(10,20,30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37826fbe",
   "metadata": {},
   "source": [
    "#### Constructor with Variable Number of Arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91169ea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Test: \n",
    "    def __init__(self,*a): \n",
    "        print('Constructor with variable number of arguments') \n",
    "\n",
    "t1=Test() \n",
    "t2=Test(10) \n",
    "t3=Test(10,20) \n",
    "t4=Test(10,20,30) \n",
    "t5=Test(10,20,30,40,50,60) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fc432c8",
   "metadata": {},
   "source": [
    "## Overriding"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c2864fb",
   "metadata": {},
   "source": [
    "### Method overriding:\n",
    "What ever members available in the parent class are by default available to the child class through inheritance. If the child class not satisfied with parent class implementation then child class is allowed to redefine that method in the child class based on its requirement. This concept is called overriding.\n",
    "\n",
    "Overriding concept applicable for both methods and constructors.\n",
    "\n",
    "Using method overriding polymorphism allows us to defines methods in the child class that have the same name as the methods in the parent class. This process of re-implementing the inherited method in the child class is known as Method Overriding.\n",
    "\n",
    "\n",
    "### Polymorphism With Inheritance\n",
    "Polymorphism is mainly used with inheritance. In inheritance, child class inherits the attributes and methods of a parent class. The existing class is called a base class or parent class, and the new class is called a subclass or child class or derived class.\n",
    "\n",
    "Using method overriding polymorphism allows us to defines methods in the child class that have the same name as the methods in the parent class. This process of re-implementing the inherited method in the child class is known as Method Overriding.\n",
    "\n",
    "\n",
    "#### Advantage of method overriding\n",
    "\n",
    "- It is effective when we want to extend the functionality by altering the inherited method. Or the method inherited from the parent class doesn’t fulfill the need of a child class, so we need to re-implement the same method in the child class in a different way.\n",
    "- Method overriding is useful when a parent class has multiple child classes, and one of that child class wants to redefine the method. The other child classes can use the parent class method. Due to this, we don’t need to modification the parent class code\n",
    "#### Demo Program for Method overriding:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb7710b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vehicle:\n",
    "\n",
    "    def __init__(self, name, color, price):\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "        self.price = price\n",
    "\n",
    "    def show(self):\n",
    "        print('Details:', self.name, self.color, self.price)\n",
    "\n",
    "    def max_speed(self):\n",
    "        print('Vehicle max speed is 150')\n",
    "\n",
    "    def change_gear(self):\n",
    "        print('Vehicle change 6 gear')\n",
    "\n",
    "\n",
    "# inherit from vehicle class\n",
    "class Car(Vehicle):\n",
    "    def max_speed(self):\n",
    "        print('Car max speed is 240')\n",
    "\n",
    "    def change_gear(self):\n",
    "        print('Car change 7 gear')\n",
    "\n",
    "\n",
    "# Car Object\n",
    "car = Car('Car x1', 'Red', 20000)\n",
    "car.show()\n",
    "# calls methods from Car class\n",
    "car.max_speed()\n",
    "car.change_gear()\n",
    "\n",
    "# Vehicle Object\n",
    "vehicle = Vehicle('Truck x1', 'white', 75000)\n",
    "vehicle.show()\n",
    "# calls method from a Vehicle class\n",
    "vehicle.max_speed()\n",
    "vehicle.change_gear()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8de9deab",
   "metadata": {},
   "source": [
    "As you can see, due to polymorphism, the Python interpreter recognizes that the max_speed() and change_gear() methods are overridden for the car object. So, it uses the one defined in the child class (Car)\n",
    "\n",
    "On the other hand, the show() method isn’t overridden in the Car class, so it is used from the Vehicle class.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "844ed70f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class P: \n",
    "    def property(self): \n",
    "        print('Gold+Land+Cash+Power') \n",
    "    def marry(self): \n",
    "        print('Nikhil') \n",
    "class C(P): \n",
    "    def marry(self): \n",
    "        print('Prakriti') \n",
    "        \n",
    "c=C() \n",
    "c.property() \n",
    "c.marry()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b5eb9fb",
   "metadata": {},
   "source": [
    "From Overriding method of child class,we can call parent class method also by using super() \n",
    "method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9886d19",
   "metadata": {},
   "outputs": [],
   "source": [
    "class P: \n",
    "    def property(self): \n",
    "        print('Gold+Land+Cash+Power') \n",
    "    def marry(self): \n",
    "        print('Nikhil') \n",
    "class C(P): \n",
    "    def marry(self): \n",
    "        super().marry() \n",
    "        print('Prakriti') \n",
    "\n",
    "c=C() \n",
    "c.property() \n",
    "c.marry()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bffdb80",
   "metadata": {},
   "source": [
    "#### Demo Program for Constructor overriding:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89e7cdc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class P: \n",
    "    def __init__(self): \n",
    "        print('Parent Constructor') \n",
    "    \n",
    "class C(P): \n",
    "    def __init__(self): \n",
    "        print('Child Constructor')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8685058",
   "metadata": {},
   "source": [
    "c=C()In the above example,if child class does not contain constructor then parent class constructor will \n",
    "be executed\n",
    "\n",
    "From child class constuctor we can call parent class constructor by using super() method.\n",
    "### Overrride Built-in Functions\n",
    "\n",
    "In Python, we can change the default behavior of the built-in functions. For example, we can change or extend the built-in functions such as len(), abs(), or divmod() by redefining them in our class. Let’s see the example.\n",
    "\n",
    "Example\n",
    "\n",
    "In this example, we will redefine the function len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "856f2a05",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Shopping:\n",
    "    def __init__(self, basket, buyer):\n",
    "        self.basket = list(basket)\n",
    "        self.buyer = buyer\n",
    "\n",
    "    def __len__(self):\n",
    "        print('Redefine length')\n",
    "        count = len(self.basket)\n",
    "        # count total items in a different way\n",
    "        # pair of shoes and shir+pant\n",
    "        return count * 2\n",
    "\n",
    "shopping = Shopping(['Shoes', 'dress'], 'Jessa')\n",
    "print(len(shopping))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f17f5a37",
   "metadata": {},
   "source": [
    "### Polymorphism In Class methods\n",
    "Polymorphism with class methods is useful when we group different objects having the same method. we can add them to a list or a tuple, and we don’t need to check the object type before calling their methods. Instead, Python will check object type at runtime and call the correct method. Thus, we can call the methods without being concerned about which class type each object is. \n",
    "\n",
    "We assume that these methods exist in each class.\n",
    "\n",
    "\n",
    "Python allows different classes to have methods with the same name.\n",
    "\n",
    "- Let’s design a different class in the same way by adding the same methods in two or more classes.\n",
    "- Next, create an object of each class\n",
    "- Next, add all objects in a tuple.\n",
    "- In the end, iterate the tuple using a for loop and call methods of a object without checking its class.\n",
    "\n",
    "\n",
    "Example\n",
    "\n",
    "\n",
    "In the below example, fuel_type() and max_speed() are the instance methods created in both classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7883f462",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ferrari:\n",
    "    def fuel_type(self):\n",
    "        print(\"Petrol\")\n",
    "\n",
    "    def max_speed(self):\n",
    "        print(\"Max speed 350\")\n",
    "\n",
    "class BMW:\n",
    "    def fuel_type(self):\n",
    "        print(\"Diesel\")\n",
    "\n",
    "    def max_speed(self):\n",
    "        print(\"Max speed is 240\")\n",
    "\n",
    "ferrari = Ferrari()\n",
    "bmw = BMW()\n",
    "\n",
    "# iterate objects of same type\n",
    "for car in (ferrari, bmw):\n",
    "    # call methods without checking class of object\n",
    "    car.fuel_type()\n",
    "    car.max_speed()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c655a5e2",
   "metadata": {},
   "source": [
    "As you can see, we have created two classes Ferrari and BMW. They have the same instance method names fuel_type() and max_speed(). However, we have not linked both the classes nor have we used inheritance.\n",
    "\n",
    "We packed two different objects into a tuple and iterate through it using a car variable. It is possible due to polymorphism because we have added the same method in both classes Python first checks the object’s class type and executes the method present in its class.\n",
    "\n",
    "### Polymorphism with Function and Objects\n",
    "\n",
    "We can create polymorphism with a function that can take any object as a parameter and execute its method without checking its class type. Using this, we can call object actions using the same function instead of repeating method calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4398d2f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ferrari:\n",
    "    def fuel_type(self):\n",
    "        print(\"Petrol\")\n",
    "\n",
    "    def max_speed(self):\n",
    "        print(\"Max speed 350\")\n",
    "\n",
    "class BMW:\n",
    "    def fuel_type(self):\n",
    "        print(\"Diesel\")\n",
    "\n",
    "    def max_speed(self):\n",
    "        print(\"Max speed is 240\")\n",
    "\n",
    "# normal function\n",
    "def car_details(obj):\n",
    "    obj.fuel_type()\n",
    "    obj.max_speed()\n",
    "\n",
    "ferrari = Ferrari()\n",
    "bmw = BMW()\n",
    "\n",
    "car_details(ferrari)\n",
    "car_details(bmw)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "578c8802",
   "metadata": {},
   "source": [
    "### Polymorphism In Built-in Methods\n",
    "The word polymorphism is taken from the Greek words poly (many) and morphism (forms). It means a method can process objects differently depending on the class type or data type.\n",
    "\n",
    "The built-in function reversed(obj) returns the iterable by reversing the given object. For example, if you pass a string to it, it will reverse it. But if you pass a list of strings to it, it will return the iterable by reversing the order of elements (it will not reverse the individual string).\n",
    "\n",
    "Let us see how a built-in method process objects having different data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "233c63fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "students = ['Emma', 'Jessa', 'Kelly']\n",
    "school = 'ABC School'\n",
    "\n",
    "print('Reverse string')\n",
    "for i in reversed('PYnative'):\n",
    "    print(i, end=' ')\n",
    "\n",
    "print('\\nReverse list')\n",
    "for i in reversed(['Emma', 'Jessa', 'Kelly']):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f98335b4",
   "metadata": {},
   "source": [
    "### Following are built-in class functions:-\n",
    "\n",
    "    getattr(object_name, attribute_name)\n",
    "    setattar(object_name, attribute_name, new_value)\n",
    "    delattr(object_name, attribute_name)\n",
    "    hasattr(object_name, attribute_name)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efb00b6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example:\n",
    "class Employee:\n",
    "    '''This is employee class for maintaining employee data'''\n",
    "    def __init__(self,nm,ag):\n",
    "        self.name = nm\n",
    "        self.age = ag\n",
    "        \n",
    "e1 = Employee(\"Nikhil Yadav\",22)\n",
    "e2 = Employee(\"Prakriti Yadav\", 19)\n",
    "\n",
    "print(getattr(e1,'age'))\n",
    "print(getattr(e2,'name'))\n",
    "setattr(e2,'name',\"Chunmun\")\n",
    "print(e2.__dict__)\n",
    "delattr(e2,\"age\")\n",
    "print(e2.__dict__)\n",
    "print(hasattr(e2,\"name\"))\n",
    "print(hasattr(e2,\"enam\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b617e39",
   "metadata": {},
   "source": [
    "### Following are built-in class attributes:-\n",
    "    \n",
    "    __dict__ :- Dictionary containing class's namespace\n",
    "    __doc__ :- Class documentation string\n",
    "    __name__ :- Class Name\n",
    "    __module__ :- Module name in which class is defined\n",
    "    __bases__ :- List of base classes"
   ]
  },
  {
   "cell_type": "raw",
   "id": "26004324",
   "metadata": {},
   "source": [
    "# Example:\n",
    "class Employee:\n",
    "    \n",
    "    \n",
    "e1 = Employee(\"Nikhil Yadav\",22)\n",
    "e2 = Employee(\"Prakriti Yadav\", 19)\n",
    "\n",
    "print(Employee.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbeb17ab",
   "metadata": {},
   "source": [
    "### Isinstance() function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa6fa67f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example:\n",
    "class Demo:\n",
    "    pass\n",
    "d1 = Demo()\n",
    "\n",
    "class Employee:\n",
    "    def __init__(self,name):\n",
    "        self.name = name\n",
    "        \n",
    "e1 = Employee(\"Nikhil\")\n",
    "print(isinstance(e1,Employee))\n",
    "print(isinstance(d1,Employee))\n",
    "\n",
    "# Main used of isinstance:\n",
    "# if isinstance(obj,classname):\n",
    "#     pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd5eca58",
   "metadata": {},
   "source": [
    "# Abstraction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88805042",
   "metadata": {},
   "source": [
    "Abstraction is used to hide the internal functionality of the function from the users. The users only interact with the basic implementation of the function, but inner working is hidden. User is familiar with that \"what function does\" but they don't know \"how it does.\"\n",
    "\n",
    "In simple words, we all use the smartphone and very much familiar with its functions such as camera, voice-recorder, call-dialing, etc., but we don't know how these operations are happening in the background. Let's take another example - When we use the TV remote to increase the volume. We don't know how pressing a key increases the volume of the TV. We only know to press the \"+\" button to increase the volume.\n",
    "\n",
    "\n",
    "That is exactly the abstraction that works in the object-oriented concept.\n",
    "\n",
    "An abstraction is used to hide the irrelevant data/class in order to reduce the complexity. It also enhances the application efficiency. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0178e58e",
   "metadata": {},
   "source": [
    "## Abstract Methods and Classes:\n",
    "\n",
    "An abstract method is a method that is declared, but does not contain implementation. An abstract method in a base class identifies the functionality that should be implemented by all its subclasses. However, since the implementation of an abstract method would differ from one subclass to another, often the method body comprises just a pass statement. Every subclass of the base class will ride this method with its implementation. A class containing abstract methods is called abstract class.Python provides the abc module to use the abstraction in the Python program, syntax as:\n",
    "\n",
    "    from abc import ABC,   \n",
    "    class ClassName(ABC):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3111d66a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The mileage is 30kmph\n",
      "The mileage is 27kmph \n",
      "The mileage is 25kmph \n",
      "The mileage is 24kmph \n"
     ]
    }
   ],
   "source": [
    "# Python program demonstrate  \n",
    "# abstract base class work   \n",
    "\n",
    "from abc import ABC, abstractmethod   \n",
    "class Car(ABC):   \n",
    "    def mileage(self):   \n",
    "        pass  \n",
    "class Tesla(Car):   \n",
    "    def mileage(self):   \n",
    "        print(\"The mileage is 30kmph\")   \n",
    "class Suzuki(Car):   \n",
    "    def mileage(self):   \n",
    "        print(\"The mileage is 25kmph \")   \n",
    "class Duster(Car):   \n",
    "     def mileage(self):   \n",
    "          print(\"The mileage is 24kmph \")   \n",
    "class Renault(Car):   \n",
    "    def mileage(self):   \n",
    "            print(\"The mileage is 27kmph \")  \n",
    "            \n",
    "# Driver code   \n",
    "t= Tesla ()   \n",
    "t.mileage()   \n",
    "  \n",
    "r = Renault()   \n",
    "r.mileage()   \n",
    "  \n",
    "s = Suzuki()   \n",
    "s.mileage()   \n",
    "d = Duster()   \n",
    "d.mileage()  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99b56f27",
   "metadata": {},
   "source": [
    "#### Explanation -\n",
    "\n",
    "In the above code, we have imported the abc module to create the abstract base class. We created the Car class that inherited the ABC class and defined an abstract method named mileage(). We have then inherited the base class from the three different subclasses and implemented the abstract method differently. We created the objects to call the abstract method.\n",
    "\n",
    "\n",
    "Let's understand another example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0640bf05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Triangle has 3 sides\n",
      "I have 4 sides\n",
      "Pentagon has 5 sides\n",
      "Hexagon has 6 sides\n"
     ]
    }
   ],
   "source": [
    "# Python program to define   \n",
    "# abstract class  \n",
    "  \n",
    "from abc import ABC  \n",
    "  \n",
    "class Polygon(ABC):   \n",
    "  \n",
    "   # abstract method   \n",
    "   def sides(self):   \n",
    "      pass  \n",
    "  \n",
    "class Triangle(Polygon):   \n",
    "  \n",
    "     \n",
    "   def sides(self):   \n",
    "      print(\"Triangle has 3 sides\")   \n",
    "  \n",
    "class Pentagon(Polygon):   \n",
    "  \n",
    "     \n",
    "   def sides(self):   \n",
    "      print(\"Pentagon has 5 sides\")   \n",
    "  \n",
    "class Hexagon(Polygon):   \n",
    "  \n",
    "   def sides(self):   \n",
    "      print(\"Hexagon has 6 sides\")   \n",
    "  \n",
    "class square(Polygon):   \n",
    "  \n",
    "   def sides(self):   \n",
    "      print(\"I have 4 sides\")   \n",
    "  \n",
    "# Driver code   \n",
    "t = Triangle()   \n",
    "t.sides()   \n",
    "  \n",
    "s = square()   \n",
    "s.sides()   \n",
    "  \n",
    "p = Pentagon()   \n",
    "p.sides()   \n",
    "  \n",
    "k = Hexagon()   \n",
    "k.sides()   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85bc2ae1",
   "metadata": {},
   "source": [
    "#### Explanation -\n",
    "\n",
    "In the above code, we have defined the abstract base class named Polygon and we also defined the abstract method. This base class inherited by the various subclasses. We implemented the abstract method in each subclass. We created the object of the subclasses and invoke the sides() method. The hidden implementations for the sides() method inside the each subclass comes into play. The abstract method sides() method, defined in the abstract class, is never invoked."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfae76f9",
   "metadata": {},
   "source": [
    "### Points to Remember\n",
    "Below are the points which we should remember about the abstract base class in Python.\n",
    "\n",
    "- An Abstract class can contain the both method normal and abstract method.\n",
    "- An Abstract cannot be instantiated; we cannot create objects for the abstract class.\n",
    "\n",
    "Abstraction is essential to hide the core functionality from the users. We have covered the all the basic concepts of Abstraction in Python.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8b8e96f",
   "metadata": {},
   "source": [
    "# Garbage Collection:\n",
    "In old languages like C++, programmer is responsible for both creation and destruction of \n",
    "objects.Usually programmer taking very much care while creating object, but neglecting \n",
    "destruction of useless objects. Because of his neglectance, total memory can be filled with useless \n",
    "objects which creates memory problems and total application will be down with Out of memory \n",
    "error.\n",
    "\n",
    "But in Python, We have some assistant which is always running in the background to destroy \n",
    "useless objects.Because this assistant the chance of failing Python program with memory \n",
    "problems is very less. This assistant is nothing but Garbage Collector.\n",
    "\n",
    "Hence the main objective of Garbage Collector is to destroy useless objects.\n",
    "\n",
    "If an object does not have any reference variable then that object eligible for Garbage Collection.\n",
    "#### How to enable and disable Garbage Collector in our program:\n",
    "By default Gargbage collector is enabled, but we can disable based on our requirement. In this \n",
    "context we can use the following functions of gc module.\n",
    "### 1. gc.isenabled()\n",
    "     \n",
    "     Returns True if GC enabled\n",
    "### 2. gc.disable()\n",
    "     \n",
    "     To disable GC explicitly\n",
    "### 3. gc.enable()\n",
    "     \n",
    "     To enable GC explicitly\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3adeda9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gc \n",
    "print(gc.isenabled()) \n",
    "gc.disable() \n",
    "print(gc.isenabled()) \n",
    "gc.enable() \n",
    "print(gc.isenabled())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b362ea5",
   "metadata": {},
   "source": [
    "### How to find the number of references of an object:\n",
    "sys module contains getrefcount() function for this purpose.\n",
    "    \n",
    "    sys.getrefcount(objectreference)\n",
    "#### Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10b74691",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys \n",
    "class Test: \n",
    "    pass \n",
    "t1=Test() \n",
    "t2=t1 \n",
    "t3=t1 \n",
    "t4=t1 \n",
    "print(sys.getrefcount(t1)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "150cd6bb",
   "metadata": {},
   "source": [
    "___Note: For every object, Python internally maintains one default reference variable self.___"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba857fe5",
   "metadata": {},
   "source": [
    "In the above program python will consider only last method.\n",
    "#### How we can handle overloaded method requirements in Python:\n",
    "Most of the times, if method with variable number of arguments required then we can handle \n",
    "with default arguments or with variable number of argument methods.\n",
    "#### Demo Program with Default Arguments:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1fd06e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person: \n",
    "    def __init__(self,name,age): \n",
    "        self.name=name \n",
    "        self.age=age \n",
    "        \n",
    "class Employee(Person): \n",
    "    def __init__(self,name,age,eno,esal): \n",
    "        super().__init__(name,age) \n",
    "        self.eno=eno \n",
    "        self.esal=esal \n",
    "        \n",
    "    def display(self): \n",
    "        print('Employee Name:',self.name) \n",
    "        print('Employee Age:',self.age) \n",
    "        print('Employee Number:',self.eno) \n",
    "        print('Employee Salary:',self.esal) \n",
    "        \n",
    "e1=Employee('Nikhil',23,872425,26000) \n",
    "e1.display() \n",
    "e2=Employee('Prakriti',19,872426,36000) \n",
    "e2.display() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34c17f9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example for class:\n",
    "class Student: \n",
    "    '''Hello!'''\n",
    "    def __init__(self): \n",
    "        self.name='Nikhil' \n",
    "        self.age=40 \n",
    "        self.marks=80 \n",
    "\n",
    "    def talk(self): \n",
    "        print(\"Hello I am :\",self.name) \n",
    "        print(\"My Age is:\",self.age) \n",
    "        print(\"My Marks are:\",self.marks)\n",
    "\n",
    "get = Student()   # create Obj\n",
    "get.talk() \n",
    "get.age \n",
    "\n",
    "\n",
    "class Data:\n",
    "    def __init__(self, fname,lname,branch):\n",
    "        self.fname = fname\n",
    "        self.lname = lname\n",
    "        self.branch = branch\n",
    "nikhil = Data('Nikhil','Yadav','MCA')\n",
    "prakriti = Data('Prakriti', 'Yadav', 'BS in Data Science')\n",
    "\n",
    "print(nikhil.fname,prakriti.fname)\n",
    "\n",
    "\n",
    "\n",
    "class Employee:\n",
    "    pass\n",
    "nikhil = Employee()\n",
    "prakriti = Employee()\n",
    "\n",
    "nikhil.name = 'Nikhil Yadav'\n",
    "nikhil.branch = 'MCA'\n",
    "prakriti.name = 'Prakriti Yadav'\n",
    "prakriti.branch = 'BS in Data Science'\n",
    "print(nikhil.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80d94398",
   "metadata": {},
   "source": [
    "#### Make ATM Machine using OOPS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "13334db6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Atm:\n",
    "    \n",
    "# __init__ (Its a Constructor - Constractor is a special function/method that can excute the code automatically)\n",
    "\n",
    "# Now we create Object\n",
    "\n",
    "    def __init__(self):      \n",
    "        \n",
    "        self.pin = ''     # data1             \n",
    "        self.balance = 0  # data2\n",
    "        \n",
    "        self.menu()   # calling the function\n",
    "        \n",
    "    def menu(self):          \n",
    "        user_input = int(input('''\n",
    "        Hello, how would you like to proceed?\n",
    "        - Enter 1 to create pin\n",
    "        - Enter 2 to deposit\n",
    "        - Enter 3 to withdraw\n",
    "        - Enter 4 to check balance\n",
    "        - Enter 5 to exit\n",
    "        '''))\n",
    "        \n",
    "        if user_input==1:\n",
    "            self.create_pin()\n",
    "        elif user_input==2:\n",
    "            self.deposit()\n",
    "        elif user_input==3:\n",
    "            self.withdraw()\n",
    "        elif user_input==4:\n",
    "            self.check_balance()\n",
    "        else:\n",
    "            print(\"Bye\")\n",
    "            \n",
    " # Now we create Methods\n",
    "\n",
    "    def create_pin(self):\n",
    "        self.pin = input(\"Enter your pin: \")\n",
    "        print(\"Pin set successfully\")\n",
    "        \n",
    "    def deposit(self):\n",
    "        temp = input(\"Enter your pin\")\n",
    "        if temp==self.pin:\n",
    "            amount = int(input(\"Enter the amount: \"))\n",
    "            self.balance = self.balance+amount\n",
    "        else:\n",
    "            print(\"Invalid Pin\")\n",
    "            \n",
    "    def withdraw(self):\n",
    "        temp = input(\"Enter your pin\")\n",
    "        if temp==self.pin:\n",
    "            amount = int(input(\"Enter the amount: \"))\n",
    "            if amount<self.balance:\n",
    "                self.balance = self.balance-amount\n",
    "            else:\n",
    "                print(\"Insufficient funds\")\n",
    "        else:\n",
    "            print(\"Invalid Pin\")\n",
    "            \n",
    "        \n",
    "    def check_balance(self):\n",
    "        temp = input(\"Enter your pin\")\n",
    "        if temp==self.pin:\n",
    "            print(\"Your amount is: \", self.balance)\n",
    "        else:\n",
    "            print(\"Invalid Pin\")\n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "sbi = Atm()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b533d7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sbi.check_balance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07c51c68",
   "metadata": {},
   "outputs": [],
   "source": [
    "sbi.deposit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b3f45e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "sbi.check_balance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acf641a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "sbi.withdraw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fc2e50f",
   "metadata": {},
   "outputs": [],
   "source": [
    "sbi.check_balance()"
   ]
  }
 ],
 "metadata": {
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}