Assignment 5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c8b14701",
   "metadata": {},
   "source": [
    "# 1. What is the meaning of multiple inheritance?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "754b1156",
   "metadata": {},
   "source": [
    "Inheritence is nothing but reusing the code of Parent class by the child class. Similary when a child class inherits its properties from multiple Parent classes this scenario is called Multiple Inheritence. Multiple inheritance is a feature of some object-oriented computer programming languages in which an object or class can inherit features from more than one parent object or parent class. It is distinct from single inheritance, where an object or class may only inherit from one particular object or class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4791b525",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parent_1:\n",
    "    pass\n",
    "class Parent_2:\n",
    "    pass\n",
    "class child(Parent_1,Parent_2):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "551c2927",
   "metadata": {},
   "source": [
    "# Q2. What is the concept of delegation?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fc13fc2",
   "metadata": {},
   "source": [
    "Delegation provides a proxy object for any class that we want on top of the main class. It is like a wrapper to our class so that we can access limited resources of the main class.\n",
    "\n",
    "It wraps the object of main class into a smaller object with limited access\n",
    "\n",
    "In simple terms, Delegation means that we can include an instance of another class as an instance variable, and forward messages to the instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "16911598",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey i am back\n",
      "Hey i am back\n",
      "Hey i am back\n",
      "Iam the main class\n"
     ]
    }
   ],
   "source": [
    "class Myclass:\n",
    "    def sayHi(self):\n",
    "        print('Hey i am back')\n",
    "    def whoAmI(self):\n",
    "        print('Iam the main class')\n",
    "class NewClass:\n",
    "    def __init__(self,obj):\n",
    "        self.main = obj\n",
    "    def welcome(self):\n",
    "        self.main.sayHi()\n",
    "\n",
    "m = Myclass()        \n",
    "n = NewClass(m)\n",
    "m.sayHi()\n",
    "n.main.sayHi()\n",
    "n.welcome()\n",
    "n.main.whoAmI()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe46116c",
   "metadata": {},
   "source": [
    "# Q3. What is the concept of composition?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "936d6689",
   "metadata": {},
   "source": [
    "In the concept of Composition, a class refers to one or more other classes by using instances of those classes as an instance variable. Irrespective of inheritence, In this approach all the parent class members are not inherited into child class, but only required methods from a class are used by using class instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d4277bcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Salary : 21600\n"
     ]
    }
   ],
   "source": [
    "class Salary:\n",
    "    def __init__(self,pay):\n",
    "        self.pay = pay\n",
    "    def get_total(self):\n",
    "        return self.pay*12\n",
    "    \n",
    "class Employee:\n",
    "    def __init__(self,pay,bonus):\n",
    "        self.pay = pay\n",
    "        self.bonus = bonus\n",
    "        self.obj_salary = Salary(self.pay)\n",
    "    def annual_salary(self):\n",
    "        return f'Total Salary : {str(self.obj_salary.get_total())}'\n",
    "\n",
    "obj_emp = Employee(1800,1500)\n",
    "print(obj_emp.annual_salary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b45987b",
   "metadata": {},
   "source": [
    "# Q4. What are bound methods and how do we use them?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bc718a0",
   "metadata": {},
   "source": [
    "If a function is an attribute of class and it is accessed via the instances, they are called bound methods. A bound method is one that has self as its first argument. Since these are dependent on the instance of classes, these are also known as instance methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2233e633",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Called method_one\n",
      "Called method_two\n",
      "Called method_two\n",
      "Called method_three\n"
     ]
    }
   ],
   "source": [
    "class Test:\n",
    "    def method_one(self): # bound method\n",
    "        print(\"Called method_one\")\n",
    "    @classmethod\n",
    "    def method_two(cls): # unbound method\n",
    "        print(\"Called method_two\")\n",
    "    @staticmethod\n",
    "    def method_three(): # static method\n",
    "        print(\"Called method_three\")\n",
    "\n",
    "test = Test()\n",
    "test.method_one() # accessing through instance object\n",
    "test.method_two() # accessing through instance object\n",
    "Test.method_two() # accessing directly through class\n",
    "Test.method_three() # accessing directly through class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fc6844d",
   "metadata": {},
   "source": [
    "# Q5. What is the purpose of pseudoprivate attributes?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b277f54e",
   "metadata": {},
   "source": [
    "Pseudoprivate attributes are also useful in larger frameworks or tools, both to avoid introducing new method names that might accidentally hide definitions elsewhere in the class tree and to reduce the chance of internal methods being replaced by names defined lower in the tree. If a method is intended for use only within a class that may be mixed into other classes, the double underscore prefix ensures that the method won't interfere with other names in the tree, especially in multiple-inheritance scenarios\n",
    "\n",
    "Pseudoprivate names also prevent subclasses from accidentally redefining the internal method's names,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "65865b98",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Super:\n",
    "    def method(self): # A real application method\n",
    "        pass\n",
    "class Tool:\n",
    "    def _method(self): # becomes _Tool_method\n",
    "        pass\n",
    "    def other(self): # uses internal method\n",
    "        self._method()\n",
    "class Subl(Tool,Super):\n",
    "    def actions(self):\n",
    "        self.method()\n",
    "class Sub2(Tool):\n",
    "    def __init__(self):\n",
    "        self.method = 99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f95828cc",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}