05 advance python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02a0bd1b-6614-437c-bfe2-1e7988753e69",
   "metadata": {},
   "outputs": [],
   "source": [
    "Assignment 05 Solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78bdfc19-eaae-409d-966b-fe54babbaadd",
   "metadata": {},
   "source": [
    "Q1. What is the meaning of multiple inheritance?\n",
    "Ans: 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8ad8d542-3e88-42af-be60-04e9f7362038",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Parent_one:\n",
    "    pass\n",
    "class Parent_two:\n",
    "    pass\n",
    "class child(Parent_one,Parent_two):\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4cf0606-e884-4de3-a263-469d10730331",
   "metadata": {},
   "source": [
    "Q2. What is the concept of delegation?\n",
    "Ans: Delegation provides a proxy object for any class thay you want on top of the main class. its like a wrapper to your class so that you 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",
    "Simply Delegation means that you can include a instance of another class as an instance variable, and forward messages to the instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8a8dd60c-4e33-4dd6-8d77-1a5c14aa2848",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey iam back\n",
      "Hey iam back\n",
      "Hey iam back\n",
      "Iam the main class\n"
     ]
    }
   ],
   "source": [
    "class Myclass:\n",
    "    def sayHi(self):\n",
    "        print('Hey iam 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": "65dcc8bc-0e24-46cb-9484-77636d120564",
   "metadata": {},
   "source": [
    "Q3. What is the concept of composition?\n",
    "Ans: In the concept of Composition, a class refers to one or more other classes by using instances of those classes as a 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": "71016a59-21cc-4d71-8887-c5fc19585c62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Salary : 9600\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(800,500)\n",
    "print(obj_emp.annual_salary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ffe1c7-fa4c-40cd-a75a-45efc08046c1",
   "metadata": {},
   "source": [
    "Q4. What are bound methods and how do we use them?\n",
    "Ans: 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": "258457bf-6d5f-4466-821a-4191ff972705",
   "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": "22ee9e55-5f43-4389-a802-1c76615b7383",
   "metadata": {},
   "source": [
    "Q5. What is the purpose of pseudoprivate attributes?\n",
    "Ans: 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": "e252277b-e1ec-435f-b950-4c4b1d5eed57",
   "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"
   ]
  }
 ],
 "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}